@astryxdesign/core 0.7.5-canary.fccd771 → 0.7.5

package/dist/gestures/VelocityTracker.d.ts

@@ -0,0 +1,51 @@
+import type { Point, TouchSample } from './types.js';
+export interface VelocityTrackerOptions {
+    /**
+     * A contact that has not moved for longer than this (ms) before its
+     * release releases at 0 (spec:AST-100 FR2).
+     */
+    stillness?: number;
+}
+export declare class VelocityTracker {
+    private readonly stillness;
+    /** The newest sample added, moved or not. */
+    private newest;
+    /**
+     * The newest moved samples, oldest first (the touch-down counts as the
+     * first); the filter reads the last three.
+     */
+    private moved;
+    /** Moved samples since the touch-down. */
+    private moves;
+    /** The newest pan value, and the one before it. */
+    private pan;
+    private previousPan;
+    constructor(options?: VelocityTrackerOptions);
+    /** Forget every sample (a new gesture). */
+    reset(): void;
+    /**
+     * Record a position. Timestamps must not go backwards (an older sample is
+     * ignored), and a moved sample at the newest moved sample's timestamp
+     * replaces it. A sample at the newest position is not motion: it changes
+     * no velocity.
+     */
+    add(x: number, y: number, time: number): void;
+    /** Record every sample in order. */
+    addSamples(samples: ReadonlyArray<TouchSample>): void;
+    /** The newest sample, if any. */
+    get lastSample(): TouchSample | null;
+    /**
+     * The pan's velocity in px/s. Pass the release's event time to read the
+     * release velocity of a dragged surface: 0 after a rest longer than the
+     * stillness interval, or with fewer than two moved samples (AST-100 FR2).
+     */
+    velocity(releaseTime?: number): Point;
+    /**
+     * A scrolling surface's release velocity in px/s (paging, a wheel): 0.25
+     * times the newest pan value plus 0.75 times the previous one, with the
+     * same stillness and two-moved-sample rules (AST-100 FR2).
+     */
+    scrollVelocity(releaseTime: number): Point;
+    private releases;
+}
+//# sourceMappingURL=VelocityTracker.d.ts.map

package/dist/gestures/VelocityTracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VelocityTracker.d.ts","sourceRoot":"","sources":["../../src/gestures/VelocityTracker.ts"],"names":[],"mappings":"AAqCA,OAAO,KAAK,EAAC,KAAK,EAAE,WAAW,EAAC,MAAM,SAAS,CAAC;AAEhD,MAAM,WAAW,sBAAsB;IACrC;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAaD,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,6CAA6C;IAC7C,OAAO,CAAC,MAAM,CAA4B;IAC1C;;;OAGG;IACH,OAAO,CAAC,KAAK,CAAqB;IAClC,0CAA0C;IAC1C,OAAO,CAAC,KAAK,CAAK;IAClB,mDAAmD;IACnD,OAAO,CAAC,GAAG,CAAe;IAC1B,OAAO,CAAC,WAAW,CAAe;gBAEtB,OAAO,GAAE,sBAA2B;IAIhD,2CAA2C;IAC3C,KAAK,IAAI,IAAI;IAQb;;;;;OAKG;IACH,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAwB7C,oCAAoC;IACpC,UAAU,CAAC,OAAO,EAAE,aAAa,CAAC,WAAW,CAAC,GAAG,IAAI;IAMrD,iCAAiC;IACjC,IAAI,UAAU,IAAI,WAAW,GAAG,IAAI,CAEnC;IAED;;;;OAIG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,KAAK;IAOrC;;;;OAIG;IACH,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,KAAK;IAO1C,OAAO,CAAC,QAAQ;CAQjB"}

package/dist/gestures/VelocityTracker.js

@@ -0,0 +1,186 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file VelocityTracker.ts
+ * @input Timestamped positions of a moving contact, and the release time
+ * @output Exports VelocityTracker, the one velocity tracker every continuous
+ *   recognizer uses (architecture:interaction-modality INV10,
+ *   spec:AST-100 FR1, FR2)
+ * @position Pure math under packages/core/src/gestures; no DOM
+ *
+ * What a release hands to a spring or a deceleration: the finger's velocity
+ * when it lifted, in px per SECOND (UIKit's unit for `velocity(in:)`).
+ *
+ * One filter, iOS's measured blend, updated on each MOVED sample (a sample
+ * at the newest position is not motion):
+ *
+ * - A pan's velocity is 0.2 times the newest interval's velocity plus 0.8
+ *   times the previous interval's (an interval runs from one moved sample to
+ *   the next; the touch-down counts as the first). With one interval so far
+ *   it is that interval, as UIKit reports it. It reproduces every value
+ *   UIKit reported on six HID streams, and like UIKit's it reacts a frame
+ *   late to an acceleration.
+ * - A scrolling surface's release (paging, a wheel) is 0.25 times the newest
+ *   pan value plus 0.75 times the previous one.
+ *
+ * A release (`velocity(releaseTime)`, `scrollVelocity(releaseTime)`) reads 0
+ * when the contact was still for longer than the stillness interval before
+ * lifting, the one difference from iOS, whose filter never decays and so
+ * flings after a rest; and 0 with fewer than two moved samples.
+ *
+ * Feed it one sample per input event: coalesced samples would change its
+ * timing.
+ *
+ * SYNC: When modified, update VelocityTracker.test.ts.
+ */
+
+import { UIKIT_VELOCITY } from "../motion/uikit/gestures.js";
+const ZERO = {
+  x: 0,
+  y: 0
+};
+const PAN_CURRENT_WEIGHT = UIKIT_VELOCITY.currentWeight.value;
+const SCROLL_CURRENT_WEIGHT = UIKIT_VELOCITY.scrollReleaseWeight.value;
+function blend(weight, current, previous) {
+  return {
+    x: weight * current.x + (1 - weight) * previous.x,
+    y: weight * current.y + (1 - weight) * previous.y
+  };
+}
+export class VelocityTracker {
+  /** The newest sample added, moved or not. */
+  newest = null;
+  /**
+   * The newest moved samples, oldest first (the touch-down counts as the
+   * first); the filter reads the last three.
+   */
+  moved = [];
+  /** Moved samples since the touch-down. */
+  moves = 0;
+  /** The newest pan value, and the one before it. */
+  pan = ZERO;
+  previousPan = ZERO;
+  constructor(options = {}) {
+    this.stillness = options.stillness ?? UIKIT_VELOCITY.stillness.value;
+  }
+
+  /** Forget every sample (a new gesture). */
+  reset() {
+    this.newest = null;
+    this.moved = [];
+    this.moves = 0;
+    this.pan = ZERO;
+    this.previousPan = ZERO;
+  }
+
+  /**
+   * Record a position. Timestamps must not go backwards (an older sample is
+   * ignored), and a moved sample at the newest moved sample's timestamp
+   * replaces it. A sample at the newest position is not motion: it changes
+   * no velocity.
+   */
+  add(x, y, time) {
+    if (this.newest != null && time < this.newest.time) {
+      return;
+    }
+    this.newest = {
+      x,
+      y,
+      time
+    };
+    const last = this.moved[this.moved.length - 1];
+    if (last != null && x === last.x && y === last.y) {
+      return;
+    }
+    if (last != null && time === last.time) {
+      this.moved[this.moved.length - 1] = {
+        x,
+        y,
+        time
+      };
+    } else {
+      this.moved.push({
+        x,
+        y,
+        time
+      });
+      if (this.moved.length > 3) {
+        this.moved.shift();
+      }
+      if (last != null) {
+        this.moves += 1;
+        this.previousPan = this.pan;
+      }
+    }
+    this.pan = panVelocity(this.moved);
+  }
+
+  /** Record every sample in order. */
+  addSamples(samples) {
+    for (const sample of samples) {
+      this.add(sample.x, sample.y, sample.time);
+    }
+  }
+
+  /** The newest sample, if any. */
+  get lastSample() {
+    return this.newest;
+  }
+
+  /**
+   * The pan's velocity in px/s. Pass the release's event time to read the
+   * release velocity of a dragged surface: 0 after a rest longer than the
+   * stillness interval, or with fewer than two moved samples (AST-100 FR2).
+   */
+  velocity(releaseTime) {
+    if (releaseTime != null && !this.releases(releaseTime)) {
+      return ZERO;
+    }
+    return this.pan;
+  }
+
+  /**
+   * A scrolling surface's release velocity in px/s (paging, a wheel): 0.25
+   * times the newest pan value plus 0.75 times the previous one, with the
+   * same stillness and two-moved-sample rules (AST-100 FR2).
+   */
+  scrollVelocity(releaseTime) {
+    if (!this.releases(releaseTime)) {
+      return ZERO;
+    }
+    return blend(SCROLL_CURRENT_WEIGHT, this.pan, this.previousPan);
+  }
+  releases(releaseTime) {
+    const last = this.moved[this.moved.length - 1];
+    return this.moves >= 2 && last != null && releaseTime - last.time <= this.stillness;
+  }
+}
+
+/**
+ * UIPanGestureRecognizer's filter over the newest moved samples: 0.2 x the
+ * newest interval's velocity + 0.8 x the previous one's; one interval so far
+ * is reported whole, as UIKit does.
+ */
+function panVelocity(moved) {
+  const n = moved.length;
+  if (n < 2) {
+    return ZERO;
+  }
+  const current = pairVelocity(moved[n - 2], moved[n - 1]);
+  if (n === 2) {
+    return current;
+  }
+  return blend(PAN_CURRENT_WEIGHT, current, pairVelocity(moved[n - 3], moved[n - 2]));
+}
+
+/** Instantaneous velocity (px/s) between two samples, zero across no time. */
+function pairVelocity(start, end) {
+  const dt = end.time - start.time;
+  if (dt <= 0) {
+    return ZERO;
+  }
+  return {
+    x: (end.x - start.x) / dt * 1000,
+    y: (end.y - start.y) / dt * 1000
+  };
+}

package/dist/gestures/geometry.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @file geometry.ts
+ * @input Touches
+ * @output Exports the small geometry helpers recognizers share: centroid,
+ *   distance, span and angle of two touches, angle unwrapping
+ * @position Pure helpers under packages/core/src/gestures
+ */
+import type { GestureTouch, Point } from './types.js';
+export declare function centroid(touches: Iterable<GestureTouch>, excluding?: ReadonlySet<number>): Point;
+export declare function distance(a: Point, b: Point): number;
+/** How far a touch is from where it landed. */
+export declare function travel(touch: GestureTouch): number;
+/** The angle of the vector from the first touch to the second, radians. */
+export declare function angleBetween(a: Point, b: Point): number;
+/** `angle` shifted by whole turns to be within half a turn of `reference`. */
+export declare function unwrapAngle(angle: number, reference: number): number;
+//# sourceMappingURL=geometry.d.ts.map

package/dist/gestures/geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/gestures/geometry.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAC,YAAY,EAAE,KAAK,EAAC,MAAM,SAAS,CAAC;AAEjD,wBAAgB,QAAQ,CACtB,OAAO,EAAE,QAAQ,CAAC,YAAY,CAAC,EAC/B,SAAS,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,GAC9B,KAAK,CAaP;AAED,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,MAAM,CAEnD;AAED,+CAA+C;AAC/C,wBAAgB,MAAM,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,CAElD;AAED,2EAA2E;AAC3E,wBAAgB,YAAY,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,MAAM,CAEvD;AAED,8EAA8E;AAC9E,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CASpE"}

package/dist/gestures/geometry.js

@@ -0,0 +1,55 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file geometry.ts
+ * @input Touches
+ * @output Exports the small geometry helpers recognizers share: centroid,
+ *   distance, span and angle of two touches, angle unwrapping
+ * @position Pure helpers under packages/core/src/gestures
+ */
+
+export function centroid(touches, excluding) {
+  let x = 0;
+  let y = 0;
+  let count = 0;
+  for (const touch of touches) {
+    if (excluding?.has(touch.id)) {
+      continue;
+    }
+    x += touch.x;
+    y += touch.y;
+    count += 1;
+  }
+  return count === 0 ? {
+    x: 0,
+    y: 0
+  } : {
+    x: x / count,
+    y: y / count
+  };
+}
+export function distance(a, b) {
+  return Math.hypot(a.x - b.x, a.y - b.y);
+}
+
+/** How far a touch is from where it landed. */
+export function travel(touch) {
+  return Math.hypot(touch.x - touch.startX, touch.y - touch.startY);
+}
+
+/** The angle of the vector from the first touch to the second, radians. */
+export function angleBetween(a, b) {
+  return Math.atan2(b.y - a.y, b.x - a.x);
+}
+
+/** `angle` shifted by whole turns to be within half a turn of `reference`. */
+export function unwrapAngle(angle, reference) {
+  let result = angle;
+  while (result - reference > Math.PI) {
+    result -= 2 * Math.PI;
+  }
+  while (result - reference < -Math.PI) {
+    result += 2 * Math.PI;
+  }
+  return result;
+}

package/dist/gestures/types.d.ts

@@ -0,0 +1,139 @@
+/**
+ * @file types.ts
+ * @input Nothing
+ * @output Exports the data the gesture system passes around: recognizer
+ *   states, pointer kinds, touches (UITouch), the per-event context, the
+ *   environment a host provides, and the view-level touch consumer contract
+ * @position Shared vocabulary of packages/core/src/gestures; no runtime code
+ */
+/**
+ * UIGestureRecognizer.State. A discrete recognizer goes straight from
+ * `possible` to `ended` (UIKit's `.recognized` is the same value).
+ */
+export type GestureState = 'possible' | 'began' | 'changed' | 'ended' | 'cancelled' | 'failed';
+/** What made the contact. A pen on an iPad is `pen`, not `touch`. */
+export type PointerKind = 'touch' | 'mouse' | 'pen';
+export interface Point {
+    readonly x: number;
+    readonly y: number;
+}
+/** One position of a contact at one instant, in client (viewport) CSS px. */
+export interface TouchSample {
+    readonly x: number;
+    readonly y: number;
+    /** Milliseconds on the `performance.now()` clock (an event's `timeStamp`). */
+    readonly time: number;
+}
+export type TouchPhase = 'began' | 'moved' | 'ended' | 'cancelled';
+/**
+ * The scrollers between a touch and the page, as the host sees them: enough
+ * for a recognizer to ask whether the browser would scroll something if the
+ * finger moved one way, without the recognizer touching the DOM.
+ */
+export interface NativeScrollProbe {
+    /**
+     * Whether a finger moving by (dx, dy) would scroll some element under the
+     * touch (one that has room left in that direction and whose `touch-action`
+     * lets the browser pan that axis).
+     */
+    canScroll(dx: number, dy: number): boolean;
+    /**
+     * How much further (px) the scroller that would move for a finger moving
+     * by (dx, dy) can scroll before it reaches its edge; 0 when none would.
+     * Lets a reader place the point where the content runs out between two
+     * samples instead of at the next one.
+     */
+    distanceToEdge?(dx: number, dy: number): number;
+    /** Whether any element under the touch can scroll natively at all. */
+    readonly isInsideScroller: boolean;
+    /**
+     * Whether `touch-action` from the touch target to the page lets the
+     * browser pan at all: when it does not, the browser cannot have taken the
+     * touch for a scroll, whatever its events say.
+     */
+    readonly allowsNativePan: boolean;
+}
+/**
+ * One contact: UITouch. The arena owns it and updates it in place; a
+ * recognizer keeps a reference to every touch it receives.
+ */
+export interface GestureTouch {
+    /** Unique among the contacts the arena tracks at once. */
+    readonly id: number;
+    readonly pointerType: PointerKind;
+    phase: TouchPhase;
+    /** Latest position, client CSS px. */
+    x: number;
+    y: number;
+    /** Timestamp of the latest position. */
+    time: number;
+    readonly startX: number;
+    readonly startY: number;
+    readonly startTime: number;
+    /**
+     * Positions since the previous event, oldest first, ending with the
+     * current one (coalesced samples where the platform has them). Velocity
+     * trackers read these; actions fire once per event.
+     */
+    samples: TouchSample[];
+    /** The node the contact began on. Opaque to the arena. */
+    readonly target: unknown;
+    /** The native scrollers under the contact, when the host knows them. */
+    readonly scroll: NativeScrollProbe | null;
+    /** The browser took this contact for its own pan or zoom. */
+    takenByBrowser: boolean;
+}
+/** The input a host hands the arena for one contact in one event. */
+export interface TouchInput {
+    readonly id: number;
+    readonly x: number;
+    readonly y: number;
+    readonly time: number;
+    /** Extra positions since the previous event, oldest first (coalesced). */
+    readonly history?: ReadonlyArray<TouchSample>;
+}
+/** A new contact: where it is, what made it, and what it landed on. */
+export interface TouchBeganInput extends TouchInput {
+    readonly pointerType: PointerKind;
+    readonly target: unknown;
+    readonly scroll?: NativeScrollProbe | null;
+}
+/** What a recognizer is told alongside the touches that changed. */
+export interface GestureEventContext {
+    /** Timestamp of the event being processed. */
+    readonly time: number;
+    /** Every contact the arena currently tracks, not only this recognizer's. */
+    readonly allTouches: ReadonlyArray<GestureTouch>;
+}
+/**
+ * Facts about the page a recognizer may need and must not read from the DOM
+ * itself: the viewport for screen-edge pans, and the writing direction of a
+ * view for `leading` / `trailing`.
+ */
+export interface GestureEnvironment {
+    viewportSize(): {
+        readonly width: number;
+        readonly height: number;
+    };
+    isRtl(view: unknown): boolean;
+}
+export declare const DEFAULT_ENVIRONMENT: GestureEnvironment;
+/**
+ * A view-level touch consumer: what UIKit delivers `touchesBegan` /
+ * `touchesEnded` to when no gesture recognizer takes the touch (a UIControl).
+ * The arena delivers through it, honoring `delaysTouchesBegan`,
+ * `delaysTouchesEnded` and `cancelsTouchesInView`.
+ */
+export interface TouchConsumer {
+    touchBegan(touch: GestureTouch): void;
+    touchMoved(touch: GestureTouch): void;
+    touchEnded(touch: GestureTouch): void;
+    touchCancelled(touch: GestureTouch): void;
+    /**
+     * UIControl's iOS 6 rule: a control's own action wins over an overlapping
+     * single-tap recognizer on an ancestor. Return false to stop `recognizer`
+     * (attached above this consumer) from beginning for a touch on it.
+     */
+    allowsAncestorRecognizer?(recognizer: unknown): boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/gestures/types.d.ts.map

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

package/dist/gestures/types.js

@@ -0,0 +1,67 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file types.ts
+ * @input Nothing
+ * @output Exports the data the gesture system passes around: recognizer
+ *   states, pointer kinds, touches (UITouch), the per-event context, the
+ *   environment a host provides, and the view-level touch consumer contract
+ * @position Shared vocabulary of packages/core/src/gestures; no runtime code
+ */
+
+/**
+ * UIGestureRecognizer.State. A discrete recognizer goes straight from
+ * `possible` to `ended` (UIKit's `.recognized` is the same value).
+ */
+
+/** What made the contact. A pen on an iPad is `pen`, not `touch`. */
+
+/** One position of a contact at one instant, in client (viewport) CSS px. */
+
+/**
+ * The scrollers between a touch and the page, as the host sees them: enough
+ * for a recognizer to ask whether the browser would scroll something if the
+ * finger moved one way, without the recognizer touching the DOM.
+ */
+
+/**
+ * One contact: UITouch. The arena owns it and updates it in place; a
+ * recognizer keeps a reference to every touch it receives.
+ */
+
+/** The input a host hands the arena for one contact in one event. */
+
+/** A new contact: where it is, what made it, and what it landed on. */
+
+/** What a recognizer is told alongside the touches that changed. */
+
+/**
+ * Facts about the page a recognizer may need and must not read from the DOM
+ * itself: the viewport for screen-edge pans, and the writing direction of a
+ * view for `leading` / `trailing`.
+ */
+
+export const DEFAULT_ENVIRONMENT = {
+  viewportSize() {
+    if (typeof window === 'undefined') {
+      return {
+        width: 0,
+        height: 0
+      };
+    }
+    return {
+      width: window.innerWidth,
+      height: window.innerHeight
+    };
+  },
+  isRtl() {
+    return false;
+  }
+};
+
+/**
+ * A view-level touch consumer: what UIKit delivers `touchesBegan` /
+ * `touchesEnded` to when no gesture recognizer takes the touch (a UIControl).
+ * The arena delivers through it, honoring `delaysTouchesBegan`,
+ * `delaysTouchesEnded` and `cancelsTouchesInView`.
+ */

package/dist/hooks/AnnounceRenderedText.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @file AnnounceRenderedText.tsx
+ * @input Uses React, useAnnounceRenderedText
+ * @output Exports AnnounceRenderedText (internal; not re-exported from
+ *   hooks/index.ts, so it ships no public API without `spec:AST-002`)
+ * @position Internal client island that lets a presentational, server-safe
+ *   component announce its own content; rendered by EmptyState around its
+ *   message. On the server it only renders its `div`: effects never run there.
+ */
+import { type HTMLAttributes } from 'react';
+/**
+ * A `div` whose rendered text is announced once through the shared polite
+ * live region when it appears or changes after the page loaded, and never for
+ * text present when the page first rendered (`spec:AST-086` FR11).
+ */
+export declare function AnnounceRenderedText(props: HTMLAttributes<HTMLDivElement>): import("react").JSX.Element;
+//# sourceMappingURL=AnnounceRenderedText.d.ts.map

package/dist/hooks/AnnounceRenderedText.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnnounceRenderedText.d.ts","sourceRoot":"","sources":["../../src/hooks/AnnounceRenderedText.tsx"],"names":[],"mappings":"AAIA;;;;;;;;GAQG;AAEH,OAAO,EAAS,KAAK,cAAc,EAAC,MAAM,OAAO,CAAC;AAGlD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,cAAc,CAAC,cAAc,CAAC,+BAIzE"}

package/dist/hooks/AnnounceRenderedText.js

@@ -0,0 +1,32 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+'use client';
+
+/**
+ * @file AnnounceRenderedText.tsx
+ * @input Uses React, useAnnounceRenderedText
+ * @output Exports AnnounceRenderedText (internal; not re-exported from
+ *   hooks/index.ts, so it ships no public API without `spec:AST-002`)
+ * @position Internal client island that lets a presentational, server-safe
+ *   component announce its own content; rendered by EmptyState around its
+ *   message. On the server it only renders its `div`: effects never run there.
+ */
+import { useRef } from 'react';
+import { useAnnounceRenderedText } from "./useAnnounceRenderedText.js";
+
+/**
+ * A `div` whose rendered text is announced once through the shared polite
+ * live region when it appears or changes after the page loaded, and never for
+ * text present when the page first rendered (`spec:AST-086` FR11).
+ */
+import { jsx as _jsx } from "react/jsx-runtime";
+export function AnnounceRenderedText(props) {
+  const ref = useRef(null);
+  useAnnounceRenderedText(ref, true, '', {
+    skipFirstRender: true
+  });
+  return /*#__PURE__*/_jsx("div", {
+    ref: ref,
+    ...props
+  });
+}

package/dist/hooks/ModalAnnounceProvider.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @file ModalAnnounceProvider.tsx
+ * @input Uses React context, effects and the exposure and delivery
+ *   internals of useAnnounce
+ * @output Exports ModalAnnounceProvider, the element every Astryx component
+ *   that owns a native <dialog> renders around its content
+ * @position Core a11y internal (spec:AST-086 FR14). Its own module so only
+ *   the modals' bundles carry it: a component that calls useAnnounce but
+ *   renders no modal does not load the provider.
+ *
+ * SYNC: not exported from /packages/core/src/hooks/index.ts.
+ */
+import { type ReactNode, type RefObject } from 'react';
+/**
+ * Rendered by every Astryx component that owns a native `<dialog>` (Dialog,
+ * BottomSheet, Drawer, Lightbox; CommandPalette through Dialog), around the
+ * dialog's content, so `useAnnounce` beneath it routes into that dialog while
+ * it is open as a modal. The provider watches the dialog's `open`, `inert`
+ * and `aria-hidden` attributes: when the dialog stops being exposed, any
+ * message its containers hold that assistive technology has not had yet is
+ * handed to the channel exposed then — the modal on top, or the shared
+ * channel — and the same happens when the provider unmounts with the dialog
+ * still open. A dialog closed and shown again in one task is exposed again
+ * by the time the change is seen, so its words stay (a hand-over, not a
+ * close).
+ *
+ * Internal: imported by path inside the package; not exported from the hooks
+ * barrel or the package entry.
+ */
+export declare function ModalAnnounceProvider({ dialogRef, isOpen, children, }: {
+    dialogRef: RefObject<HTMLDialogElement | null>;
+    /**
+     * The owner's intent for this render: open as a modal (or presented as a
+     * modal step). A non-modal surface — a scrimless Drawer shown with
+     * `showPopover()`, a scrimless sheet — passes `false`: it is not an FR14
+     * modal, and callers inside it route as the page does.
+     */
+    isOpen: boolean;
+    children: ReactNode;
+}): ReactNode;
+//# sourceMappingURL=ModalAnnounceProvider.d.ts.map

package/dist/hooks/ModalAnnounceProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModalAnnounceProvider.d.ts","sourceRoot":"","sources":["../../src/hooks/ModalAnnounceProvider.tsx"],"names":[],"mappings":"AAIA;;;;;;;;;;;GAWG;AAEH,OAAO,EAKL,KAAK,SAAS,EACd,KAAK,SAAS,EACf,MAAM,OAAO,CAAC;AAWf;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,qBAAqB,CAAC,EACpC,SAAS,EACT,MAAM,EACN,QAAQ,GACT,EAAE;IACD,SAAS,EAAE,SAAS,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAAC;IAC/C;;;;;OAKG;IACH,MAAM,EAAE,OAAO,CAAC;IAChB,QAAQ,EAAE,SAAS,CAAC;CACrB,GAAG,SAAS,CAyFZ"}