@ethlete/core 5.0.0-next.34 → 5.0.0-next.36

package/fesm2022/ethlete-core.mjs

@@ -7,7 +7,7 @@ import { SIGNAL, signalSetFn } from '@angular/core/primitives/signals';
 import { coerceElement } from '@angular/cdk/coercion';
 import { DOCUMENT as DOCUMENT$1, isPlatformBrowser } from '@angular/common';
 import { BreakpointObserver } from '@angular/cdk/layout';
-import { Router, NavigationEnd, NavigationSkipped } from '@angular/router';
+import { Router, NavigationEnd, NavigationSkipped, NavigationStart } from '@angular/router';
 import { Overlay } from '@angular/cdk/overlay';
 import { ComponentPortal } from '@angular/cdk/portal';
 import { autoUpdate, computePosition, offset, flip, size, shift, limitShift, arrow, hide } from '@floating-ui/dom';
@@ -1972,7 +1972,12 @@ const signalStyles = (el, styleMap) => {
 const signalHostStyles = (styleMap) => signalStyles(inject(ElementRef), styleMap);
 
 const elementCanScroll = (element, direction) => {
-    const el = element || document.documentElement;
+    // Omitting the element means "the document scroller". Resolved lazily and guarded so a call on the
+    // server answers "cannot scroll" instead of throwing on a missing `document`.
+    const el = element || (typeof document === 'undefined' ? null : document.documentElement);
+    if (!el) {
+        return false;
+    }
     const { scrollHeight, clientHeight, scrollWidth, clientWidth } = el;
     if (direction === 'x') {
         return scrollWidth > clientWidth;
@@ -1982,17 +1987,25 @@ const elementCanScroll = (element, direction) => {
     }
     return scrollHeight > clientHeight || scrollWidth > clientWidth;
 };
-const createViewportRect = () => ({
-    left: 0,
-    top: 0,
-    right: window.innerWidth,
-    bottom: window.innerHeight,
-    width: window.innerWidth,
-    height: window.innerHeight,
-    x: 0,
-    y: 0,
-    toJSON: () => ({}),
-});
+const createViewportRect = () => {
+    // Collapses to a zero rect where there is no window (server). `isElementVisible` never reaches the
+    // intersection math there anyway — `elementCanScroll` already reports the document as unscrollable
+    // — so the rect only has to be a valid shape.
+    const hasWindow = typeof window !== 'undefined';
+    const width = hasWindow ? window.innerWidth : 0;
+    const height = hasWindow ? window.innerHeight : 0;
+    return {
+        left: 0,
+        top: 0,
+        right: width,
+        bottom: height,
+        width,
+        height,
+        x: 0,
+        y: 0,
+        toJSON: () => ({}),
+    };
+};
 const isElementVisible = (options) => {
     const { container, element } = options;
     if (!element) {
@@ -2444,6 +2457,21 @@ const signalElementLastScrollDirection = (el) => {
 };
 const signalHostElementLastScrollDirection = () => signalElementLastScrollDirection(inject(ElementRef));
 
+/**
+ * A signal for whether this page is the one the reader is actually looking at — `false` for a backgrounded
+ * tab or a minimised window.
+ *
+ * Not the same question as whether an element is on screen: an IntersectionObserver reports a fully visible
+ * element in a background tab, because the tab's own visibility is no part of what it measures. Anything
+ * that moves on its own needs to ask both, and a timer is not a substitute — browsers throttle timers in a
+ * hidden tab rather than stopping them, so work keeps piling up out of sight.
+ */
+const injectIsDocumentVisible = memoizeSignal(() => {
+    const document = inject(DOCUMENT);
+    const isVisible = () => document.visibilityState === 'visible';
+    return toSignal(fromEvent(document, 'visibilitychange').pipe(map(isVisible)), { initialValue: isVisible() });
+});
+
 const areScrollStatesEqual = (a, b) => {
     return (a.canScroll === b.canScroll &&
         a.canScrollHorizontally === b.canScrollHorizontally &&
@@ -2557,6 +2585,8 @@ const writeViewportSizeToCssVariables = () => {
 
 /** The deadzone in pixels after which the cursor drag scroll will take effect. */
 const CURSOR_DRAG_SCROLL_DEADZONE = 5;
+/** `MouseEvent.button` for the primary button. A secondary click opens a menu; it does not drag. */
+const PRIMARY_MOUSE_BUTTON = 0;
 /** The class that is added to the element when the cursor is being dragged. */
 const CURSOR_DRAG_SCROLLING_CLASS = 'et-cursor-drag-scroll--scrolling';
 const CURSOR_DRAG_INIT_CLASS = 'et-cursor-drag-scroll--init';
@@ -2692,15 +2722,18 @@ const useCursorDragScroll = (el, options) => {
         dragAmount.set({ x: 0, y: 0 });
     };
     const setupDragging = (e) => {
-        const mouseUp = fromEvent(document, 'mouseup');
+        // A context menu takes the pointer away without ever delivering a `mouseup` — so without it in here, a
+        // right click (or a ctrl-click on a Mac, which is the primary button) leaves the drag latched on and
+        // every later mouse move scrolls the container.
+        const dragEnd = merge(fromEvent(document, 'mouseup'), fromEvent(document, 'contextmenu'));
         const mouseMove = fromEvent(document, 'mousemove');
         const el = element().currentElement;
         if (!el)
             return;
         mouseMove
-            .pipe(takeUntilDestroyed(destroyRef), takeUntil(mouseUp), tap((e) => updateDragging(e)))
+            .pipe(takeUntilDestroyed(destroyRef), takeUntil(dragEnd), tap((e) => updateDragging(e)))
             .subscribe();
-        mouseUp
+        dragEnd
             .pipe(take(1), takeUntilDestroyed(destroyRef), tap(() => updateDraggingEnd()))
             .subscribe();
         initialDragPosition.set({ x: e.clientX, y: e.clientY });
@@ -2708,7 +2741,7 @@ const useCursorDragScroll = (el, options) => {
         isInitDragging.set(true);
     };
     toObservable(element)
-        .pipe(map((e) => e?.currentElement), switchMap((el) => (el ? fromEvent(el, 'mousedown') : of(null))), filter((e) => !!e), filter(() => enabled()), tap((e) => setupDragging(e)), takeUntilDestroyed())
+        .pipe(map((e) => e?.currentElement), switchMap((el) => (el ? fromEvent(el, 'mousedown') : of(null))), filter((e) => !!e), filter((e) => e.button === PRIMARY_MOUSE_BUTTON), filter(() => enabled()), tap((e) => setupDragging(e)), takeUntilDestroyed())
         .subscribe();
     return {
         isDragging: isDragging.asReadonly(),
@@ -2941,6 +2974,31 @@ const injectPathParamChanges = memoizeSignal(() => {
         return changes;
     });
 });
+/**
+ * The state handed to the navigation that is currently in progress, i.e. what
+ * `router.navigate(…, { state })` passed — typed to whatever you expect.
+ *
+ * Read **synchronously**, in a constructor or a resolver, and deliberately not a signal: navigation state exists
+ * only for the duration of the navigation that carries it. By the time an effect flushed, the navigation would be
+ * over and the answer always `null`. Returns `null` when there is no navigation in flight or it carried no state —
+ * which is the normal case for a page arrived at by typing its URL, so always handle it.
+ *
+ * Use it for the things a URL should not carry: a "you were redirected because…" reason, a pre-fetched object the
+ * previous page already had, a scroll intent. Anything the page needs to survive a reload belongs in the URL.
+ *
+ * @example
+ * type CheckoutNavState = { fromCart: boolean };
+ *
+ * export class CheckoutComponent {
+ *   private navState = injectRouterNavigationState<CheckoutNavState>();
+ *
+ *   protected cameFromCart = this.navState?.fromCart ?? false;
+ * }
+ */
+const injectRouterNavigationState = () => {
+    const router = inject(Router);
+    return router.getCurrentNavigation()?.extras.state ?? null;
+};
 
 const ET_DISABLE_SCROLL_TOP = Symbol('ET_DISABLE_SCROLL_TOP');
 const ET_DISABLE_SCROLL_TOP_AS_RETURN_ROUTE = Symbol('ET_DISABLE_SCROLL_TOP_AS_RETURN_ROUTE');
@@ -2951,22 +3009,182 @@ const routerDisableScrollTop = (config = {}) => {
         ...(config.onPathParamChange ? { [ET_DISABLE_SCROLL_TOP_ON_PATH_PARAM_CHANGE]: true } : {}),
     };
 };
+/**
+ * Registry of "not settled yet" reporters. Lives in the root injector so a route component can
+ * reach the registration created by the app level `setupScrollRestoration` call.
+ * @internal
+ */
+const [, injectScrollRestorationHolds] = createRootProvider(() => {
+    const holds = new Set();
+    return {
+        add: (isPending) => {
+            holds.add(isPending);
+            return () => holds.delete(isPending);
+        },
+        isHeld: () => {
+            for (const isPending of holds) {
+                if (isPending())
+                    return true;
+            }
+            return false;
+        },
+    };
+}, { name: 'ScrollRestorationHolds' });
+/**
+ * Suspend scroll restoration while `isPending` reads `true`.
+ *
+ * Restoration already waits for the scroll container to grow tall enough to reach the saved offset,
+ * so this is only needed when the content may take longer than `restore.timeout` to get there —
+ * a slow list request, for instance. Registers for the lifetime of the current injection context.
+ *
+ * @example
+ * // inside a route component
+ * holdScrollRestoration(() => query.isLoading());
+ */
+const holdScrollRestoration = (isPending) => {
+    const remove = injectScrollRestorationHolds().add(isPending);
+    inject(DestroyRef).onDestroy(remove);
+};
+/** Upper bound on remembered history entries. Each entry is a single number, so this is generous. */
+const MAX_STORED_POSITIONS = 200;
+const DEFAULT_RESTORE_TIMEOUT = 1000;
+const DEFAULT_RESTORE_MAX_TIMEOUT = 10_000;
+/** Events that mean the user took over scrolling, so a pending restoration must be abandoned. */
+const INTERACTION_EVENTS = ['wheel', 'touchmove', 'keydown'];
 const setupScrollRestoration = (config = {}) => {
     if (!isPlatformBrowser(inject(PLATFORM_ID))) {
         return;
     }
     const router = inject(Router);
     const document = inject(DOCUMENT);
+    const injector = inject(Injector);
+    const holds = injectScrollRestorationHolds();
+    const restoreEnabled = config.restore?.enabled === true;
+    const restoreTimeout = config.restore?.timeout ?? DEFAULT_RESTORE_TIMEOUT;
+    const restoreMaxTimeout = config.restore?.maxTimeout ?? DEFAULT_RESTORE_MAX_TIMEOUT;
+    const clampOnTimeout = config.restore?.clampOnTimeout ?? true;
+    const resolveScrollElement = () => {
+        const el = typeof config.scrollElement === 'function' ? config.scrollElement() : config.scrollElement;
+        return el ?? document.documentElement;
+    };
+    // The browser restores the offset against the still-loading (much shorter) document, which is the
+    // exact problem we are solving — take it over completely.
+    if (restoreEnabled && 'scrollRestoration' in history) {
+        history.scrollRestoration = 'manual';
+    }
+    /** Saved offsets keyed by the router's per-history-entry `navigationId`. */
+    const positions = new Map();
+    // Mirrors Angular's own `RouterScroller`: the offset of the currently displayed page belongs to
+    // the navigation that produced it, and a popstate reports the id of the entry it moves to.
+    let lastNavigationId = 0;
+    let restoredNavigationId = 0;
+    let isPopstate = false;
     let prev = { state: createRouterState(router), route: createRoute(router) };
-    router.events
-        .pipe(filter((e) => e instanceof NavigationEnd || e instanceof NavigationSkipped), takeUntilDestroyed())
-        .subscribe(() => {
+    let pendingRestore = null;
+    const cancelPendingRestore = () => {
+        pendingRestore?.();
+        pendingRestore = null;
+    };
+    const scheduleRestore = (target) => {
+        cancelPendingRestore();
+        let frame = 0;
+        let started = false;
+        let cancelled = false;
+        // The user scrolling always wins over a restoration we have not committed yet.
+        const abortByUser = () => cancelPendingRestore();
+        const hardDeadline = Date.now() + Math.max(restoreTimeout, restoreMaxTimeout);
+        let deadline = Date.now() + restoreTimeout;
+        const step = () => {
+            frame = 0;
+            if (cancelled)
+                return;
+            const el = resolveScrollElement();
+            const maxOffset = Math.max(0, el.scrollHeight - el.clientHeight);
+            if (maxOffset >= target) {
+                el.scrollTop = target;
+                cancelPendingRestore();
+                return;
+            }
+            const now = Date.now();
+            // A registered hold means the page knows more data is coming, so the content is expected to
+            // grow — suspend the clock instead of giving up on a still loading page.
+            if (holds.isHeld() && now < hardDeadline) {
+                deadline = now + restoreTimeout;
+            }
+            if (now < deadline && now < hardDeadline) {
+                frame = requestAnimationFrame(step);
+                return;
+            }
+            if (clampOnTimeout && maxOffset > 0) {
+                el.scrollTop = Math.min(target, maxOffset);
+            }
+            cancelPendingRestore();
+        };
+        // Wait for the new route to actually render before reading any geometry — on `NavigationEnd` the
+        // components exist but the DOM still shows the previous page, whose height would be measured
+        // instead. The timeout is a safety net in case no render pass follows.
+        const start = () => {
+            if (started || cancelled)
+                return;
+            started = true;
+            frame = requestAnimationFrame(step);
+        };
+        const renderRef = afterNextRender({ read: start }, { injector });
+        const fallback = setTimeout(start);
+        for (const eventName of INTERACTION_EVENTS) {
+            document.addEventListener(eventName, abortByUser, { capture: true, passive: true });
+        }
+        pendingRestore = () => {
+            // `cancelled` is not redundant with destroying the render hook: a superseded restoration must
+            // not apply its (now stale) offset even if its hook had already been queued to run.
+            cancelled = true;
+            renderRef.destroy();
+            if (frame)
+                cancelAnimationFrame(frame);
+            clearTimeout(fallback);
+            for (const eventName of INTERACTION_EVENTS) {
+                document.removeEventListener(eventName, abortByUser, { capture: true });
+            }
+        };
+    };
+    const onNavigationStart = (event) => {
+        // A new navigation supersedes a restoration that has not committed yet.
+        cancelPendingRestore();
+        if (!restoreEnabled)
+            return;
+        positions.set(lastNavigationId, resolveScrollElement().scrollTop);
+        if (positions.size > MAX_STORED_POSITIONS) {
+            const oldest = positions.keys().next();
+            if (!oldest.done)
+                positions.delete(oldest.value);
+        }
+        isPopstate = event.navigationTrigger === 'popstate';
+        restoredNavigationId = event.restoredState?.navigationId ?? 0;
+    };
+    const onNavigationEnd = (event) => {
         const curr = { state: createRouterState(router), route: createRoute(router) };
         const prevState = prev.state;
         const currState = curr.state;
         const sameUrlNavigation = prev.route === curr.route;
         const didFragmentChange = prevState.fragment !== currState.fragment;
         prev = curr;
+        if (event instanceof NavigationEnd) {
+            lastNavigationId = event.id;
+        }
+        else {
+            // A skipped same url navigation is not a history move, so there is nothing to restore.
+            isPopstate = false;
+            restoredNavigationId = 0;
+        }
+        if (restoreEnabled && isPopstate) {
+            const target = positions.get(restoredNavigationId);
+            // The saved offset wins over both scroll to top and fragment scrolling: the user may well have
+            // scrolled away from the anchor before leaving the page.
+            if (target !== undefined) {
+                scheduleRestore(target);
+                return;
+            }
+        }
         if (sameUrlNavigation) {
             const allQueryParams = [
                 ...new Set(Object.keys(prevState.queryParams).concat(Object.keys(currState.queryParams))),
@@ -2978,7 +3196,7 @@ const setupScrollRestoration = (config = {}) => {
             const caseQueryParams = changedQueryParams.some((key) => config.queryParamTriggerList?.includes(key));
             const caseFragment = didFragmentChange && config.fragment?.enabled;
             if (caseQueryParams) {
-                (config.scrollElement ?? document.documentElement).scrollTop = 0;
+                resolveScrollElement().scrollTop = 0;
             }
             else if (caseFragment) {
                 const fragmentElement = document.getElementById(currState.fragment ?? '');
@@ -2994,9 +3212,17 @@ const setupScrollRestoration = (config = {}) => {
             if (viaReturnRoute || explicitly || pathParamsChange) {
                 return;
             }
-            const el = config.scrollElement ?? document.documentElement;
-            el.scrollTop = 0;
+            resolveScrollElement().scrollTop = 0;
         }
+    };
+    router.events
+        .pipe(filter((e) => e instanceof NavigationStart || e instanceof NavigationEnd || e instanceof NavigationSkipped), takeUntilDestroyed())
+        .subscribe((event) => {
+        if (event instanceof NavigationStart) {
+            onNavigationStart(event);
+            return;
+        }
+        onNavigationEnd(event);
     });
 };
 
@@ -3575,6 +3801,8 @@ const getClientXY = (event) => {
     }
     return { clientX: event.clientX, clientY: event.clientY };
 };
+/** Trailing window over which {@link SwipeTracker.end} measures the release velocity. */
+const SWIPE_VELOCITY_WINDOW_MS = 100;
 const createSwipeTracker = (startEvent) => {
     const { clientX: originClientX, clientY: originClientY } = getClientXY(startEvent);
     const startTime = Date.now();
@@ -3582,10 +3810,25 @@ const createSwipeTracker = (startEvent) => {
     let movementY = 0;
     let isSwiping = false;
     let isScrolling = false;
+    /**
+     * Recent positions, oldest first, used to derive the release velocity. Trimmed to the trailing
+     * window plus the one sample just before it, which serves as that window's baseline.
+     */
+    let samples = [{ t: startTime, movementX: 0, movementY: 0 }];
     const update = (event) => {
         const { clientX, clientY } = getClientXY(event);
         movementX = clientX - originClientX;
         movementY = clientY - originClientY;
+        const now = Date.now();
+        samples.push({ t: now, movementX, movementY });
+        // Trim against the newest sample rather than `now + window`: `end()` measures from its own
+        // timestamp, which is never earlier, so this always keeps a superset of what it needs.
+        const cutoff = now - SWIPE_VELOCITY_WINDOW_MS;
+        let dropCount = 0;
+        while (dropCount + 1 < samples.length && samples[dropCount + 1].t < cutoff)
+            dropCount++;
+        if (dropCount)
+            samples = samples.slice(dropCount);
         const positiveMovementX = Math.abs(movementX);
         const positiveMovementY = Math.abs(movementY);
         if (!isSwiping && !isScrolling) {
@@ -3608,12 +3851,31 @@ const createSwipeTracker = (startEvent) => {
             isSwiping,
         };
     };
+    const measureReleaseVelocity = (endTime) => {
+        const windowStart = endTime - SWIPE_VELOCITY_WINDOW_MS;
+        const firstInWindow = samples.findIndex((sample) => sample.t >= windowStart);
+        // Nothing moved during the window: the pointer was held still before release, so the gesture
+        // carries no momentum no matter how fast it started out.
+        if (firstInWindow === -1)
+            return { x: 0, y: 0 };
+        const newest = samples[samples.length - 1];
+        // Measure across the window when it holds a span of its own. With a single sample in it — a
+        // pointer emitting moves slower than the window — reach back one sample for a baseline instead
+        // of reporting nothing.
+        const hasSpanInWindow = samples.length - firstInWindow >= 2;
+        const baseline = samples[hasSpanInWindow ? firstInWindow : Math.max(0, firstInWindow - 1)];
+        const elapsed = newest.t - baseline.t;
+        if (elapsed <= 0)
+            return { x: 0, y: 0 };
+        return {
+            x: ((newest.movementX - baseline.movementX) / elapsed) * 1000,
+            y: ((newest.movementY - baseline.movementY) / elapsed) * 1000,
+        };
+    };
     const end = () => {
-        const swipeTime = Math.max(1, Date.now() - startTime);
         const positiveMovementX = Math.abs(movementX);
         const positiveMovementY = Math.abs(movementY);
-        const pixelPerSecondX = (movementX / swipeTime) * 1000;
-        const pixelPerSecondY = (movementY / swipeTime) * 1000;
+        const { x: pixelPerSecondX, y: pixelPerSecondY } = measureReleaseVelocity(Date.now());
         return {
             movementX,
             movementY,
@@ -3630,6 +3892,7 @@ const createSwipeTracker = (startEvent) => {
     const cancel = () => {
         movementX = 0;
         movementY = 0;
+        samples = [{ t: Date.now(), movementX: 0, movementY: 0 }];
     };
     return { update, end, cancel };
 };
@@ -3717,6 +3980,56 @@ const [provideLocale, injectLocale] = createRootProvider(() => {
     name: 'Locale',
 });
 
+const resolveSource = (source, locale) => typeof source === 'function' ? source(locale) : source;
+/**
+ * The one mechanism for the strings a component renders or announces itself. Every domain in the UI
+ * library that has such strings exposes exactly this pair — `provide<Domain>Labels` to localize a
+ * subtree, `inject<Domain>Labels()` to read the result — so localizing an app is the same move
+ * repeated per domain rather than a different one each time.
+ *
+ * `defaults` may itself be locale-derived, for a domain that ships more than one language (the
+ * `@ethlete/query` error tables, say). Overrides are partial and layer on top of whatever the locale
+ * resolved to, so translating into a third language while keeping a shipped one as the base is the
+ * same call.
+ *
+ * The injector returns a **signal**, because both halves can change at runtime — read it in a
+ * template or computed, never destructure it once.
+ *
+ * @example
+ * export type BreadcrumbLabels = { navigation: string; overflow: string };
+ *
+ * export const DEFAULT_BREADCRUMB_LABELS: BreadcrumbLabels = {
+ *   navigation: 'Breadcrumb',
+ *   overflow: 'Show hidden levels',
+ * };
+ *
+ * export const [provideBreadcrumbLabels, injectBreadcrumbLabels, BREADCRUMB_LABELS] =
+ *   createLabels<BreadcrumbLabels>('BREADCRUMB_LABELS', DEFAULT_BREADCRUMB_LABELS);
+ *
+ * @example
+ * // consumer, fixed wording
+ * provideBreadcrumbLabels({ navigation: 'Brotkrumen' });
+ *
+ * // consumer, driven by the app's i18n and re-resolved on a locale change
+ * provideBreadcrumbLabels((locale) => ({ navigation: translate('breadcrumb.nav', locale) }));
+ */
+const createLabels = (name, defaults) => {
+    const token = new InjectionToken(name, {
+        providedIn: 'root',
+        factory: () => ({}),
+    });
+    const provide = (labels) => ({ provide: token, useValue: labels });
+    const injectFn = () => {
+        const source = inject(token);
+        const { currentLocale } = injectLocale();
+        return computed(() => {
+            const locale = currentLocale();
+            return { ...resolveSource(defaults, locale), ...resolveSource(source, locale) };
+        });
+    };
+    return [provide, injectFn, token];
+};
+
 const [provideStyleManager, injectStyleManager] = createRootProvider(() => {
     const appRef = inject(ApplicationRef);
     const destroyRef = inject(DestroyRef);
@@ -3799,8 +4112,23 @@ const fromNextFrame = () => {
         });
     });
 };
-const forceReflow = (element = document.body) => {
-    return element.offsetHeight;
+const forceReflow = (element) => {
+    // The `document.body` fallback is resolved lazily and guarded: there is nothing to reflow on the
+    // server, so this becomes a no-op instead of throwing on a missing `document`.
+    const el = element ?? (typeof document === 'undefined' ? null : document.body);
+    return el?.offsetHeight ?? 0;
+};
+/**
+ * Whether the user asked for reduced motion, read straight from `matchMedia`.
+ *
+ * Inside a component, prefer the reactive `injectPrefersReducedMotion()`. This is for the animation
+ * helpers that run from effects, event handlers and imperative APIs, where there is no injection
+ * context. Pass the element being animated so the query resolves against its own window — otherwise
+ * an animation inside an iframe would read the top-level document's preference.
+ */
+const matchesReducedMotion = (element) => {
+    const view = element?.ownerDocument.defaultView ?? (typeof window === 'undefined' ? null : window);
+    return view?.matchMedia('(prefers-reduced-motion: reduce)').matches ?? false;
 };
 
 const ANIMATED_LIFECYCLE_TOKEN = new InjectionToken('ANIMATED_LIFECYCLE_DIRECTIVE_TOKEN');
@@ -4489,11 +4817,11 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.7", ngImpor
         }], ctorParameters: () => [], propDecorators: { placement: [{ type: i0.Input, args: [{ isSignal: true, alias: "placement", required: false }] }], fallbackPlacements: [{ type: i0.Input, args: [{ isSignal: true, alias: "fallbackPlacements", required: false }] }], offset: [{ type: i0.Input, args: [{ isSignal: true, alias: "offset", required: false }] }], arrowPadding: [{ type: i0.Input, args: [{ isSignal: true, alias: "arrowPadding", required: false }] }], viewportPadding: [{ type: i0.Input, args: [{ isSignal: true, alias: "viewportPadding", required: false }] }], autoResize: [{ type: i0.Input, args: [{ isSignal: true, alias: "autoResize", required: false }] }], shift: [{ type: i0.Input, args: [{ isSignal: true, alias: "shift", required: false }] }], autoHide: [{ type: i0.Input, args: [{ isSignal: true, alias: "autoHide", required: false }] }], autoCloseIfReferenceHidden: [{ type: i0.Input, args: [{ isSignal: true, alias: "autoCloseIfReferenceHidden", required: false }] }], referenceElement: [{ type: i0.Input, args: [{ isSignal: true, alias: "referenceElement", required: false }] }], mirrorWidth: [{ type: i0.Input, args: [{ isSignal: true, alias: "mirrorWidth", required: false }] }] } });
 
 const createFlipAnimationGroup = (config) => {
-    const { elements, duration = 250, easing = 'cubic-bezier(0.4, 0, 0.2, 1)' } = config;
+    const { elements, duration = 250, easing = 'cubic-bezier(0.4, 0, 0.2, 1)', ignoreReducedMotion } = config;
     const flips = elements.map((el) => {
         const element = 'element' in el ? el.element : el;
         const originElement = 'originElement' in el ? el.originElement : undefined;
-        return createFlipAnimation({ element, originElement, duration, easing });
+        return createFlipAnimation({ element, originElement, duration, easing, ignoreReducedMotion });
     });
     const onStart$ = combineLatest(flips.map((animation) => animation.onStart$));
     const onFinish$ = combineLatest(flips.map((animation) => animation.onFinish$));
@@ -4517,7 +4845,7 @@ const createFlipAnimationGroup = (config) => {
     };
 };
 const createFlipAnimation = (config) => {
-    const { element: el, originElement = el, duration = 250, easing = 'cubic-bezier(0.4, 0, 0.2, 1)' } = config;
+    const { element: el, originElement = el, duration = 250, easing = 'cubic-bezier(0.4, 0, 0.2, 1)', ignoreReducedMotion = false, } = config;
     let initialRect = originElement.getBoundingClientRect();
     let animation = null;
     const onStart$ = new Subject();
@@ -4549,6 +4877,10 @@ const createFlipAnimation = (config) => {
             scaleX: initialRect.width / lastRect.width,
             scaleY: initialRect.height / lastRect.height,
         };
+        // Under reduced motion the element jumps straight to its final position. Collapsing the duration
+        // instead of bailing out keeps the `Animation` lifecycle intact, so callers that wait on
+        // `onFinish$` to clean up still get their event.
+        const effectiveDuration = !ignoreReducedMotion && matchesReducedMotion(el) ? 0 : duration;
         animation = el.animate([
             {
                 transformOrigin: 'top left',
@@ -4562,7 +4894,7 @@ const createFlipAnimation = (config) => {
                 transform: 'none',
             },
         ], {
-            duration,
+            duration: effectiveDuration,
             easing,
             fill: 'both',
         });
@@ -4776,6 +5108,20 @@ const setupDragObservable = (startEvent, el, commitThreshold) => {
     }), takeUntil(end$));
     return concat(moves$, defer(() => of(committed ? { type: 'end' } : { type: 'tapped' })));
 };
+/**
+ * Observe one drag gesture, starting from a `pointerdown` on `element`.
+ *
+ * Emits `start` once the pointer has travelled `commitThreshold` px (so a click is not a drag),
+ * immediately followed by a catch-up `move`, then a `move` per pointer move, and finally `end`. A
+ * pointer released before crossing the threshold emits a single `tapped` instead. The stream
+ * completes with the gesture, so there is nothing to unsubscribe on the happy path.
+ *
+ * This is the primitive behind {@link DragHandleDirective}. Prefer the directive; reach for this when
+ * the draggable element belongs to someone else's template (e.g. a table feature attaching a drag to
+ * header cells the table itself renders) and you can only work from a delegated `pointerdown`.
+ */
+const dragGestureFrom = (event, element, options) => setupDragObservable(event, element, options?.commitThreshold ?? 8);
+
 class DragHandleDirective {
     constructor() {
         this.el = inject(ElementRef);
@@ -4783,7 +5129,7 @@ class DragHandleDirective {
         ...(ngDevMode ? [{ debugName: "commitThreshold" }] : /* istanbul ignore next */ []));
         this.disabled = input(false, { ...(ngDevMode ? { debugName: "disabled" } : /* istanbul ignore next */ {}), transform: booleanAttribute });
         this.gestureStart$ = new Subject();
-        this.gesture$ = this.gestureStart$.pipe(exhaustMap((event) => setupDragObservable(event, this.el.nativeElement, this.commitThreshold())), takeUntilDestroyed(), share());
+        this.gesture$ = this.gestureStart$.pipe(exhaustMap((event) => dragGestureFrom(event, this.el.nativeElement, { commitThreshold: this.commitThreshold() })), takeUntilDestroyed(), share());
         this.dragTapped = outputFromObservable(this.gesture$.pipe(filter((e) => e.type === 'tapped'), map(() => undefined)));
         this.dragStarted = outputFromObservable(this.gesture$.pipe(filter((e) => e.type === 'start'), map((e) => e.data)));
         this.dragMoved = outputFromObservable(this.gesture$.pipe(filter((e) => e.type === 'move'), map((e) => e.data)));
@@ -5016,7 +5362,10 @@ const createAnchoredPositionCleanup = (strategy, paneElement, overlayRef, render
         if (arrowElement) {
             middleware.push(arrow({
                 element: arrowElement,
-                padding: strategy.arrowPadding ?? 4,
+                // keeps the arrow off a rounded pane corner by default: 12px covers the radius of the
+                // built-in boxed panes (--et-overlay-radius). Panes with a larger radius have to pass their
+                // own — an arrow whose base sits on the corner arc looks detached from the pane.
+                padding: strategy.arrowPadding ?? 12,
             }));
         }
         if (strategy.autoHide || strategy.autoCloseIfReferenceHidden) {
@@ -8257,5 +8606,5 @@ const createUnsavedChangesGuard = (config) => {
  * Generated bundle index. Do not edit.
  */
 
-export { ANIMATABLE_TOKEN, ANIMATED_IF_TOKEN, ANIMATED_LIFECYCLE_TOKEN, ANIMATION_DEBUG_STORAGE_KEY, AT_LEAST_ONE_REQUIRED, AnimatableDirective, AnimatedIfDirective, AnimatedLifecycleDirective, AnimatedOverlayDirective, AutoSurfaceDirective, BOUNDARY_ELEMENT_TOKEN, BREAKPOINT_INSTANCE_TOKEN, BREAKPOINT_ORDER, COLOR_PROVIDER, ClickOutsideDirective, ColorInteractiveContainerDirective, ColorInteractiveDirective, ColorInteractiveExcludeDirective, ColorInteractiveHasFocusDirective, DEFAULT_MULTI_INSTANCE_RELS, DEFAULT_MULTI_INSTANCE_TAGS, DEFAULT_VIEWPORT_CONFIG, DISABLE_LOGGER_PARAM, DragHandleDirective, ET_DISABLE_SCROLL_TOP, ET_DISABLE_SCROLL_TOP_AS_RETURN_ROUTE, ET_DISABLE_SCROLL_TOP_ON_PATH_PARAM_CHANGE, ET_PROPERTY_REMOVED, FOCUSABLE_SELECTOR, FOCUS_VISIBLE_TRACKER_TOKEN, HtmlToMarkdownPipe, IS_ARRAY_NOT_EMPTY, IS_EMAIL, InferMimeTypePipe, InitialsPipe, IsArrayNotEmpty, IsEmail, jsonLd as JsonLD, KeyPressManager, MUST_MATCH, MarkdownToHtmlPipe, MustMatch, NormalizeGameResultTypePipe, NormalizeMatchParticipantsPipe, NormalizeMatchScorePipe, NormalizeMatchStatePipe, NormalizeMatchTypePipe, PropsDirective, ProvideColorDirective, ProvideSurfaceDirective, RUNTIME_ERROR_NO_DATA, RepeatDirective, ResizeHandlesComponent, RuntimeError, SEO_DIRECTIVE_TOKEN, SURFACE_PROVIDER, SURFACE_TYPE, ScrollObserverDirective, ScrollObserverEndDirective, ScrollObserverStartDirective, SeoDirective, SlugifyPipe, StructuredDataComponent, SurfaceInteractiveDirective, ToArrayPipe, TypedQueryList, ValidateAtLeastOneRequired, Validators, animationDebugLog, applyAlternateBinding, applyAlternateLanguagesBindings, applyArticleBindings, applyAuthorBinding, applyCanonicalBinding, applyCenteredPosition, applyDescriptionBinding, applyGlobalPosition, applyHeadBinding, applyHeadTitleBinding, applyHostListener, applyHostListeners, applyInitialFocus, applyKeywordsBinding, applyLinkBinding, applyMetaBinding, applyNextBinding, applyOgBinding, applyOpenGraphBindings, applyPrevBinding, applyResourceHintsBindings, applyRobotsBinding, applySocialMediaBindings, applyStructuredDataBinding, applyTwitterCardBindings, areScrollStatesEqual, bindProps, boolBreakpointTransform, booleanBreakpointAttribute, boundingClientRectToElementRect, breakpointTransformBase, buildElementSignal, buildSignalEffects, canUseSessionMemory, clamp, clone, cloneFormGroup, computedTillFalsy, computedTillTruthy, controlValueSignal, controlValueSignalWithPrevious, copyToClipboard, createAnchoredPositionCleanup, createArrayPropertyBinding, createAutoSessionMemoryKey, createBulkPropertyBinding, createCanAnimateSignal, createComponentId, createCssColorThemeName, createCssSurfaceName, createDependencyStash, createDestroy, createDocumentElementSignal, createElementDictionary, createElementDimensions, createEmptyElementSignal, createFlipAnimation, createFlipAnimationGroup, createHostProps, createIsRenderedSignal, createLogger, createOverlayRuntimeRef, createPropHandlers, createPropertyBinding, createProps, createProvider, createRootProvider, createRootThemeCss, createRoute, createRouterState, createRxHostListener, createSessionMemory, createSetup, createStaticProvider, createStaticRootProvider, createSwatchCss, createSwipeTracker, createTailwindColorThemes, createTailwindCssVar, createTailwindRgbVar, createThemeStyle, createUnsavedChangesGuard, createUnsavedChangesTracker, createUserConsentProvider, deferredSignal, deleteCookie, easeElastic, easeIn, easeInOut, easeLinear, easeOut, easeOutBack, easeOutBackStrong, elementCanScroll, equal, firstElementSignal, focusElement, forceReflow, formatRuntimeError, fromNextFrame, getCookie, getDomain, getElementScrollCoordinates, getFocusableElements, getFormGroupValue, getGroupMatchPoints, getGroupMatchScore, getHeadingElement, getKnockoutMatchScore, getMatchScoreSubLine, getObjectProperty, getScrollContainerTarget, getScrollItemTarget, getScrollSnapTarget, hasCookie, htmlToMarkdown, inferMimeType, initials, injectAngularRootElement, injectAnimatedBlockSize, injectBoundaryElement, injectBreakpointInput, injectBreakpointIsMatched, injectBreakpointObserver, injectCanHover, injectColorThemes, injectColorThemesPrefix, injectCurrentBreakpoint, injectDeviceInputType, injectDisplayOrientation, injectErrorTheme, injectFocusVisibleTracker, injectFragment, injectHasPrecisionInput, injectHasTouchInput, injectHostElement, injectIs2Xl, injectIsLandscape, injectIsLg, injectIsMd, injectIsPortrait, injectIsRouterInitialized, injectIsSm, injectIsXl, injectIsXs, injectLinkStore, injectLinkStoreConfig, injectLocale, injectMediaQueryIsMatched, injectMetaConfig, injectMetaStore, injectObserveBreakpoint, injectObserveMediaQuery, injectOverlayRuntime, injectPathParam, injectPathParamChanges, injectPathParams, injectPrefersReducedMotion, injectQueryParam, injectQueryParamChanges, injectQueryParams, injectRenderer, injectRoute, injectRouteData, injectRouteDataItem, injectRouteTitle, injectRouterEvent, injectRouterState, injectScrollbarDimensions, injectStructuredDataConfig, injectStructuredDataStore, injectStyleManager, injectSuccessTheme, injectSurfaceContextTracker, injectSurfaceThemes, injectSurfaceThemesPrefix, injectTemplateRef, injectTitleConfig, injectTitleStore, injectUrl, injectViewportConfig, injectViewportDimensions, injectViewportSize, injectWarningTheme, isAnimationDebugEnabled, isArray, isElementSignal, isElementVisible, isFocusable, isGroupMatch, isHTMLElement, isKnockoutMatch, isObject, markdownToHtml, maybeSignalValue, memoizeSignal, nextFrame, normalizeGameResultType, normalizeMatchParticipant, normalizeMatchParticipants, normalizeMatchScore, normalizeMatchState, normalizeMatchType, normalizeUnsavedChangesSource, numberBreakpointAttribute, numberBreakpointTransform, previousSignalValue, provideBoundaryElement, provideBreakpointInstance, provideBreakpointObserver, provideColorThemes, provideColorThemesWithTailwind4, provideFocusVisibleTracker, provideLinkStore, provideLinkStoreConfig, provideLocale, provideMetaConfig, provideMetaStore, provideOverlayRuntime, provideRenderer, provideStructuredDataConfig, provideStructuredDataStore, provideStyleManager, provideSurfaceContextTracker, provideSurfaceThemesWithTailwind4, provideTitleConfig, provideTitleStore, provideViewportConfig, randomId, readFromClipboard, resetPositioningStyles, resolveAppRootColorProvider, resolveSurfaceByElevation, round, routerDisableScrollTop, scrollToElement, setBackdropStyles, setBaseElementStyles, setCookie, setInputSignal, setupFocusTrap, setupPositioning, setupScrollRestoration, signalAnimatedNumber, signalAttributes, signalClasses, signalElementChildren, signalElementDimensions, signalElementIntersection, signalElementLastScrollDirection, signalElementMutations, signalElementScrollState, signalHostAttributes, signalHostClasses, signalHostElementDimensions, signalHostElementIntersection, signalHostElementLastScrollDirection, signalHostElementMutations, signalHostElementScrollState, signalHostStyles, signalIsRendered, signalStyles, slugify, switchQueryListChanges, syncSignal, templateComputed, toArray, toArrayTrackByFn, toStringBinding, transformOrReturn, typedBreakpointTransform, unbindProps, useCursorDragScroll, writeScrollbarSizeToCssVariables, writeViewportSizeToCssVariables, ɵProvideColorThemes, ɵProvideColorThemesPrefix, ɵProvideSurfaceThemes, ɵProvideSurfaceThemesPrefix };
+export { ANIMATABLE_TOKEN, ANIMATED_IF_TOKEN, ANIMATED_LIFECYCLE_TOKEN, ANIMATION_DEBUG_STORAGE_KEY, AT_LEAST_ONE_REQUIRED, AnimatableDirective, AnimatedIfDirective, AnimatedLifecycleDirective, AnimatedOverlayDirective, AutoSurfaceDirective, BOUNDARY_ELEMENT_TOKEN, BREAKPOINT_INSTANCE_TOKEN, BREAKPOINT_ORDER, COLOR_PROVIDER, ClickOutsideDirective, ColorInteractiveContainerDirective, ColorInteractiveDirective, ColorInteractiveExcludeDirective, ColorInteractiveHasFocusDirective, DEFAULT_MULTI_INSTANCE_RELS, DEFAULT_MULTI_INSTANCE_TAGS, DEFAULT_VIEWPORT_CONFIG, DISABLE_LOGGER_PARAM, DragHandleDirective, ET_DISABLE_SCROLL_TOP, ET_DISABLE_SCROLL_TOP_AS_RETURN_ROUTE, ET_DISABLE_SCROLL_TOP_ON_PATH_PARAM_CHANGE, ET_PROPERTY_REMOVED, FOCUSABLE_SELECTOR, FOCUS_VISIBLE_TRACKER_TOKEN, HtmlToMarkdownPipe, IS_ARRAY_NOT_EMPTY, IS_EMAIL, InferMimeTypePipe, InitialsPipe, IsArrayNotEmpty, IsEmail, jsonLd as JsonLD, KeyPressManager, MUST_MATCH, MarkdownToHtmlPipe, MustMatch, NormalizeGameResultTypePipe, NormalizeMatchParticipantsPipe, NormalizeMatchScorePipe, NormalizeMatchStatePipe, NormalizeMatchTypePipe, PropsDirective, ProvideColorDirective, ProvideSurfaceDirective, RUNTIME_ERROR_NO_DATA, RepeatDirective, ResizeHandlesComponent, RuntimeError, SEO_DIRECTIVE_TOKEN, SURFACE_PROVIDER, SURFACE_TYPE, SWIPE_VELOCITY_WINDOW_MS, ScrollObserverDirective, ScrollObserverEndDirective, ScrollObserverStartDirective, SeoDirective, SlugifyPipe, StructuredDataComponent, SurfaceInteractiveDirective, ToArrayPipe, TypedQueryList, ValidateAtLeastOneRequired, Validators, animationDebugLog, applyAlternateBinding, applyAlternateLanguagesBindings, applyArticleBindings, applyAuthorBinding, applyCanonicalBinding, applyCenteredPosition, applyDescriptionBinding, applyGlobalPosition, applyHeadBinding, applyHeadTitleBinding, applyHostListener, applyHostListeners, applyInitialFocus, applyKeywordsBinding, applyLinkBinding, applyMetaBinding, applyNextBinding, applyOgBinding, applyOpenGraphBindings, applyPrevBinding, applyResourceHintsBindings, applyRobotsBinding, applySocialMediaBindings, applyStructuredDataBinding, applyTwitterCardBindings, areScrollStatesEqual, bindProps, boolBreakpointTransform, booleanBreakpointAttribute, boundingClientRectToElementRect, breakpointTransformBase, buildElementSignal, buildSignalEffects, canUseSessionMemory, clamp, clone, cloneFormGroup, computedTillFalsy, computedTillTruthy, controlValueSignal, controlValueSignalWithPrevious, copyToClipboard, createAnchoredPositionCleanup, createArrayPropertyBinding, createAutoSessionMemoryKey, createBulkPropertyBinding, createCanAnimateSignal, createComponentId, createCssColorThemeName, createCssSurfaceName, createDependencyStash, createDestroy, createDocumentElementSignal, createElementDictionary, createElementDimensions, createEmptyElementSignal, createFlipAnimation, createFlipAnimationGroup, createHostProps, createIsRenderedSignal, createLabels, createLogger, createOverlayRuntimeRef, createPropHandlers, createPropertyBinding, createProps, createProvider, createRootProvider, createRootThemeCss, createRoute, createRouterState, createRxHostListener, createSessionMemory, createSetup, createStaticProvider, createStaticRootProvider, createSwatchCss, createSwipeTracker, createTailwindColorThemes, createTailwindCssVar, createTailwindRgbVar, createThemeStyle, createUnsavedChangesGuard, createUnsavedChangesTracker, createUserConsentProvider, deferredSignal, deleteCookie, dragGestureFrom, easeElastic, easeIn, easeInOut, easeLinear, easeOut, easeOutBack, easeOutBackStrong, elementCanScroll, equal, firstElementSignal, focusElement, forceReflow, formatRuntimeError, fromNextFrame, getCookie, getDomain, getElementScrollCoordinates, getFocusableElements, getFormGroupValue, getGroupMatchPoints, getGroupMatchScore, getHeadingElement, getKnockoutMatchScore, getMatchScoreSubLine, getObjectProperty, getScrollContainerTarget, getScrollItemTarget, getScrollSnapTarget, hasCookie, holdScrollRestoration, htmlToMarkdown, inferMimeType, initials, injectAngularRootElement, injectAnimatedBlockSize, injectBoundaryElement, injectBreakpointInput, injectBreakpointIsMatched, injectBreakpointObserver, injectCanHover, injectColorThemes, injectColorThemesPrefix, injectCurrentBreakpoint, injectDeviceInputType, injectDisplayOrientation, injectErrorTheme, injectFocusVisibleTracker, injectFragment, injectHasPrecisionInput, injectHasTouchInput, injectHostElement, injectIs2Xl, injectIsDocumentVisible, injectIsLandscape, injectIsLg, injectIsMd, injectIsPortrait, injectIsRouterInitialized, injectIsSm, injectIsXl, injectIsXs, injectLinkStore, injectLinkStoreConfig, injectLocale, injectMediaQueryIsMatched, injectMetaConfig, injectMetaStore, injectObserveBreakpoint, injectObserveMediaQuery, injectOverlayRuntime, injectPathParam, injectPathParamChanges, injectPathParams, injectPrefersReducedMotion, injectQueryParam, injectQueryParamChanges, injectQueryParams, injectRenderer, injectRoute, injectRouteData, injectRouteDataItem, injectRouteTitle, injectRouterEvent, injectRouterNavigationState, injectRouterState, injectScrollbarDimensions, injectStructuredDataConfig, injectStructuredDataStore, injectStyleManager, injectSuccessTheme, injectSurfaceContextTracker, injectSurfaceThemes, injectSurfaceThemesPrefix, injectTemplateRef, injectTitleConfig, injectTitleStore, injectUrl, injectViewportConfig, injectViewportDimensions, injectViewportSize, injectWarningTheme, isAnimationDebugEnabled, isArray, isElementSignal, isElementVisible, isFocusable, isGroupMatch, isHTMLElement, isKnockoutMatch, isObject, markdownToHtml, matchesReducedMotion, maybeSignalValue, memoizeSignal, nextFrame, normalizeGameResultType, normalizeMatchParticipant, normalizeMatchParticipants, normalizeMatchScore, normalizeMatchState, normalizeMatchType, normalizeUnsavedChangesSource, numberBreakpointAttribute, numberBreakpointTransform, previousSignalValue, provideBoundaryElement, provideBreakpointInstance, provideBreakpointObserver, provideColorThemes, provideColorThemesWithTailwind4, provideFocusVisibleTracker, provideLinkStore, provideLinkStoreConfig, provideLocale, provideMetaConfig, provideMetaStore, provideOverlayRuntime, provideRenderer, provideStructuredDataConfig, provideStructuredDataStore, provideStyleManager, provideSurfaceContextTracker, provideSurfaceThemesWithTailwind4, provideTitleConfig, provideTitleStore, provideViewportConfig, randomId, readFromClipboard, resetPositioningStyles, resolveAppRootColorProvider, resolveSurfaceByElevation, round, routerDisableScrollTop, scrollToElement, setBackdropStyles, setBaseElementStyles, setCookie, setInputSignal, setupFocusTrap, setupPositioning, setupScrollRestoration, signalAnimatedNumber, signalAttributes, signalClasses, signalElementChildren, signalElementDimensions, signalElementIntersection, signalElementLastScrollDirection, signalElementMutations, signalElementScrollState, signalHostAttributes, signalHostClasses, signalHostElementDimensions, signalHostElementIntersection, signalHostElementLastScrollDirection, signalHostElementMutations, signalHostElementScrollState, signalHostStyles, signalIsRendered, signalStyles, slugify, switchQueryListChanges, syncSignal, templateComputed, toArray, toArrayTrackByFn, toStringBinding, transformOrReturn, typedBreakpointTransform, unbindProps, useCursorDragScroll, writeScrollbarSizeToCssVariables, writeViewportSizeToCssVariables, ɵProvideColorThemes, ɵProvideColorThemesPrefix, ɵProvideSurfaceThemes, ɵProvideSurfaceThemesPrefix };
 //# sourceMappingURL=ethlete-core.mjs.map