{renderedLayer}
@@ -1038,6 +1044,60 @@ describe('useLayer', () => {
expect(layer).toHaveAttribute('data-open', 'true');
});
+ it('prepare() mounts it closed, and the next show opens that element at once', async () => {
+ const showSpy = mockPopover();
+ const {container, getByRole} = render(
);
+
+ fireEvent.click(getByRole('button', {name: 'Prepare'}));
+ await waitFor(() => {
+ expect(container.querySelector('[popover]')).not.toBeNull();
+ });
+ const layer = container.querySelector('[popover]');
+ expect(layer).not.toHaveAttribute('data-open');
+ expect(showSpy).not.toHaveBeenCalled();
+
+ fireEvent.click(getByRole('button', {name: 'Trigger'}));
+ // Mounted: shown within the call, not after a commit.
+ expect(showSpy).toHaveBeenCalledOnce();
+ expect(container.querySelector('[popover]')).toBe(layer);
+ expect(layer).toHaveAttribute('data-open', 'true');
+ });
+
+ it('releasePrepared() unmounts a prepared layer that never showed', async () => {
+ const showSpy = mockPopover();
+ const {container, getByRole} = render(
);
+
+ fireEvent.click(getByRole('button', {name: 'Prepare'}));
+ await waitFor(() => {
+ expect(container.querySelector('[popover]')).not.toBeNull();
+ });
+ fireEvent.click(getByRole('button', {name: 'Release'}));
+
+ await waitFor(() => {
+ expect(container.querySelector('[popover]')).toBeNull();
+ });
+ expect(container.querySelector('template')).not.toBeNull();
+ expect(showSpy).not.toHaveBeenCalled();
+ });
+
+ it('releasePrepared() keeps a prepared layer that has shown since', async () => {
+ mockPopover();
+ const {container, getByRole} = render(
);
+
+ fireEvent.click(getByRole('button', {name: 'Prepare'}));
+ await waitFor(() => {
+ expect(container.querySelector('[popover]')).not.toBeNull();
+ });
+ const layer = container.querySelector('[popover]');
+ fireEvent.click(getByRole('button', {name: 'Trigger'}));
+ fireEvent.click(getByRole('button', {name: 'Close'}));
+ fireEvent.click(getByRole('button', {name: 'Release'}));
+
+ await act(async () => {});
+ expect(container.querySelector('[popover]')).toBe(layer);
+ expect(layer?.isConnected).toBe(true);
+ });
+
it('without the option, a lazy layer still unmounts on hide', async () => {
mockPopover();
const {container, getByRole} = render(
diff --git a/packages/core/src/Layer/useLayer.tsx b/packages/core/src/Layer/useLayer.tsx
index a2f86663550ad..3420ac47d9987 100644
--- a/packages/core/src/Layer/useLayer.tsx
+++ b/packages/core/src/Layer/useLayer.tsx
@@ -474,6 +474,23 @@ interface InternalLayerFields {
wasJustDismissed: () => boolean;
}
+/** Context-mode members a core component may use through `useLayerInternal`. */
+interface InternalContextLayerFields {
+ /**
+ * With `lazyMount`, mounts the layer's content without showing it. The
+ * popover stays closed, so it shows no pixel and is out of the accessibility
+ * tree until `show()`, which then only shows it. A caller that knows a show
+ * is coming spares that show the first mount's render. Does nothing for a
+ * layer that is mounted already.
+ */
+ prepare: () => void;
+ /**
+ * Unmounts what `prepare()` mounted, unless the layer has shown since. A
+ * layer that has shown keeps its mount as its options say.
+ */
+ releasePrepared: () => void;
+}
+
/**
* Context-mode options a core component may pass through `useLayerInternal`;
* not part of the public `useLayer` options.
@@ -518,7 +535,9 @@ interface InternalContextLayerOptions extends ContextLayerOptions {
writesEntranceSide?: boolean;
}
-type InternalContextLayerReturn = ContextLayerReturn & InternalLayerFields;
+type InternalContextLayerReturn = ContextLayerReturn &
+ InternalLayerFields &
+ InternalContextLayerFields;
type InternalFixedLayerReturn = FixedLayerReturn & InternalLayerFields;
function toCssLength(value: number | string): string {
@@ -1543,6 +1562,30 @@ function useLayerImplementation(
[mountStore],
);
+ // The mount came from `prepare()`, and the layer has not shown since.
+ const isMountPreparedRef = useRef(false);
+
+ const prepare = useCallback(() => {
+ if (mode !== 'context' || !lazyMount || contextMountRef.current != null) {
+ return;
+ }
+ isMountPreparedRef.current = true;
+ requestContextMount();
+ }, [mode, lazyMount, requestContextMount]);
+
+ const releasePrepared = useCallback(() => {
+ if (
+ !isMountPreparedRef.current ||
+ pendingShowRef.current ||
+ isOpenRef.current
+ ) {
+ return;
+ }
+ isMountPreparedRef.current = false;
+ contextMountRef.current = null;
+ mountStore.set(null);
+ }, [mountStore]);
+
const clearContextMount = useCallback(() => {
if (mode !== 'context' || !lazyMount || keepsMountAfterShow) {
return;
@@ -1557,6 +1600,7 @@ function useLayerImplementation(
if (wasJustDismissed()) {
return;
}
+ isMountPreparedRef.current = false;
// A context popover left over until React commits a previous hide must not
// be reopened. The synchronous mount ref is the source of truth.
const candidate = popoverRef.current;
@@ -2488,6 +2532,8 @@ function useLayerImplementation(
hide,
isOpen,
wasJustDismissed,
+ prepare,
+ releasePrepared,
id,
render: renderContext,
}),
@@ -2498,6 +2544,8 @@ function useLayerImplementation(
hide,
isOpen,
wasJustDismissed,
+ prepare,
+ releasePrepared,
id,
renderContext,
],
@@ -2525,7 +2573,15 @@ export function useLayer(
): ContextLayerReturn | FixedLayerReturn {
const internalLayer = useLayerImplementation(options);
return useMemo(() => {
- const {wasJustDismissed: _, ...layer} = internalLayer;
+ const {
+ wasJustDismissed: _,
+ prepare: _prepare,
+ releasePrepared: _releasePrepared,
+ ...layer
+ } = internalLayer as (
+ InternalContextLayerReturn | InternalFixedLayerReturn
+ ) &
+ Partial
;
return layer;
}, [internalLayer]);
}
diff --git a/packages/core/src/gestures/GestureArena.ts b/packages/core/src/gestures/GestureArena.ts
index 62bf6d03374cd..6a0cf0887a85f 100644
--- a/packages/core/src/gestures/GestureArena.ts
+++ b/packages/core/src/gestures/GestureArena.ts
@@ -181,6 +181,14 @@ export class GestureArena {
return this.currentTime ?? Math.max(this.latestTime, this.clock.now());
}
+ /**
+ * The injected clock's own reading: when the page runs now. Behind a block,
+ * the event clock lags it.
+ */
+ pageTime(): number {
+ return this.clock.now();
+ }
+
/** Whether a recognizer owns this touch, so the browser must not pan or zoom it. */
isClaimed(id: number): boolean {
return this.records.get(id)?.isClaimed === true;
@@ -238,6 +246,11 @@ export class GestureArena {
x: input.x,
y: input.y,
time,
+ inputTime: input.time,
+ inputSamples: [
+ ...(input.history ?? []),
+ {x: input.x, y: input.y, time: input.time},
+ ],
startX: input.x,
startY: input.y,
startTime: time,
@@ -328,6 +341,8 @@ export class GestureArena {
x: input.x,
y: input.y,
time,
+ inputTime: input.time,
+ inputSamples: [{x: input.x, y: input.y, time: input.time}],
startX: input.x,
startY: input.y,
startTime: time,
@@ -993,6 +1008,11 @@ export class GestureArena {
touch.x = input.x;
touch.y = input.y;
touch.time = time;
+ touch.inputTime = input.time;
+ touch.inputSamples = [
+ ...(input.history ?? []),
+ {x: input.x, y: input.y, time: input.time},
+ ];
touch.phase = phase;
changed.push(touch);
}
diff --git a/packages/core/src/gestures/__tests__/arena.test.ts b/packages/core/src/gestures/__tests__/arena.test.ts
index d5a724e20862d..13f798c14339b 100644
--- a/packages/core/src/gestures/__tests__/arena.test.ts
+++ b/packages/core/src/gestures/__tests__/arena.test.ts
@@ -10,7 +10,9 @@
* requirements, idle recognizers), shouldBegin and shouldReceiveTouch,
* innermost resolution, independent touches, delivery to the view (claims,
* cancelsTouchesInView, delaysTouchesBegan, deferred and replayed clicks,
- * the browser taking a touch), cancellation, and the event clock
+ * the browser taking a touch), cancellation, and the event clock, which
+ * holds a late input at its time and keeps the times the input and its
+ * coalesced samples came with
* @position Unit tests of packages/core/src/gestures/GestureArena.ts and the
* state machine of GestureRecognizer.ts
*/
@@ -402,6 +404,47 @@ describe('arena: cancellation and time', () => {
h.finger(1).move(5, 0, 90);
expect(h.log).toEqual(['r:began@100']);
});
+ it('holds a late input at the clock, and keeps the time it came with', () => {
+ const h = createHarness();
+ const seen: {time: number; inputTime: number}[] = [];
+ const r = new Scripted('r', {
+ moved: recognizer => {
+ const [touch] = recognizer.trackedTouches;
+ seen.push({time: touch.time, inputTime: touch.inputTime});
+ },
+ });
+ h.finger(1).down(0, 0, 100, {recognizers: [r]});
+ h.advance(500);
+ h.finger(1).move(5, 0, 300);
+ h.finger(1).move(6, 0, 520);
+ expect(seen).toEqual([
+ {time: 500, inputTime: 300},
+ {time: 520, inputTime: 520},
+ ]);
+ });
+ it('keeps a late move’s coalesced samples at the times they came with', () => {
+ const h = createHarness();
+ const seen: {samples: number[]; inputSamples: number[]}[] = [];
+ const r = new Scripted('r', {
+ moved: recognizer => {
+ const [touch] = recognizer.trackedTouches;
+ seen.push({
+ samples: touch.samples.map(sample => sample.time),
+ inputSamples: touch.inputSamples.map(sample => sample.time),
+ });
+ },
+ });
+ h.finger(1).down(0, 0, 100, {recognizers: [r]});
+ h.advance(500);
+ h.finger(1).move(5, 0, 300);
+ // Both late: the clock holds them at 500 ms, and `samples` drops the
+ // earlier one, which comes before the touch's held time.
+ h.finger(1).move(7, 0, 320, [{x: 6, y: 0, time: 310}]);
+ expect(seen).toEqual([
+ {samples: [500], inputSamples: [300]},
+ {samples: [500], inputSamples: [310, 320]},
+ ]);
+ });
});
/** A clock whose timers run one task at a time, as an event loop does. */
diff --git a/packages/core/src/gestures/__tests__/harness.ts b/packages/core/src/gestures/__tests__/harness.ts
index 37f8796de614d..3e7fecf58ff86 100644
--- a/packages/core/src/gestures/__tests__/harness.ts
+++ b/packages/core/src/gestures/__tests__/harness.ts
@@ -5,8 +5,8 @@
* @input Nothing
* @output Exports the synthetic-input harness the gesture tests share: a
* manual clock, an arena wired to a transition log, fingers that land,
- * move and lift at explicit timestamps, and a coarse primary pointer for
- * tests that go through the document's host
+ * move (with coalesced samples) and lift at explicit timestamps, and a
+ * coarse primary pointer for tests that go through the document's host
* @position Test-only helper of packages/core/src/gestures (excluded from the
* build with the rest of __tests__)
*/
@@ -18,6 +18,7 @@ import type {
GestureTouch,
NativeScrollProbe,
TouchConsumer,
+ TouchSample,
} from '../types';
/**
@@ -82,8 +83,11 @@ export interface Harness {
view?: {left?: number; top?: number; width: number; height: number};
};
finger(id: number): Finger;
- /** Advance the clock and run every timer due by `time`. */
- advance(time: number): void;
+ /**
+ * Advance the clock and run every timer due by `time`. `runsAt`: when the
+ * page runs those timers on the clock, later behind a block.
+ */
+ advance(time: number, runsAt?: number): void;
}
export function createHarness(): Harness {
@@ -138,8 +142,8 @@ export function createHarness(): Harness {
}
return finger;
},
- advance: time => {
- clock.time = time;
+ advance: (time, runsAt = time) => {
+ clock.time = runsAt;
arena.advanceTime(time);
},
};
@@ -189,12 +193,25 @@ export class Finger {
return this;
}
- move(x: number, y: number, time: number): this {
+ /**
+ * `history`: the coalesced samples before this one, oldest first.
+ * `arrivesAt`: when the page gets the move on the clock, for a move that
+ * reaches it after its own time.
+ */
+ move(
+ x: number,
+ y: number,
+ time: number,
+ history?: ReadonlyArray,
+ arrivesAt = time,
+ ): this {
this.x = x;
this.y = y;
this.time = time;
- this.harness.clock.time = time;
- this.harness.arena.moved([{id: this.id, x, y, time}]);
+ this.harness.clock.time = arrivesAt;
+ this.harness.arena.moved([
+ {id: this.id, x, y, time, ...(history == null ? {} : {history})},
+ ]);
return this;
}
diff --git a/packages/core/src/gestures/types.ts b/packages/core/src/gestures/types.ts
index ef646cecde9d2..598501a78456c 100644
--- a/packages/core/src/gestures/types.ts
+++ b/packages/core/src/gestures/types.ts
@@ -81,6 +81,18 @@ export interface GestureTouch {
y: number;
/** Timestamp of the latest position. */
time: number;
+ /**
+ * The latest position's own timestamp, as the host read it. The arena's
+ * clock never runs back, so a late input's `time` is held at the clock;
+ * this field keeps the time the input came with.
+ */
+ inputTime: number;
+ /**
+ * The latest event's positions at the times they came with, oldest first,
+ * ending with the current one at `inputTime`. The arena's clock filters
+ * `samples`; it does not filter these.
+ */
+ inputSamples: TouchSample[];
readonly startX: number;
readonly startY: number;
readonly startTime: number;
diff --git a/packages/core/src/motion/README.md b/packages/core/src/motion/README.md
index f094c86363240..5bebd7d85ea95 100644
--- a/packages/core/src/motion/README.md
+++ b/packages/core/src/motion/README.md
@@ -18,6 +18,7 @@ roles through `resolveMotion`.
| `uikit/springs.ts` | Interaction springs (navigation, sheets, alerts, menus, controls, keyboard, banners) and the SwiftUI / UIKit presets. |
| `uikit/scroll.ts` | UIScrollView: deceleration rates, rubber band, bounce-back spring, `delaysContentTouches`, scroll to top. |
| `uikit/timing.ts` | Non-spring clocks and curves: press highlight, Core Animation's named curves, keyboard, Reduced Motion cross-fade. |
+| `uikit/contextMenu.ts` | UIContextMenuInteraction: touch timeline (feedback, commit, menu), drift tolerance, the press feedback's held scale, commit haptic. |
| `uikit/paging.ts` | A paging UIScrollView: the integrator that settles a release on its page, the page rule, the catch, `setContentOffset(animated:)`. |
| `uikit/alert.ts` | UIAlertController: how a finger is tracked across the actions (highlight onset and bounds). |
| `uikit/navigation.ts` | UINavigationController: push velocity, parallax, dimming, transition clock, interactive pop finish rule. |
diff --git a/packages/core/src/motion/uikit/contextMenu.ts b/packages/core/src/motion/uikit/contextMenu.ts
new file mode 100644
index 0000000000000..7d7743e20b664
--- /dev/null
+++ b/packages/core/src/motion/uikit/contextMenu.ts
@@ -0,0 +1,117 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file contextMenu.ts
+ * @input Measurements of UIContextMenuInteraction on iOS 26.2
+ * @output `contextMenu`: UIContextMenuInteraction's touch timeline, drift
+ * tolerance, held scale and commit haptic
+ * @position The context-menu domain of the UIKit constants table. Only
+ * ContextMenu's own modules import it. The table's barrel does not
+ * re-export it.
+ *
+ * SYNC: When modified, update /packages/core/src/motion/MEASUREMENTS.md,
+ * /packages/core/src/ContextMenu/contextMenuPressFeedback.ts and
+ * /packages/core/src/ContextMenu/contextMenuPress.ts
+ */
+
+/**
+ * UIContextMenuInteraction's touch timeline on iOS 26.2. A context menu is not
+ * a plain long press. A finger that rests on the view starts a press feedback
+ * after 150 ms. A copy of the view grows uniformly, and its size follows a
+ * linear ramp through a spring. At 400 ms the press commits. The click haptic
+ * plays, and the touch can no longer become a tap. The menu displays at 735 ms
+ * if the finger is still down, or at the lift after the commit. A finger that
+ * lifts before the commit gets no menu, and the copy springs back. A finger
+ * that drifts too far before the menu displays gets the same.
+ *
+ * UIKit runs this on display-link ticks. So a 60 Hz screen shows each moment
+ * on the first frame after it: the feedback at 151 ms, the commit at 417 ms.
+ * The times here are the moments themselves, from the `touchstart` timestamp.
+ * UIKit counts from the main thread's receipt of the touch, about a frame
+ * after the hardware timestamp that a browser stamps. A browser's compositor
+ * shows a value about a frame after its time, so the two offsets cancel.
+ * Scales are fractions of the view's own size. The lift and dismissal springs
+ * are `springs.contextMenuLift` and `springs.contextMenuDismiss`.
+ *
+ * Every leaf has one or more `@source`. A GUESS value also has the `@measure`
+ * task that confirms or replaces it. uikit.test.ts enforces both.
+ */
+export const contextMenu = {
+ press: {
+ /**
+ * When the long press commits. The click haptic plays, and from then on
+ * the touch belongs to the menu, not to a tap. The menu itself waits for
+ * `menuDisplayMs` or the lift.
+ * @source measured: UIKit lab (injected host app), iOS 26.2 simulator,
+ * iPhone 17 Pro, recognizer state log, Oct 23 2026: the
+ * clickPresentationExclusion and clickPresentationFailure recognizers
+ * ended on the first 60 Hz tick after 400 ms (at 416.7 ms; the tick
+ * before, at 399.5 ms, had not), the haptic played at 420 ms, and the
+ * platter's size ramp changes slope at 400 ms
+ * @measure M-CM6
+ */
+ commitMs: 400,
+ /**
+ * How far the finger may drift on either axis, from where it landed,
+ * until the menu displays; past it the press ends with no menu. Not the
+ * long press's `UIKIT_GESTURES.longPress.allowableMovement` (a distance):
+ * a diagonal drift of 15.6 pt still opens the menu.
+ * @source measured: UIKit lab (injected host app), iOS 26.2 simulator,
+ * iPhone 17 Pro, drifts at 100, 250 and 500 ms, Oct 23 2026: (7, 7),
+ * (8, 8), (10, 0) and (11, 11) pt open the menu; (12, 0) and (0, 12)
+ * cancel it, before and after the onset alike, and a 30 pt drag after
+ * the commit cancels it too
+ * @source GUESS — the value, midway in the measured bracket (11, 12)
+ * @measure M-CM3
+ */
+ allowableMovement: 11.5,
+ /**
+ * When the menu displays for a finger that is still down: the delegate's
+ * willDisplay, with the backdrop and the menu. Until then, only the press
+ * copy shows, and it grows on the second ramp. A finger lifted after the
+ * commit gets the menu at the lift.
+ * @source measured: UIKit lab (injected host app), iOS 26.2 simulator,
+ * iPhone 17 Pro, delegate log and per-frame view tree, Oct 23 2026:
+ * 735–738 ms after the touch over five warm presses at random display
+ * phase (734 ms on the first press of a session); a press lifted at
+ * 0.5 s displayed at the lift (529 ms)
+ */
+ menuDisplayMs: 735,
+ /**
+ * The size the press copy reaches when the menu displays, as a fraction
+ * of the view. It is the second ramp at `menuDisplayMs`: 1 + 0.1 per
+ * second since the touch. The trigger grows toward it on
+ * `springs.contextMenuLift`, not on UIKit's ramp.
+ * @source measured: UIKit lab (injected host app), iOS 26.2 simulator,
+ * iPhone 17 Pro, per-frame model frames of the press platter over a
+ * 200 × 120 pt view, Oct 23 2026: 0.1001 per second, linear over 19
+ * frames, zero at the touch (−1.4 ms), at 735 ms
+ * @measure M-CM2
+ */
+ heldScale: 1.0735,
+ },
+ /**
+ * The click haptic at the commit, as a vibration where that is the only
+ * haptic (Android browsers). UIKit plays a private pattern
+ * (`_UIClickPresentationFeedbackGenerator`) at the commit; iOS Safari can
+ * play nothing at that moment, because no tap lands then.
+ * @source measured: UIKit lab (injected host app), iOS 26.2 simulator,
+ * iPhone 17 Pro, UIFeedbackGenerator hook, Oct 23 2026: the click
+ * presentation feedback plays 3 ms after the commit, nothing plays for a
+ * press lifted before it (the moment)
+ * @source GUESS — a medium impact stands in for the private pattern (the
+ * kind)
+ * @measure M-CM5
+ */
+ commitHaptic: 'impactMedium',
+ /**
+ * Reduce Motion: whether the press feedback still grows the view. It does
+ * not; only the copy's shadow fades in, and the haptic and the menu stay.
+ * @source measured: UIKit lab (injected host app), iOS 26.2 simulator,
+ * iPhone 17 Pro, per-frame platter frames with Reduce Motion on, Prefer
+ * Cross-Fade off and on, Oct 23 2026: the platter stays at scale 1 and
+ * opacity 1 through the hold while its shadow opacity rises 0 → 0.31 by
+ * 0.6 s; a press lifted at 0.25 s does not grow either
+ */
+ reducedMotionFeedback: false,
+} as const;
diff --git a/packages/core/src/privateAttributes/contextMenuTrigger.stylex.ts b/packages/core/src/privateAttributes/contextMenuTrigger.stylex.ts
new file mode 100644
index 0000000000000..fb57645f753b2
--- /dev/null
+++ b/packages/core/src/privateAttributes/contextMenuTrigger.stylex.ts
@@ -0,0 +1,27 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file privateAttributes/contextMenuTrigger.stylex.ts
+ * @input A ContextMenu trigger whose touch press feedback is attached
+ * @output markContextMenuTrigger, which marks the trigger, and
+ * closestContextMenuTrigger, which finds the trigger at or above an element
+ * @position Owner module of the private context-menu-trigger attribute: the
+ * only file that writes its name. ContextMenu's press feedback
+ * (ContextMenu/contextMenuPressFeedback.ts) marks its trigger and finds the
+ * trigger a press belongs to. No package entry exports it.
+ */
+
+const CONTEXT_MENU_TRIGGER = 'data-astryx-context-menu-trigger';
+
+/** Marks `trigger` as a ContextMenu trigger. The returned call unmarks it. */
+export function markContextMenuTrigger(trigger: Element): () => void {
+ trigger.setAttribute(CONTEXT_MENU_TRIGGER, '');
+ return () => {
+ trigger.removeAttribute(CONTEXT_MENU_TRIGGER);
+ };
+}
+
+/** The ContextMenu trigger at or above `element`, or null outside one. */
+export function closestContextMenuTrigger(element: Element): Element | null {
+ return element.closest(`[${CONTEXT_MENU_TRIGGER}]`);
+}
diff --git a/packages/core/src/utils/pressableCoverage.test.ts b/packages/core/src/utils/pressableCoverage.test.ts
index 965ab38c0c8f0..481f142f5b466 100644
--- a/packages/core/src/utils/pressableCoverage.test.ts
+++ b/packages/core/src/utils/pressableCoverage.test.ts
@@ -15,7 +15,10 @@
* holds it equal to the marked set:
*
* - A file paints a press when its StyleX carries an `':active` key, a
- * `[data-astryx-press` arm, or composes `interactionOverlayStyles`.
+ * `[data-astryx-press` arm, or composes `interactionOverlayStyles`. It
+ * also paints one when its script follows the pressed state that a
+ * controller writes, as ContextMenu's growth does. A script that also
+ * writes that state is a press controller, so it is part of the model.
* - A file is marked when it calls `usePressFeedback(`.
* - A file whose press arms are read off an ancestor scope marker
* (`stylex.when.ancestor(':active', someScope)`, the way an indicator
@@ -73,6 +76,13 @@ const source = new Map(
// a bare attribute selector or inside `:is(…)`.
const PRESS_ARM =
/':active|'(?::is\()?\[data-astryx-press=|interactionOverlayStyles\./;
+function paintsPress(text: string): boolean {
+ return (
+ PRESS_ARM.test(text) ||
+ (text.includes('getAttribute(PRESSED_ATTRIBUTE)') &&
+ !text.includes('setAttribute(PRESSED_ATTRIBUTE'))
+ );
+}
const ANCESTOR_ARM =
/stylex\.when\.ancestor\(\s*'(?::active|\[data-astryx-press=[^)]*)',\s*(\w+)\s*,?\s*\)/g;
@@ -145,7 +155,7 @@ function importers(file: string): string[] {
}
const pressArmFiles = [...source.entries()]
- .filter(([file, text]) => !MODEL_FILES.has(file) && PRESS_ARM.test(text))
+ .filter(([file, text]) => !MODEL_FILES.has(file) && paintsPress(text))
.map(([file]) => file)
.sort();
@@ -229,7 +239,7 @@ describe('every surface that paints a press is reachable by the touch press cont
);
const unexplained = marked.filter(file => {
const text = source.get(file) ?? '';
- if (PRESS_ARM.test(text)) {
+ if (paintsPress(text)) {
return false;
}
return ![...scopeNames].some(scope =>
diff --git a/scripts/lazy-sheet-bundle.test.mjs b/scripts/lazy-sheet-bundle.test.mjs
index d0f74abb83cb5..807fb86c36323 100644
--- a/scripts/lazy-sheet-bundle.test.mjs
+++ b/scripts/lazy-sheet-bundle.test.mjs
@@ -7,8 +7,9 @@
* @output Pins that a menu's static import keeps its on-demand bottom sheet's
* keyboard code on demand. The sheet's keyboard ride (the animator and
* `rideKeyboard`) stays in the chunks the import loads only when the sheet
- * opens. This holds though the layer runtime's keyboard cap imports the
- * keyboard module statically.
+ * opens. A menu that uses the animator at once loads it with the menu. This
+ * holds though the layer runtime's keyboard cap imports the keyboard module
+ * statically.
* @position Node test over source, so it needs no build
*/
@@ -110,20 +111,28 @@ function rideIn(bytes) {
describe('a menu with an on-demand bottom sheet', () => {
it.each([
- ['DropdownMenu', 'packages/core/src/DropdownMenu/index.ts'],
- ['ContextMenu', 'packages/core/src/ContextMenu/index.ts'],
- ['Selector', 'packages/core/src/Selector/index.ts'],
- ['MultiSelector', 'packages/core/src/MultiSelector/index.ts'],
+ ['DropdownMenu', 'packages/core/src/DropdownMenu/index.ts', []],
+ // ContextMenu's touch growth plays on the animator, so the animator loads
+ // with the menu. The sheet's own ride is then `rideKeyboard` alone.
+ [
+ 'ContextMenu',
+ 'packages/core/src/ContextMenu/index.ts',
+ ['packages/core/src/motion/animator.ts'],
+ ],
+ ['Selector', 'packages/core/src/Selector/index.ts', []],
+ ['MultiSelector', 'packages/core/src/MultiSelector/index.ts', []],
])(
"%s loads the sheet's keyboard ride only with the sheet",
- (name, entry) => {
+ (name, entry, eagerRide) => {
const {eager, onDemand} = importOf(entry, name);
// The sheet still rides the keyboard, on demand.
- expect(rideIn(onDemand)).toEqual([
- 'packages/core/src/keyboard/rideKeyboard.ts',
- 'packages/core/src/motion/animator.ts',
- ]);
- expect(rideIn(eager)).toEqual([]);
+ expect(rideIn(onDemand)).toEqual(
+ [
+ 'packages/core/src/keyboard/rideKeyboard.ts',
+ 'packages/core/src/motion/animator.ts',
+ ].filter(input => !eagerRide.includes(input)),
+ );
+ expect(rideIn(eager)).toEqual(eagerRide);
},
);
});