@ethlete/core 5.0.0-next.33 → 5.0.0-next.35

package/CHANGELOG.md

@@ -1,5 +1,42 @@
 # @ethlete/core
 
+## 5.0.0-next.35
+
+### Minor Changes
+
+- [`a20d0ce`](https://github.com/ethlete-io/ethdk/commit/a20d0cee2f9937ad45ac1fd5eaec3c1a6ac1d27c) Thanks [@TomTomB](https://github.com/TomTomB)! - Add `injectIsDocumentVisible()` — a signal for whether the page is the tab in front, which an
+  IntersectionObserver cannot tell you.
+
+- [#3037](https://github.com/ethlete-io/ethdk/pull/3037) [`d787b1d`](https://github.com/ethlete-io/ethdk/commit/d787b1de041da31b6974a9f1b06ceb6ba6f5f6c5) Thanks [@github-actions](https://github.com/apps/github-actions)! - Export `dragGestureFrom(event, element, { commitThreshold })` — the pointer-drag primitive that
+  `etDragHandle` is built on, now usable directly. It takes a `pointerdown` and returns an observable of
+  `start` / `move` / `end` (or a single `tapped` when the pointer never crossed the commit threshold),
+  completing with the gesture.
+
+  Prefer the directive. Reach for the primitive when the draggable element belongs to someone else's
+  template and you only have a delegated `pointerdown` — the case that motivated this: `et-table`'s
+  opt-in column-reorder feature attaches a drag to header cells the table itself renders, without the
+  table having to import any drag code.
+
+  `DragHandleDirective` is unchanged and now uses this primitive internally; `DragStartEvent` /
+  `DragMoveEvent` keep their import path.
+
+- [#3037](https://github.com/ethlete-io/ethdk/pull/3037) [`929e355`](https://github.com/ethlete-io/ethdk/commit/929e3554770a132b4791edd2c063fa677f758762) Thanks [@github-actions](https://github.com/apps/github-actions)! - `setupScrollRestoration` can now restore the previous scroll offset on browser back/forward navigation instead of scrolling to top, via `restore: { enabled: true }`.
+
+  - The offset is applied only once the content is tall enough to reach it, so query-driven pages no longer land at the wrong place while their skeleton/loading state is on screen. Options: `timeout`, `maxTimeout`, `clampOnTimeout`.
+  - `holdScrollRestoration(() => query.isLoading())` suspends the wait from inside a route component when the data takes longer than `timeout` to arrive.
+  - `scrollElement` now also accepts a getter (`() => HTMLElement | null`), for scroll containers that only exist after the app shell rendered or are created per route.
+
+### Patch Changes
+
+- [`4ffabfb`](https://github.com/ethlete-io/ethdk/commit/4ffabfbe1830d4560b98dcda7d262155273dd62e) Thanks [@TomTomB](https://github.com/TomTomB)! - `useCursorDragScroll` no longer starts a drag on a secondary click, and ends one when a context menu opens —
+  previously a right-click left it latched on, so every later mouse move scrolled the container.
+
+## 5.0.0-next.34
+
+### Patch Changes
+
+- [`ef65231`](https://github.com/ethlete-io/ethdk/commit/ef65231ed04184345200f1e6f2e80d3207778157) Thanks [@TomTomB](https://github.com/TomTomB)! - Auto-surface: content that is grafted into an overlay pane after it first renders (e.g. a select option's `etAutoSurface` avatar) now re-resolves its elevation once it lands in the pane, instead of staying stuck one level too low.
+
 ## 5.0.0-next.33
 
 ### Patch Changes

package/fesm2022/ethlete-core.mjs

@@ -1,5 +1,5 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, inject, ElementRef, Directive, assertInInjectionContext, DestroyRef, TemplateRef, QueryList, RendererFactory2, RendererStyleFlags2, isSignal, DOCUMENT, signal, linkedSignal, isDevMode, computed, afterNextRender, effect, NgZone, untracked, EnvironmentInjector, runInInjectionContext, Injector, booleanAttribute, numberAttribute, PLATFORM_ID, ApplicationRef, createComponent, model, ViewContainerRef, input, output, Pipe, ViewEncapsulation, Component } from '@angular/core';
+import { InjectionToken, inject, ElementRef, Directive, assertInInjectionContext, DestroyRef, TemplateRef, QueryList, RendererFactory2, RendererStyleFlags2, isSignal, DOCUMENT, signal, linkedSignal, isDevMode, computed, afterNextRender, effect, NgZone, untracked, EnvironmentInjector, runInInjectionContext, Injector, booleanAttribute, numberAttribute, PLATFORM_ID, ApplicationRef, createComponent, model, ViewContainerRef, input, output, Pipe, ViewEncapsulation, Component, afterEveryRender } from '@angular/core';
 import { takeUntilDestroyed, toSignal, toObservable, outputFromObservable } from '@angular/core/rxjs-interop';
 import { Subject, BehaviorSubject, debounceTime, combineLatest, map, merge, fromEvent, filter, tap, switchMap, startWith, of, defer, from, catchError, timer, takeUntil, pairwise, distinctUntilChanged, take, Observable, concatMap, EMPTY, concat, exhaustMap, share, isObservable, firstValueFrom, defaultIfEmpty } from 'rxjs';
 import { FormGroup, FormArray, FormControl } from '@angular/forms';
@@ -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';
@@ -2444,6 +2444,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 +2572,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 +2709,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 +2728,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(),
@@ -2951,22 +2971,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 +3158,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 +3174,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);
     });
 };
 
@@ -4776,6 +4964,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 +4985,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)));
@@ -7637,11 +7839,20 @@ class AutoSurfaceDirective {
         // rather than layering one level above a parent surface.
         this.isOverlaySurface = signal(false, /* @ts-ignore */
         ...(ngDevMode ? [{ debugName: "isOverlaySurface" }] : /* istanbul ignore next */ []));
+        // Bumped by the afterEveryRender watcher in the constructor whenever this element's overlay
+        // containment changes. surfaceForElement() below does a non-reactive element.contains() read,
+        // so the computed must be re-triggered when this element is (re)grafted into an overlay pane —
+        // otherwise a value cached from before the graft (one elevation too low) sticks forever.
+        this.domSettleTick = signal(0, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "domSettleTick" }] : /* istanbul ignore next */ []));
         this.resolvedSurface = computed(() => {
             const themes = this.surfaceThemes;
             if (!themes) {
                 return null;
             }
+            // Establish a dependency on the DOM-settle tick so the non-reactive containment read below
+            // is re-evaluated after the element is grafted into its final overlay pane.
+            this.domSettleTick();
             const contextProvider = this.surfaceProvider() ?? this.contextSurfaceProvider ?? null;
             const contextElevation = contextProvider?.elevation() ?? null;
             const contextType = contextProvider?.surfaceType() ?? null;
@@ -7688,6 +7899,29 @@ class AutoSurfaceDirective {
             return resolveSurfaceByElevation(themes, parentType, parentElevation + 1)?.name ?? null;
         }, /* @ts-ignore */
         ...(ngDevMode ? [{ debugName: "resolvedSurface" }] : /* istanbul ignore next */ []));
+        // Projected/portaled auto-surface content (e.g. a select option's avatar) can have its
+        // resolvedSurface computed run *before* it is grafted into the overlay pane it visually lives
+        // in — or while it is briefly mounted in an off-pane measuring container, as windowed lists do.
+        // surfaceForElement()'s element.contains() check then returns the wrong (or no) overlay, so it
+        // resolves off the declaration injector (the trigger location) one elevation too low. That check
+        // is a plain DOM read, not a signal, so nothing re-runs the computed once the element reaches its
+        // final pane. Watch the tracker result across renders and re-trigger the computed whenever the
+        // element's overlay containment changes, settling (and unsubscribing) once it stops moving.
+        let lastElevation = this.surfaceContextTracker.surfaceForElement(this.elementRef.nativeElement)?.elevation ?? null;
+        let stableRenders = 0;
+        const settleWatcher = afterEveryRender(() => {
+            const el = this.elementRef.nativeElement;
+            const elevation = this.surfaceContextTracker.surfaceForElement(el)?.elevation ?? null;
+            if (elevation !== lastElevation) {
+                lastElevation = elevation;
+                stableRenders = 0;
+                this.domSettleTick.update((v) => v + 1);
+            }
+            else if (el.isConnected && ++stableRenders >= 2) {
+                // containment has held for a couple of renders and the element is in the DOM — done moving
+                settleWatcher.destroy();
+            }
+        });
         effect(() => {
             const surface = this.resolvedSurface();
             untracked(() => {
@@ -8225,5 +8459,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, 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, 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, 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 };
 //# sourceMappingURL=ethlete-core.mjs.map