@brytdesigns/web-component-core 1.1.7 → 3.1.0

package/dist/main/index.d.ts

@@ -1,15 +1,73 @@
 // Generated by dts-bundle-generator v9.5.1
 
 import { BodyScrollOptions } from 'body-scroll-lock-upgrade';
-import { ComponentType as mComponentType, ICustomElement, createContext, provide as _provide } from 'component-register';
+import { ComponentType as ComponentRegisterComponentType, ICustomElement, createContext, provide as _provide } from 'component-register';
 import { FocusTrap, Options } from 'focus-trap';
 import { AnimationGeneratorType, AnimationPlaybackControlsWithThen, Easing, RepeatType } from 'motion';
-import { Accessor } from 'solid-js';
+import { Accessor, EffectFunction, EffectOptions } from 'solid-js';
 
-export declare const createFocusTrap: (element: HTMLElement, options?: Accessor<Options>) => Accessor<FocusTrap>;
-export declare function abortablePromise(promise: Promise<any>, signal: AbortSignal): Promise<unknown>;
-export declare function controlsToPromise(controls: AnimationPlaybackControlsWithThen): Promise<unknown>;
 export declare function awaitAllAnimations(promises: AnimationPlaybackControlsWithThen[]): Promise<unknown>;
+/**
+ * Whether the visitor has asked their device to reduce motion. Read on every
+ * open and close, so changing the setting applies without a reload.
+ */
+export declare function shouldReduceMotion(): boolean;
+/**
+ * Whether the direction this animation was started for has since been left.
+ *
+ * Toggling mid-animation re-runs the caller's effect, whose cleanup calls
+ * `animation.complete()` — which resolves the promise, so the `.then` below
+ * fires as a microtask *after* the new direction has already applied its
+ * styles, and would undo them. Callers flip their own flag in that cleanup;
+ * the default is for callers that never re-enter.
+ */
+export type IsStale = () => boolean;
+/**
+ * Whether the browser supports `hidden="until-found"`, which keeps a closed
+ * content's text reachable by find-in-page and text-fragment links.
+ */
+export declare function supportsHiddenUntilFound(): boolean;
+/**
+ * Puts the content in its open end state, without animating.
+ *
+ * `flow-root` rather than `block`, so the panel is always a block formatting
+ * context and always contains its children's margins.
+ *
+ * Without it the box model changed underneath the animation. The measurement
+ * runs before `overflow: hidden` is applied, so a child margin collapsed out
+ * of the panel and the target came back short; the animation then set
+ * `overflow: hidden`, which *makes* the panel a BFC, so the same content
+ * suddenly needed more room than the target allowed and stayed clipped — and
+ * snapped into place when `overflow` was removed at the end. A `<p>` with
+ * default margins inside a plain `<div>` measured 24px and rendered 56px.
+ *
+ * `flow-root` is the modern way to ask for a BFC without clipping, which is
+ * exactly what is wanted here: `overflow: hidden` during the animation now
+ * changes nothing about the box, only what is painted outside it.
+ */
+export declare function showContent(element: HTMLElement): void;
+/**
+ * Puts the content in its closed end state, without animating.
+ *
+ * Where supported, the content is closed with `hidden="until-found"` rather
+ * than `display: none`, so find-in-page can still match its text. The inline
+ * styles zero the box, which `until-found` alone leaves its padding, and keep
+ * it a block: `until-found` hides content through `content-visibility`, which
+ * does not apply to an inline box, and custom elements are inline by default.
+ */
+export declare function hideContent(element: HTMLElement): void;
+/**
+ * Calls `callback` when find-in-page or a text-fragment link matches text
+ * inside the closed content. It fires before the browser removes `hidden` and
+ * scrolls to the match, so layout changes made synchronously in `callback`
+ * are settled by the time the browser scrolls. Returns a cleanup function.
+ */
+export declare function onContentRevealed(element: HTMLElement, callback: () => void): () => void;
+/** Animates the content open from zero height. */
+export declare function expandContent(element: HTMLElement, isStale?: IsStale): import("motion").AnimationPlaybackControlsWithThen;
+/** Animates the content closed to zero height. */
+export declare function collapseContent(element: HTMLElement, isStale?: IsStale): import("motion").AnimationPlaybackControlsWithThen;
+export declare function controlsToPromise(controls: AnimationPlaybackControlsWithThen): Promise<unknown>;
 export declare function getTransitionConfig(style: CSSStyleDeclaration): {
 	bounce: number | undefined;
 	bounceDamping: number | undefined;
@@ -34,30 +92,248 @@ export declare function getTransitionConfig(style: CSSStyleDeclaration): {
 	velocity: number | undefined;
 	visualDuration: number | undefined;
 };
-export declare function toHyphenated(str: string): string;
-export type ComponentType<T> = mComponentType<T>;
-export type CorrectComponentOptions = {
-	element: HTMLElement & ICustomElement;
+export declare const createFocusTrap: (element: HTMLElement, options?: Accessor<Options>) => import("solid-js").SourceAccessor<FocusTrap>;
+/**
+ * Shared accessibility helpers.
+ *
+ * Everything here was either duplicated across leaf packages or missing
+ * entirely while each overlay reimplemented a piece of it.
+ */
+/**
+ * Visually hidden, still in the accessibility tree.
+ *
+ * Byte-identical to the copies that lived in `keen-slider-scrollbar`,
+ * `keen-slider-navigation-arrows` and `keen-slider-navigation-dots` — three
+ * copies of the same clip-rect incantation, none of which could be fixed
+ * without finding the other two.
+ */
+export declare const srOnly = "border-width:0 !important;clip:rect(1px, 1px, 1px, 1px) !important;-webkit-clip-path:inset(50%) !important;clip-path:inset(50%) !important;height:1px !important;margin-top:-1px !important;margin-bottom:-1px !important;margin-right:-1px !important;margin-left:-1px !important;overflow:hidden !important;padding-top:0 !important;padding-bottom:0 !important;padding-right:0 !important;padding-left:0 !important;position:absolute !important;width:1px !important;white-space:nowrap !important;";
+/**
+ * The panel belonging to this overlay — `dialog-content`, `drawer-content` or
+ * `modal-panel` — skipping the panels of overlays nested inside it.
+ *
+ * Same shape as `findDisclosureContent`, and for the same reason: a plain
+ * `querySelector` finds a nested overlay's panel first whenever the nested one
+ * is authored above its parent's own content.
+ */
+export declare function findOverlayPanel(context: HTMLElement, panelTag: string, selector?: string): HTMLElement | null;
+export type FocusReturn = {
+	/** Remembers what holds focus now, to restore later. */
+	record: () => void;
+	/** Restores it. Returns whether focus was actually moved. */
+	restore: () => boolean;
 };
-export type CorrectComponentType<T> = (props: T, options: CorrectComponentOptions) => unknown;
-export declare function customElement<T extends object>(tagName: string, props: T, Component?: ComponentType<T>, ...rest: ((C: ComponentType<T>) => ComponentType<T>)[]): import("component-register/types/utils").ComponentType<any>;
-export declare function customShadowlessElement<T extends object>(tagName: string, props: T, Component?: ComponentType<T>, ...rest: ((C: ComponentType<T>) => ComponentType<T>)[]): import("component-register/types/utils").ComponentType<any>;
-export declare const correctElementType: <T>(component: CorrectComponentType<T>) => ComponentType<T>;
-export declare function isCustomElement(element: any): element is ICustomElement & HTMLElement;
-export declare function getContextFromProvider<T>(context: ReturnType<typeof createContext>, element: Element): T;
+/**
+ * Remembers where focus came from when an overlay opens, and puts it back when
+ * the overlay closes.
+ *
+ * `focus-trap` already does this, but only while a trap is active — so an
+ * overlay with `should-trap-focus="false"` dropped focus on the floor, and a
+ * keyboard user was returned to the top of the document. Keeping it separate
+ * means focus return is a property of opening and closing rather than a
+ * side effect of trapping.
+ *
+ * Focus already inside the overlay is not recorded: that is where focus is
+ * going, not where it came from, and restoring to it would strand the user in
+ * a hidden subtree.
+ */
+export declare function createFocusReturn(element: HTMLElement): FocusReturn;
+export type EscapeHandlerOptions = {
+	/** The overlay root — the element carrying `is-open`. */
+	element: HTMLElement;
+	/** Called when Escape should close this overlay. */
+	onEscape: () => void;
+	/** Checked at key time, so toggling the attribute takes effect at once. */
+	isEnabled?: () => boolean;
+	/** Overridable for tests; defaults to the three overlay context tags. */
+	selector?: string;
+};
+/**
+ * Closes the topmost overlay on Escape. Returns its own teardown.
+ *
+ * This exists because Escape was previously `focus-trap`'s `escapeDeactivates`
+ * option, which has two consequences nobody wanted: Escape did nothing at all
+ * unless focus trapping was *also* on, and the two settings could not be
+ * configured independently even though they are different promises to the
+ * user.
+ *
+ * Only the innermost open overlay responds, so Escape inside a nested dialog
+ * closes that dialog rather than collapsing the whole stack.
+ */
+export declare function createEscapeHandler({ element, onEscape, isEnabled, selector, }: EscapeHandlerOptions): () => void;
+export type Politeness = "polite" | "assertive";
+/**
+ * Announces a message to assistive tech through a single shared live region.
+ *
+ * One region for the whole page, not one per component: a live region has to
+ * be in the DOM *before* its content changes for the change to be announced,
+ * so a component that creates one and fills it in the same tick announces
+ * nothing. Creating it once, on first use, sidesteps that.
+ *
+ * The text is cleared and set on a later tick for the same reason in reverse —
+ * writing identical text is not a change, so a screen reader stays silent when
+ * the same message is announced twice in a row.
+ */
+export declare function announce(message: string, politeness?: Politeness): void;
+export declare const disableBodyScroll: (element: ICustomElement & HTMLElement, options?: BodyScrollOptions) => void;
+export declare const enableBodyScroll: (element: ICustomElement & HTMLElement) => void;
 export declare function checkLoaded(): boolean;
-export declare function invokeOnLoaded(fn: () => void, { signal }: {
-	signal?: AbortSignal;
-}): void;
+export type ContextRef = {
+	id: symbol;
+};
+export declare class RemoteContextError extends Error {
+	readonly target: unknown;
+	constructor(message: string, target: unknown);
+}
+export type RemoteContextOptions = {
+	/**
+	 * Map a `target` to the element that actually provides the context.
+	 *
+	 * Synchronous by design — it answers "which element, given the DOM as it is
+	 * now". Waiting for the element to appear is the helper's job, and it
+	 * re-runs `resolve` on each mutation, so a strategy never has to implement
+	 * retrying itself.
+	 *
+	 * Defaults to `document.querySelector(target)`, falling back to the host
+	 * element when `target` is empty.
+	 */
+	resolve?: (target: string | undefined, host: HTMLElement) => Element | null;
+	/** Label used in warnings and errors. Defaults to the context's symbol. */
+	name?: string;
+};
+/**
+ * Build a hook that resolves one context from a *lateral* element.
+ *
+ * ```ts
+ * export const useDrawerAt = createRemoteContext<DrawerContext>(DrawerContextState);
+ * ```
+ */
+export declare function createRemoteContext<T>(context: ContextRef, { resolve, name }?: RemoteContextOptions): (target: () => string | undefined, host: HTMLElement) => import("solid-js").SourceAccessor<T & ({} | null)>;
 /**
- * Creates a HOF to ensure that a given callback is invoked only after the context for the element is ready.
- * */
-export declare function createWithElementContext<Context extends ReturnType<typeof createContext>, ContextState = null>(context: Context): <D extends any>(target: string | Accessor<string> | Accessor<() => Element>, dependencies: Accessor<D> | undefined, cb: (context: ContextState, dependencies: D) => void | (() => void)) => void;
+ * ARIA wiring for disclosure widgets (accordion and collapsible): the
+ * trigger's button reports whether its content is open and which content it
+ * controls.
+ */
+/**
+ * The element a trigger exposes to assistive tech: the trigger itself when it
+ * has `role="button"`, otherwise the first button inside it.
+ */
+export declare function findDisclosureControl(trigger: HTMLElement): HTMLElement | null;
+/**
+ * The content belonging to the same item as `trigger`, skipping the content of items
+ * nested inside it.
+ */
+export declare function findDisclosureContent(trigger: HTMLElement, itemTag: string, contentTag: string): HTMLElement | null;
+/** Returns the element's id, assigning a unique `${prefix}-N` if it has none. */
+export declare function ensureId(element: HTMLElement, prefix: string): string;
+/**
+ * Points the control's `aria-controls` at the content, unless the markup already
+ * set one. Returns whether the control is linked.
+ */
+export declare function linkDisclosureControl(control: HTMLElement, content: HTMLElement | null, idPrefix: string): boolean;
 export type Format = "currency" | "number" | "boolean" | "invert_boolean" | string;
 export declare function formatValue(format: Format, value: unknown): any;
+/**
+ * Read a `component-register` context off an element, synchronously.
+ *
+ * The imperative counterpart to `createRemoteContext`: no waiting, no effect,
+ * callable from a plain `<script>` in a Liquid template when you already know
+ * the element is there. Deliberately kept separate — forcing an async,
+ * effect-shaped API on this use case would break theme scripts for no gain.
+ */
+export declare function getContextFromProvider<T>(context: ReturnType<typeof createContext>, element: Element): T & ({} | null);
 export declare function getTemplateContent(element: HTMLElement, state: string): DocumentFragment | null;
-export declare const disableBodyScroll: (element: ICustomElement & HTMLElement, options?: BodyScrollOptions) => void;
-export declare const enableBodyScroll: (element: ICustomElement & HTMLElement) => void;
+/**
+ * `createEffect` whose **apply phase cannot take the page down**.
+ *
+ * ## Why this exists
+ *
+ * Solid 2 treats the two phases of an effect very differently, and only one
+ * of them is dangerous. Measured against the installed `2.0.0-rc.14`, in
+ * `tests/component/reactivity-halt.test.ts`:
+ *
+ * | throw site        | rest of the page            |
+ * | ----------------- | --------------------------- |
+ * | component setup   | unaffected                  |
+ * | compute phase     | unaffected — the run is skipped and logged |
+ * | **apply phase**   | **every computation on the page stops, permanently** |
+ *
+ * An uncaught apply-phase throw calls the runtime's `haltReactivity`, which
+ * is module-level global state. On a Shopify page every Bryt element shares
+ * one `solid-js` singleton, so one bad attribute on one element freezes every
+ * drawer, modal, slider and the cart until the shopper reloads.
+ *
+ * ## Why not an error boundary
+ *
+ * Because it does not work. `createErrorBoundary` is documented as catching
+ * this, and it does not in rc.14: the characterization test drives a
+ * subscribed boundary around the throwing effect and the fallback never runs
+ * while the rest of the page still freezes. Upstream's own guidance in
+ * `@solidjs/signals`' `createEffect` docblock is the half that holds —
+ *
+ * > The **effect phase is different**: it is your own imperative code, so
+ * > handle failures with `try/catch` where they occur.
+ *
+ * — which is all this function is. If a later release makes boundaries catch
+ * it, the characterization test starts failing and says so.
+ *
+ * The compute phase is deliberately NOT guarded. It is already non-fatal, and
+ * swallowing a compute error would hide a genuine reactivity bug behind an
+ * effect that silently stops updating.
+ *
+ * @param compute the tracking phase — reads signals, returns the value
+ * @param apply the imperative phase, may return a cleanup function
+ * @param options forwarded to `createEffect`; `name` is used in the report
+ */
+export declare function createGuardedEffect<const T>(compute: (prev: T | undefined) => T, apply: EffectFunction<NoInfer<T>, T>, options?: EffectOptions): void;
+export declare function invokeOnLoaded(fn: () => void, { signal }: {
+	signal?: AbortSignal;
+}): void;
+export declare function isCustomElement(element: any): element is ICustomElement & HTMLElement;
+/**
+ * Closing an overlay has to close the overlays inside it.
+ *
+ * A dialog nested in another is hidden along with its parent, but
+ * nothing changes its own `isOpen`. It keeps reporting `is-open="true"` while
+ * invisible, never fires `drawer:close`, never releases what it holds, and
+ * reappears still open when the parent is opened again.
+ *
+ * These components have no concept of a parent — no containment check anywhere
+ * in either package — so the relationship is established here, at the point
+ * where it is needed, rather than threaded through context.
+ *
+ * Writing a *descendant's* attribute is allowed in Solid 2. Writing the
+ * component's own prop is what `REACTIVE_WRITE_IN_OWNED_SCOPE` forbids, which
+ * is why this takes the element rather than a setter.
+ */
+/**
+ * Both kinds, not just the caller's own. A modal inside a drawer is hidden by
+ * the drawer closing exactly as another drawer would be, and is left in the
+ * same wrong state.
+ */
+export declare const OVERLAY_SELECTOR = "dialog-context, drawer-context, modal-context";
+export declare function closeNestedOverlays(root: HTMLElement, selector?: string): HTMLElement[];
+export type ComponentType<T> = ComponentRegisterComponentType<T>;
+/**
+ * `component-register` types `options.element` as a bare `ICustomElement`, but
+ * at runtime it is always also an `HTMLElement`. Every component in this repo
+ * needs the DOM half.
+ */
+export type CorrectComponentOptions = {
+	element: HTMLElement & ICustomElement;
+};
+export type CorrectComponentType<T> = (props: T, options: CorrectComponentOptions) => unknown;
+export type Middleware<T> = (Component: ComponentType<T>) => ComponentType<T>;
+export declare function customElement<T extends object>(tagName: string, props: T, Component: CorrectComponentType<T>, ...rest: Middleware<T>[]): import("component-register/types/utils").ComponentType<any>;
+export declare function customShadowlessElement<T extends object>(tagName: string, props: T, Component: CorrectComponentType<T>, ...rest: Middleware<T>[]): import("component-register/types/utils").ComponentType<any>;
+/**
+ * @deprecated The narrowing is built into `customElement` and
+ * `customShadowlessElement` now, so this is a type-level identity. It is kept
+ * only so packages still on Solid 1 keep compiling during the migration;
+ * delete the call rather than porting it.
+ */
+export declare const correctElementType: <T>(component: CorrectComponentType<T>) => CorrectComponentType<T>;
+export declare function toHyphenated(str: string): string;
 export type Path<T> = T extends readonly (infer U)[] ? `${number}` | `${number}.${Path<U>}` : T extends object ? {
 	[K in keyof T & (string | number)]: T[K] extends object | any[] ? `${K}` | `${K}.${Path<T[K]>}` : `${K}`;
 }[keyof T & (string | number)] : never;
@@ -89,10 +365,6 @@ export type BaseOptions<RootData = any, Props = any> = {
 	name: string;
 	Component?: CorrectComponentType<Props>;
 };
-export declare const makePathDataComponent: <RootData = any, Props = any>({ useRootData, hooks, name, }: BaseOptions<RootData>) => CorrectComponentType<{
-	propertyName: Path<RootData>;
-	format?: Format;
-} & Props>;
 export declare const makePathDataArrayComponent: <RootData = any, Props = any>({ useRootData, hooks, name, arrayItemName, }: BaseOptions<RootData> & {
 	arrayItemName: string;
 }) => CorrectComponentType<{
@@ -102,5 +374,10 @@ export declare const makePathDataArrayComponent: <RootData = any, Props = any>({
 export declare const makePathDataArrayItemComponent: <RootData = any, Props extends {
 	itemIndex: Path<RootData>;
 } = any>({ hooks, name, }: BaseOptions<RootData, Props>) => CorrectComponentType<Props>;
+export declare const makePathDataComponent: <RootData = any, Props = any>({ useRootData, hooks, name, }: BaseOptions<RootData>) => CorrectComponentType<{
+	propertyName: Path<RootData>;
+	format?: Format;
+} & Props>;
+export declare function abortablePromise(promise: Promise<any>, signal: AbortSignal): Promise<unknown>;
 
 export {};

package/dist/main/index.js

@@ -1,7 +1,28 @@
-export * from './focusTrap/index.js';
-export * from './promise/index.js';
-export * from './animation/index.js';
-export * from './utils/index.js';
-export * from './hooks/index.js';
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map
+import { awaitAllAnimations } from "./animation/awaitAllAnimations.js";
+import { collapseContent, expandContent, hideContent, onContentRevealed, shouldReduceMotion, showContent, supportsHiddenUntilFound } from "./animation/content.js";
+import { controlsToPromise } from "./animation/controlsToPromise.js";
+import { getTransitionConfig } from "./animation/getTransitionConfig.js";
+import "./animation/index.js";
+import { createFocusTrap } from "./focusTrap/index.js";
+import { OVERLAY_SELECTOR, closeNestedOverlays } from "./utils/nested-overlays.js";
+import { announce, createEscapeHandler, createFocusReturn, findOverlayPanel, srOnly } from "./utils/a11y.js";
+import { createGuardedEffect } from "./utils/guarded-effect.js";
+import { disableBodyScroll, enableBodyScroll } from "./utils/body-scroll-lock.js";
+import { checkLoaded } from "./utils/checkLoaded.js";
+import { RemoteContextError, createRemoteContext } from "./utils/createRemoteContext.js";
+import { ensureId, findDisclosureContent, findDisclosureControl, linkDisclosureControl } from "./utils/disclosure.js";
+import { formatValue } from "./utils/formatValue.js";
+import { getContextFromProvider } from "./utils/getContextFromProvider.js";
+import { getTemplateContent } from "./utils/getTemplateContent.js";
+import { invokeOnLoaded } from "./utils/invokeOnLoaded.js";
+import { isCustomElement } from "./utils/isCustomElement.js";
+import { correctElementType, customElement, customShadowlessElement } from "./utils/solid-element.js";
+import { toHyphenated } from "./utils/toHyphenated.js";
+import "./utils/index.js";
+import { makeFullPropertyPathContext } from "./hooks/makePathContextHooks.js";
+import { makePathDataArrayComponent } from "./hooks/makePathDataArrayComponent.js";
+import { makePathDataArrayItemComponent } from "./hooks/makePathDataArrayItemComponent.js";
+import { makePathDataComponent } from "./hooks/makePathDataComponent.js";
+import "./hooks/index.js";
+import { abortablePromise } from "./promise/abortablePromise.js";
+export { OVERLAY_SELECTOR, RemoteContextError, abortablePromise, announce, awaitAllAnimations, checkLoaded, closeNestedOverlays, collapseContent, controlsToPromise, correctElementType, createEscapeHandler, createFocusReturn, createFocusTrap, createGuardedEffect, createRemoteContext, customElement, customShadowlessElement, disableBodyScroll, enableBodyScroll, ensureId, expandContent, findDisclosureContent, findDisclosureControl, findOverlayPanel, formatValue, getContextFromProvider, getTemplateContent, getTransitionConfig, hideContent, invokeOnLoaded, isCustomElement, linkDisclosureControl, makeFullPropertyPathContext, makePathDataArrayComponent, makePathDataArrayItemComponent, makePathDataComponent, onContentRevealed, shouldReduceMotion, showContent, srOnly, supportsHiddenUntilFound, toHyphenated };

package/dist/main/promise/abortablePromise.js

@@ -1,19 +1,14 @@
+//#region src/promise/abortablePromise.ts
 function abortablePromise(promise, signal) {
-  if (signal.aborted) {
-    return new Promise((_, rej) => rej(signal.reason));
-  }
-  return new Promise(async (res, rej) => {
-    signal.addEventListener(
-      "abort",
-      () => {
-        rej(signal.reason);
-      },
-      { once: true }
-    );
-    promise.then(res);
-  });
+	if (signal.aborted) return new Promise((_, rej) => rej(signal.reason));
+	return new Promise((res, rej) => {
+		signal.addEventListener("abort", () => {
+			rej(signal.reason);
+		}, { once: true });
+		promise.then(res, rej);
+	});
 }
-
+//#endregion
 export { abortablePromise };
-//# sourceMappingURL=abortablePromise.js.map
+
 //# sourceMappingURL=abortablePromise.js.map

package/dist/main/promise/abortablePromise.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/promise/abortablePromise.ts"],"names":[],"mappings":"AAAO,SAAS,gBAAA,CAAiB,SAAuB,MAAqB,EAAA;AAC3E,EAAA,IAAI,OAAO,OAAS,EAAA;AAClB,IAAO,OAAA,IAAI,QAAQ,CAAC,CAAA,EAAG,QAAQ,GAAI,CAAA,MAAA,CAAO,MAAM,CAAC,CAAA;AAAA;AAGnD,EAAA,OAAO,IAAI,OAAA,CAAQ,OAAO,GAAA,EAAK,GAAQ,KAAA;AACrC,IAAO,MAAA,CAAA,gBAAA;AAAA,MACL,OAAA;AAAA,MACA,MAAM;AACJ,QAAA,GAAA,CAAI,OAAO,MAAM,CAAA;AAAA,OACnB;AAAA,MACA,EAAE,MAAM,IAAK;AAAA,KACf;AACA,IAAA,OAAA,CAAQ,KAAK,GAAG,CAAA;AAAA,GACjB,CAAA;AACH","file":"abortablePromise.js","sourcesContent":["export function abortablePromise(promise: Promise<any>, signal: AbortSignal) {\n  if (signal.aborted) {\n    return new Promise((_, rej) => rej(signal.reason));\n  }\n\n  return new Promise(async (res, rej) => {\n    signal.addEventListener(\n      \"abort\",\n      () => {\n        rej(signal.reason);\n      },\n      { once: true },\n    );\n    promise.then(res);\n  });\n}\n"]}
+{"version":3,"file":"abortablePromise.js","names":[],"sources":["../../../src/promise/abortablePromise.ts"],"sourcesContent":["export function abortablePromise(promise: Promise<any>, signal: AbortSignal) {\n\tif (signal.aborted) {\n\t\treturn new Promise((_, rej) => rej(signal.reason));\n\t}\n\n\treturn new Promise((res, rej) => {\n\t\tsignal.addEventListener(\n\t\t\t\"abort\",\n\t\t\t() => {\n\t\t\t\trej(signal.reason);\n\t\t\t},\n\t\t\t{ once: true },\n\t\t);\n\t\t// Both settlement paths are forwarded. The previous `promise.then(res)`\n\t\t// dropped rejection, so a rejected input left the returned promise pending\n\t\t// forever unless the signal happened to abort. The `async` executor it sat\n\t\t// in compounded that: a throw inside an async executor rejects the\n\t\t// executor's own discarded promise, never the one being constructed.\n\t\tpromise.then(res, rej);\n\t});\n}\n"],"mappings":";AAAA,SAAgB,iBAAiB,SAAuB,QAAqB;CAC5E,IAAI,OAAO,SACV,OAAO,IAAI,SAAS,GAAG,QAAQ,IAAI,OAAO,MAAM,CAAC;CAGlD,OAAO,IAAI,SAAS,KAAK,QAAQ;EAChC,OAAO,iBACN,eACM;GACL,IAAI,OAAO,MAAM;EAClB,GACA,EAAE,MAAM,KAAK,CACd;EAMA,QAAQ,KAAK,KAAK,GAAG;CACtB,CAAC;AACF"}

package/dist/main/promise/index.js

@@ -1,3 +1,2 @@
-export * from './abortablePromise.js';
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map
+import { abortablePromise } from "./abortablePromise.js";
+export { abortablePromise };

package/dist/main/utils/a11y.js

@@ -0,0 +1,133 @@
+import { OVERLAY_SELECTOR } from "./nested-overlays.js";
+//#region src/utils/a11y.ts
+/**
+* Shared accessibility helpers.
+*
+* Everything here was either duplicated across leaf packages or missing
+* entirely while each overlay reimplemented a piece of it.
+*/
+/**
+* Visually hidden, still in the accessibility tree.
+*
+* Byte-identical to the copies that lived in `keen-slider-scrollbar`,
+* `keen-slider-navigation-arrows` and `keen-slider-navigation-dots` — three
+* copies of the same clip-rect incantation, none of which could be fixed
+* without finding the other two.
+*/
+var srOnly = `border-width:0 !important;clip:rect(1px, 1px, 1px, 1px) !important;-webkit-clip-path:inset(50%) !important;clip-path:inset(50%) !important;height:1px !important;margin-top:-1px !important;margin-bottom:-1px !important;margin-right:-1px !important;margin-left:-1px !important;overflow:hidden !important;padding-top:0 !important;padding-bottom:0 !important;padding-right:0 !important;padding-left:0 !important;position:absolute !important;width:1px !important;white-space:nowrap !important;`;
+/**
+* The panel belonging to this overlay — `dialog-content`, `drawer-content` or
+* `modal-panel` — skipping the panels of overlays nested inside it.
+*
+* Same shape as `findDisclosureContent`, and for the same reason: a plain
+* `querySelector` finds a nested overlay's panel first whenever the nested one
+* is authored above its parent's own content.
+*/
+function findOverlayPanel(context, panelTag, selector = OVERLAY_SELECTOR) {
+	for (const panel of Array.from(context.querySelectorAll(panelTag))) if (panel.closest(selector) === context) return panel;
+	return null;
+}
+/**
+* Remembers where focus came from when an overlay opens, and puts it back when
+* the overlay closes.
+*
+* `focus-trap` already does this, but only while a trap is active — so an
+* overlay with `should-trap-focus="false"` dropped focus on the floor, and a
+* keyboard user was returned to the top of the document. Keeping it separate
+* means focus return is a property of opening and closing rather than a
+* side effect of trapping.
+*
+* Focus already inside the overlay is not recorded: that is where focus is
+* going, not where it came from, and restoring to it would strand the user in
+* a hidden subtree.
+*/
+function createFocusReturn(element) {
+	let previous = null;
+	return {
+		record() {
+			const active = document.activeElement;
+			if (!(active instanceof HTMLElement) || active === document.body || element.contains(active)) {
+				previous = null;
+				return;
+			}
+			previous = active;
+		},
+		restore() {
+			const target = previous;
+			previous = null;
+			if (!target || !target.isConnected) return false;
+			target.focus();
+			return true;
+		}
+	};
+}
+/**
+* Whether this overlay is the innermost open one.
+*
+* Nesting is established by containment rather than a registry, matching
+* `closeNestedOverlays` — these components have no concept of a parent.
+*/
+function isTopmostOpenOverlay(element, selector) {
+	if (element.getAttribute("is-open") !== "true") return false;
+	for (const nested of Array.from(element.querySelectorAll(selector))) if (nested.getAttribute("is-open") === "true") return false;
+	return true;
+}
+/**
+* Closes the topmost overlay on Escape. Returns its own teardown.
+*
+* This exists because Escape was previously `focus-trap`'s `escapeDeactivates`
+* option, which has two consequences nobody wanted: Escape did nothing at all
+* unless focus trapping was *also* on, and the two settings could not be
+* configured independently even though they are different promises to the
+* user.
+*
+* Only the innermost open overlay responds, so Escape inside a nested dialog
+* closes that dialog rather than collapsing the whole stack.
+*/
+function createEscapeHandler({ element, onEscape, isEnabled, selector = OVERLAY_SELECTOR }) {
+	const controller = new AbortController();
+	document.addEventListener("keydown", (event) => {
+		if (event.key !== "Escape") return;
+		if (isEnabled && !isEnabled()) return;
+		if (!isTopmostOpenOverlay(element, selector)) return;
+		event.stopPropagation();
+		onEscape();
+	}, { signal: controller.signal });
+	return () => controller.abort();
+}
+var liveRegion = null;
+/** The one shared live region, created on first use. */
+function getLiveRegion() {
+	if (liveRegion?.isConnected) return liveRegion;
+	liveRegion = document.createElement("div");
+	liveRegion.setAttribute("data-bryt-announcer", "");
+	liveRegion.setAttribute("aria-atomic", "true");
+	liveRegion.setAttribute("style", srOnly);
+	document.body.appendChild(liveRegion);
+	return liveRegion;
+}
+/**
+* Announces a message to assistive tech through a single shared live region.
+*
+* One region for the whole page, not one per component: a live region has to
+* be in the DOM *before* its content changes for the change to be announced,
+* so a component that creates one and fills it in the same tick announces
+* nothing. Creating it once, on first use, sidesteps that.
+*
+* The text is cleared and set on a later tick for the same reason in reverse —
+* writing identical text is not a change, so a screen reader stays silent when
+* the same message is announced twice in a row.
+*/
+function announce(message, politeness = "polite") {
+	if (!message) return;
+	const region = getLiveRegion();
+	region.setAttribute("aria-live", politeness);
+	region.textContent = "";
+	window.setTimeout(() => {
+		if (region.isConnected) region.textContent = message;
+	}, 50);
+}
+//#endregion
+export { announce, createEscapeHandler, createFocusReturn, findOverlayPanel, srOnly };
+
+//# sourceMappingURL=a11y.js.map

package/dist/main/utils/a11y.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"a11y.js","names":[],"sources":["../../../src/utils/a11y.ts"],"sourcesContent":["import { OVERLAY_SELECTOR } from \"./nested-overlays.js\";\n\n/**\n * Shared accessibility helpers.\n *\n * Everything here was either duplicated across leaf packages or missing\n * entirely while each overlay reimplemented a piece of it.\n */\n\n/**\n * Visually hidden, still in the accessibility tree.\n *\n * Byte-identical to the copies that lived in `keen-slider-scrollbar`,\n * `keen-slider-navigation-arrows` and `keen-slider-navigation-dots` — three\n * copies of the same clip-rect incantation, none of which could be fixed\n * without finding the other two.\n */\nexport const srOnly = `border-width:0 !important;clip:rect(1px, 1px, 1px, 1px) !important;-webkit-clip-path:inset(50%) !important;clip-path:inset(50%) !important;height:1px !important;margin-top:-1px !important;margin-bottom:-1px !important;margin-right:-1px !important;margin-left:-1px !important;overflow:hidden !important;padding-top:0 !important;padding-bottom:0 !important;padding-right:0 !important;padding-left:0 !important;position:absolute !important;width:1px !important;white-space:nowrap !important;`;\n\n/**\n * The panel belonging to this overlay — `dialog-content`, `drawer-content` or\n * `modal-panel` — skipping the panels of overlays nested inside it.\n *\n * Same shape as `findDisclosureContent`, and for the same reason: a plain\n * `querySelector` finds a nested overlay's panel first whenever the nested one\n * is authored above its parent's own content.\n */\nexport function findOverlayPanel(\n\tcontext: HTMLElement,\n\tpanelTag: string,\n\tselector: string = OVERLAY_SELECTOR,\n): HTMLElement | null {\n\tfor (const panel of Array.from(\n\t\tcontext.querySelectorAll<HTMLElement>(panelTag),\n\t)) {\n\t\tif (panel.closest(selector) === context) return panel;\n\t}\n\treturn null;\n}\n\nexport type FocusReturn = {\n\t/** Remembers what holds focus now, to restore later. */\n\trecord: () => void;\n\t/** Restores it. Returns whether focus was actually moved. */\n\trestore: () => boolean;\n};\n\n/**\n * Remembers where focus came from when an overlay opens, and puts it back when\n * the overlay closes.\n *\n * `focus-trap` already does this, but only while a trap is active — so an\n * overlay with `should-trap-focus=\"false\"` dropped focus on the floor, and a\n * keyboard user was returned to the top of the document. Keeping it separate\n * means focus return is a property of opening and closing rather than a\n * side effect of trapping.\n *\n * Focus already inside the overlay is not recorded: that is where focus is\n * going, not where it came from, and restoring to it would strand the user in\n * a hidden subtree.\n */\nexport function createFocusReturn(element: HTMLElement): FocusReturn {\n\tlet previous: HTMLElement | null = null;\n\n\treturn {\n\t\trecord() {\n\t\t\tconst active = document.activeElement;\n\t\t\tif (\n\t\t\t\t!(active instanceof HTMLElement) ||\n\t\t\t\tactive === document.body ||\n\t\t\t\telement.contains(active)\n\t\t\t) {\n\t\t\t\tprevious = null;\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tprevious = active;\n\t\t},\n\n\t\trestore() {\n\t\t\tconst target = previous;\n\t\t\tprevious = null;\n\t\t\t// A trigger rendered by a section that re-rendered while the overlay\n\t\t\t// was open is gone; focusing it throws nothing but moves nothing\n\t\t\t// either, and the browser would leave focus on <body>.\n\t\t\tif (!target || !target.isConnected) return false;\n\t\t\ttarget.focus();\n\t\t\treturn true;\n\t\t},\n\t};\n}\n\nexport type EscapeHandlerOptions = {\n\t/** The overlay root — the element carrying `is-open`. */\n\telement: HTMLElement;\n\t/** Called when Escape should close this overlay. */\n\tonEscape: () => void;\n\t/** Checked at key time, so toggling the attribute takes effect at once. */\n\tisEnabled?: () => boolean;\n\t/** Overridable for tests; defaults to the three overlay context tags. */\n\tselector?: string;\n};\n\n/**\n * Whether this overlay is the innermost open one.\n *\n * Nesting is established by containment rather than a registry, matching\n * `closeNestedOverlays` — these components have no concept of a parent.\n */\nfunction isTopmostOpenOverlay(element: HTMLElement, selector: string) {\n\tif (element.getAttribute(\"is-open\") !== \"true\") return false;\n\n\tfor (const nested of Array.from(\n\t\telement.querySelectorAll<HTMLElement>(selector),\n\t)) {\n\t\tif (nested.getAttribute(\"is-open\") === \"true\") return false;\n\t}\n\n\treturn true;\n}\n\n/**\n * Closes the topmost overlay on Escape. Returns its own teardown.\n *\n * This exists because Escape was previously `focus-trap`'s `escapeDeactivates`\n * option, which has two consequences nobody wanted: Escape did nothing at all\n * unless focus trapping was *also* on, and the two settings could not be\n * configured independently even though they are different promises to the\n * user.\n *\n * Only the innermost open overlay responds, so Escape inside a nested dialog\n * closes that dialog rather than collapsing the whole stack.\n */\nexport function createEscapeHandler({\n\telement,\n\tonEscape,\n\tisEnabled,\n\tselector = OVERLAY_SELECTOR,\n}: EscapeHandlerOptions): () => void {\n\tconst controller = new AbortController();\n\n\tdocument.addEventListener(\n\t\t\"keydown\",\n\t\t(event: KeyboardEvent) => {\n\t\t\tif (event.key !== \"Escape\") return;\n\t\t\tif (isEnabled && !isEnabled()) return;\n\t\t\tif (!isTopmostOpenOverlay(element, selector)) return;\n\n\t\t\t// Stops an ancestor overlay's handler seeing the same key, in case one\n\t\t\t// is bound on a container rather than the document.\n\t\t\tevent.stopPropagation();\n\t\t\tonEscape();\n\t\t},\n\t\t{ signal: controller.signal },\n\t);\n\n\treturn () => controller.abort();\n}\n\nexport type Politeness = \"polite\" | \"assertive\";\n\nlet liveRegion: HTMLElement | null = null;\n\n/** The one shared live region, created on first use. */\nfunction getLiveRegion(): HTMLElement {\n\tif (liveRegion?.isConnected) return liveRegion;\n\n\tliveRegion = document.createElement(\"div\");\n\t// A stable hook, so a test can find the region without guessing at which\n\t// `[aria-live]` on the page belongs to it.\n\tliveRegion.setAttribute(\"data-bryt-announcer\", \"\");\n\tliveRegion.setAttribute(\"aria-atomic\", \"true\");\n\tliveRegion.setAttribute(\"style\", srOnly);\n\tdocument.body.appendChild(liveRegion);\n\n\treturn liveRegion;\n}\n\n/**\n * Announces a message to assistive tech through a single shared live region.\n *\n * One region for the whole page, not one per component: a live region has to\n * be in the DOM *before* its content changes for the change to be announced,\n * so a component that creates one and fills it in the same tick announces\n * nothing. Creating it once, on first use, sidesteps that.\n *\n * The text is cleared and set on a later tick for the same reason in reverse —\n * writing identical text is not a change, so a screen reader stays silent when\n * the same message is announced twice in a row.\n */\nexport function announce(message: string, politeness: Politeness = \"polite\") {\n\tif (!message) return;\n\n\tconst region = getLiveRegion();\n\tregion.setAttribute(\"aria-live\", politeness);\n\tregion.textContent = \"\";\n\n\twindow.setTimeout(() => {\n\t\t// Another announcement may have replaced the region in the meantime.\n\t\tif (region.isConnected) region.textContent = message;\n\t}, 50);\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAiBA,IAAa,SAAS;;;;;;;;;AAUtB,SAAgB,iBACf,SACA,UACA,WAAmB,kBACE;CACrB,KAAK,MAAM,SAAS,MAAM,KACzB,QAAQ,iBAA8B,QAAQ,CAC/C,GACC,IAAI,MAAM,QAAQ,QAAQ,MAAM,SAAS,OAAO;CAEjD,OAAO;AACR;;;;;;;;;;;;;;;AAuBA,SAAgB,kBAAkB,SAAmC;CACpE,IAAI,WAA+B;CAEnC,OAAO;EACN,SAAS;GACR,MAAM,SAAS,SAAS;GACxB,IACC,EAAE,kBAAkB,gBACpB,WAAW,SAAS,QACpB,QAAQ,SAAS,MAAM,GACtB;IACD,WAAW;IACX;GACD;GACA,WAAW;EACZ;EAEA,UAAU;GACT,MAAM,SAAS;GACf,WAAW;GAIX,IAAI,CAAC,UAAU,CAAC,OAAO,aAAa,OAAO;GAC3C,OAAO,MAAM;GACb,OAAO;EACR;CACD;AACD;;;;;;;AAmBA,SAAS,qBAAqB,SAAsB,UAAkB;CACrE,IAAI,QAAQ,aAAa,SAAS,MAAM,QAAQ,OAAO;CAEvD,KAAK,MAAM,UAAU,MAAM,KAC1B,QAAQ,iBAA8B,QAAQ,CAC/C,GACC,IAAI,OAAO,aAAa,SAAS,MAAM,QAAQ,OAAO;CAGvD,OAAO;AACR;;;;;;;;;;;;;AAcA,SAAgB,oBAAoB,EACnC,SACA,UACA,WACA,WAAW,oBACyB;CACpC,MAAM,aAAa,IAAI,gBAAgB;CAEvC,SAAS,iBACR,YACC,UAAyB;EACzB,IAAI,MAAM,QAAQ,UAAU;EAC5B,IAAI,aAAa,CAAC,UAAU,GAAG;EAC/B,IAAI,CAAC,qBAAqB,SAAS,QAAQ,GAAG;EAI9C,MAAM,gBAAgB;EACtB,SAAS;CACV,GACA,EAAE,QAAQ,WAAW,OAAO,CAC7B;CAEA,aAAa,WAAW,MAAM;AAC/B;AAIA,IAAI,aAAiC;;AAGrC,SAAS,gBAA6B;CACrC,IAAI,YAAY,aAAa,OAAO;CAEpC,aAAa,SAAS,cAAc,KAAK;CAGzC,WAAW,aAAa,uBAAuB,EAAE;CACjD,WAAW,aAAa,eAAe,MAAM;CAC7C,WAAW,aAAa,SAAS,MAAM;CACvC,SAAS,KAAK,YAAY,UAAU;CAEpC,OAAO;AACR;;;;;;;;;;;;;AAcA,SAAgB,SAAS,SAAiB,aAAyB,UAAU;CAC5E,IAAI,CAAC,SAAS;CAEd,MAAM,SAAS,cAAc;CAC7B,OAAO,aAAa,aAAa,UAAU;CAC3C,OAAO,cAAc;CAErB,OAAO,iBAAiB;EAEvB,IAAI,OAAO,aAAa,OAAO,cAAc;CAC9C,GAAG,EAAE;AACN"}