@svadmin/ui 0.38.1 → 0.38.5

package/dist/components/ui/tooltip/tooltip-context.svelte.js

@@ -0,0 +1,220 @@
+import { createContext } from 'svelte';
+import { Tooltip as TooltipPrimitive } from 'bits-ui';
+export class TooltipLayerContext {
+    defaultContentId;
+    #readOpen;
+    #writeOpen;
+    #readDisableHoverableContent;
+    #readActiveTriggerId;
+    #readExternalTrigger;
+    #readOnOpenChangeComplete;
+    #triggers = new Map();
+    #readContentId;
+    #contentNode = null;
+    #closeTimer;
+    #transitionFrame = null;
+    #transitionGeneration = 0;
+    #destroyed = false;
+    shouldRender = $state(false);
+    presenceStatus = $state(undefined);
+    constructor(defaultContentId, readOpen, writeOpen, readDisableHoverableContent, readActiveTriggerId, readExternalTrigger = () => null, readOnOpenChangeComplete = () => undefined) {
+        this.defaultContentId = defaultContentId;
+        this.#readOpen = readOpen;
+        this.#writeOpen = writeOpen;
+        this.#readDisableHoverableContent = readDisableHoverableContent;
+        this.#readActiveTriggerId = readActiveTriggerId;
+        this.#readExternalTrigger = readExternalTrigger;
+        this.#readOnOpenChangeComplete = readOnOpenChangeComplete;
+        this.#readContentId = () => defaultContentId;
+        this.shouldRender = readOpen();
+    }
+    get open() {
+        return this.#readOpen();
+    }
+    get trigger() {
+        const activeTriggerId = this.activeTriggerId;
+        if (!activeTriggerId)
+            return null;
+        return this.#triggers.get(activeTriggerId)?.() ?? this.#readExternalTrigger(activeTriggerId);
+    }
+    get activeTriggerId() {
+        return this.#readActiveTriggerId();
+    }
+    get contentId() {
+        return this.#readContentId();
+    }
+    get disableHoverableContent() {
+        return this.#readDisableHoverableContent();
+    }
+    close() {
+        if (this.#destroyed)
+            return;
+        this.cancelScheduledClose();
+        this.#writeOpen(false);
+    }
+    scheduleClose(delay = 80) {
+        if (this.#destroyed)
+            return;
+        this.cancelScheduledClose();
+        this.#closeTimer = setTimeout(() => {
+            this.#closeTimer = undefined;
+            if (!this.#destroyed)
+                this.#writeOpen(false);
+        }, delay);
+    }
+    cancelScheduledClose() {
+        if (this.#closeTimer === undefined)
+            return;
+        clearTimeout(this.#closeTimer);
+        this.#closeTimer = undefined;
+    }
+    destroy() {
+        this.#destroyed = true;
+        this.cancelScheduledClose();
+        this.#cancelTransitionFrame();
+        this.#transitionGeneration += 1;
+        this.#triggers.clear();
+        this.#contentNode = null;
+        this.#readExternalTrigger = () => null;
+        this.#readOnOpenChangeComplete = () => undefined;
+        this.#readContentId = () => this.defaultContentId;
+    }
+    setContentNode(node) {
+        this.#contentNode = node;
+    }
+    transitionPresence(open) {
+        if (this.#destroyed)
+            return;
+        const generation = ++this.#transitionGeneration;
+        this.#cancelTransitionFrame();
+        if (open)
+            this.shouldRender = true;
+        this.presenceStatus = open ? 'starting' : 'ending';
+        const readAnimations = () => {
+            this.#transitionFrame = null;
+            if (!this.#isCurrentTransition(generation, open))
+                return;
+            const contentNode = this.#contentNode;
+            if (!contentNode || typeof contentNode.getAnimations !== 'function') {
+                this.#completeTransition(generation, open);
+                return;
+            }
+            let animations;
+            try {
+                animations = contentNode.getAnimations({ subtree: true });
+            }
+            catch {
+                this.#completeTransition(generation, open);
+                return;
+            }
+            if (animations.length === 0) {
+                this.#completeTransition(generation, open);
+                return;
+            }
+            void Promise.allSettled(animations.map((animation) => animation.finished)).then(() => {
+                this.#completeTransition(generation, open);
+            });
+        };
+        const scheduleAnimationRead = () => {
+            if (typeof window.requestAnimationFrame === 'function') {
+                this.#transitionFrame = window.requestAnimationFrame(readAnimations);
+            }
+            else {
+                queueMicrotask(readAnimations);
+            }
+        };
+        const prepareAnimationRead = () => {
+            this.#transitionFrame = null;
+            if (!this.#isCurrentTransition(generation, open))
+                return;
+            if (open) {
+                this.presenceStatus = undefined;
+                scheduleAnimationRead();
+                return;
+            }
+            readAnimations();
+        };
+        if (typeof window.requestAnimationFrame === 'function') {
+            this.#transitionFrame = window.requestAnimationFrame(prepareAnimationRead);
+        }
+        else {
+            queueMicrotask(prepareAnimationRead);
+        }
+    }
+    #isCurrentTransition(generation, open) {
+        return !this.#destroyed && generation === this.#transitionGeneration && this.open === open;
+    }
+    #completeTransition(generation, open) {
+        if (!this.#isCurrentTransition(generation, open))
+            return;
+        this.presenceStatus = undefined;
+        if (!open)
+            this.shouldRender = false;
+        this.#readOnOpenChangeComplete()?.(open);
+    }
+    #cancelTransitionFrame() {
+        if (this.#transitionFrame === null)
+            return;
+        window.cancelAnimationFrame(this.#transitionFrame);
+        this.#transitionFrame = null;
+    }
+    registerTrigger(triggerId, readTrigger) {
+        this.#triggers.set(triggerId, readTrigger);
+        return () => {
+            if (this.#triggers.get(triggerId) === readTrigger) {
+                this.#triggers.delete(triggerId);
+            }
+        };
+    }
+    isActiveTrigger(triggerId) {
+        return this.open && this.activeTriggerId === triggerId;
+    }
+    registerContentId(readContentId) {
+        this.#readContentId = readContentId;
+        return () => {
+            if (this.#readContentId === readContentId) {
+                this.#readContentId = () => this.defaultContentId;
+            }
+        };
+    }
+}
+export const [getTooltipLayerContext, setTooltipLayerContext] = createContext();
+export function tryGetTooltipLayerContext() {
+    try {
+        return getTooltipLayerContext();
+    }
+    catch {
+        return undefined;
+    }
+}
+export class TooltipTetherBridge {
+    layer = $state(null);
+    #triggers = new Map();
+    registerLayer(layer) {
+        this.layer = layer;
+        return () => {
+            if (this.layer === layer)
+                this.layer = null;
+        };
+    }
+    registerTrigger(triggerId, readTrigger) {
+        this.#triggers.set(triggerId, readTrigger);
+        return () => {
+            if (this.#triggers.get(triggerId) === readTrigger) {
+                this.#triggers.delete(triggerId);
+            }
+        };
+    }
+    getTrigger(triggerId) {
+        return this.#triggers.get(triggerId)?.() ?? null;
+    }
+}
+const tetherBridges = new WeakMap();
+export function getTooltipTetherBridge(tether) {
+    let bridge = tetherBridges.get(tether);
+    if (!bridge) {
+        bridge = new TooltipTetherBridge();
+        tetherBridges.set(tether, bridge);
+    }
+    return bridge;
+}

package/dist/components/ui/tooltip/tooltip-layer-registry.svelte.d.ts

@@ -0,0 +1,11 @@
+export type TooltipLayerBehavior = 'close' | 'defer-otherwise-close' | 'defer-otherwise-ignore' | 'ignore';
+export type TooltipLayerRegistration = {
+    containsTarget: (target: EventTarget | null) => boolean;
+    getInteractOutsideBehavior: () => TooltipLayerBehavior;
+    getEscapeKeydownBehavior: () => TooltipLayerBehavior;
+    onInteractOutside: (event: PointerEvent) => void;
+    onFocusOutside: (event: FocusEvent) => void;
+    onEscapeKeydown: (event: KeyboardEvent) => void;
+    close: () => void;
+};
+export declare function registerTooltipLayer(ownerDocument: Document, layer: TooltipLayerRegistration): () => void;

package/dist/components/ui/tooltip/tooltip-layer-registry.svelte.js

@@ -0,0 +1,93 @@
+class TooltipLayerRegistry {
+    ownerDocument;
+    #layers = [];
+    #listening = false;
+    constructor(ownerDocument) {
+        this.ownerDocument = ownerDocument;
+    }
+    register(layer) {
+        this.#layers = [...this.#layers, layer];
+        this.#ensureListeners();
+        return () => {
+            this.#layers = this.#layers.filter((candidate) => candidate !== layer);
+            if (this.#layers.length === 0)
+                this.#removeListeners();
+        };
+    }
+    #ensureListeners() {
+        if (this.#listening)
+            return;
+        this.#listening = true;
+        this.ownerDocument.addEventListener('pointerdown', this.#handlePointerDown, true);
+        this.ownerDocument.addEventListener('focusin', this.#handleFocusIn, true);
+        this.ownerDocument.defaultView?.addEventListener('keydown', this.#handleKeydown, true);
+    }
+    #removeListeners() {
+        if (!this.#listening)
+            return;
+        this.#listening = false;
+        this.ownerDocument.removeEventListener('pointerdown', this.#handlePointerDown, true);
+        this.ownerDocument.removeEventListener('focusin', this.#handleFocusIn, true);
+        this.ownerDocument.defaultView?.removeEventListener('keydown', this.#handleKeydown, true);
+    }
+    #handlePointerDown = (event) => {
+        if (this.#layers.some((candidate) => candidate.containsTarget(event.target)))
+            return;
+        const layer = this.#getResponsibleLayer((candidate) => candidate.getInteractOutsideBehavior());
+        if (!layer)
+            return;
+        const behavior = layer.getInteractOutsideBehavior();
+        if (behavior !== 'close' && behavior !== 'defer-otherwise-close')
+            return;
+        layer.onInteractOutside(event);
+        if (!event.defaultPrevented)
+            layer.close();
+    };
+    #handleFocusIn = (event) => {
+        for (const layer of [...this.#layers]) {
+            if (!layer.containsTarget(event.target))
+                layer.onFocusOutside(event);
+        }
+    };
+    #handleKeydown = (event) => {
+        if (event.key !== 'Escape')
+            return;
+        const layer = this.#getResponsibleLayer((candidate) => candidate.getEscapeKeydownBehavior());
+        if (!layer)
+            return;
+        const behavior = layer.getEscapeKeydownBehavior();
+        if (behavior !== 'close' && behavior !== 'defer-otherwise-close') {
+            event.preventDefault();
+            return;
+        }
+        const KeyboardEventConstructor = this.ownerDocument.defaultView?.KeyboardEvent;
+        const callbackEvent = KeyboardEventConstructor
+            ? new KeyboardEventConstructor(event.type, event)
+            : event;
+        layer.onEscapeKeydown(callbackEvent);
+        const callbackPrevented = callbackEvent.defaultPrevented;
+        event.preventDefault();
+        if (!callbackPrevented)
+            layer.close();
+    };
+    #getResponsibleLayer(readBehavior) {
+        for (let index = this.#layers.length - 1; index >= 0; index -= 1) {
+            const layer = this.#layers[index];
+            if (!layer)
+                continue;
+            const behavior = readBehavior(layer);
+            if (behavior === 'close' || behavior === 'ignore')
+                return layer;
+        }
+        return this.#layers[0];
+    }
+}
+const registries = new WeakMap();
+export function registerTooltipLayer(ownerDocument, layer) {
+    let registry = registries.get(ownerDocument);
+    if (!registry) {
+        registry = new TooltipLayerRegistry(ownerDocument);
+        registries.set(ownerDocument, registry);
+    }
+    return registry.register(layer);
+}

package/dist/components/ui/tooltip/tooltip-trigger.svelte

@@ -1,7 +1,60 @@
-<script lang="ts">
+<script lang="ts" generics="Payload = never">
 	import { Tooltip as TooltipPrimitive } from "bits-ui";
+	import {
+		getTooltipTetherBridge,
+		tryGetTooltipLayerContext,
+	} from "./tooltip-context.svelte.js";
 
-	let { ref = $bindable(null), ...restProps }: TooltipPrimitive.TriggerProps = $props();
+	type PointerHandler = NonNullable<TooltipPrimitive.TriggerProps["onpointerenter"]>;
+	type TriggerPointerEvent = Parameters<PointerHandler>[0];
+
+	const uid = $props.id();
+	let {
+		ref = $bindable(null),
+		id = `tooltip-trigger-${uid}`,
+		"aria-describedby": ariaDescribedBy,
+		onpointerenter,
+		onpointerleave,
+		tether,
+		...restProps
+	}: TooltipPrimitive.TriggerProps<Payload> = $props();
+
+	const localTooltip = tryGetTooltipLayerContext();
+	const tetherBridge = $derived(tether ? getTooltipTetherBridge(tether) : undefined);
+	const tooltip = $derived(tether ? tetherBridge?.layer : localTooltip);
+
+	$effect(() => {
+		const currentBridge = tetherBridge;
+		if (currentBridge) return currentBridge.registerTrigger(id, () => ref);
+		if (!localTooltip) return;
+		return localTooltip.registerTrigger(id, () => ref);
+	});
+
+	const describedBy = $derived.by(() => {
+		const ids = [ariaDescribedBy, tooltip?.isActiveTrigger(id) ? tooltip.contentId : undefined]
+			.flatMap((value) => value?.split(/\s+/) ?? [])
+			.filter(Boolean);
+		return [...new Set(ids)].join(" ") || undefined;
+	});
+
+	function handlePointerEnter(event: TriggerPointerEvent) {
+		tooltip?.cancelScheduledClose();
+		onpointerenter?.(event);
+	}
+
+	function handlePointerLeave(event: TriggerPointerEvent) {
+		onpointerleave?.(event);
+		if (!event.defaultPrevented) tooltip?.scheduleClose();
+	}
 </script>
 
-<TooltipPrimitive.Trigger bind:ref data-slot="tooltip-trigger" {...restProps} />
+<TooltipPrimitive.Trigger
+	bind:ref
+	{...restProps}
+	{id}
+	{tether}
+	aria-describedby={describedBy}
+	data-slot="tooltip-trigger"
+	onpointerenter={handlePointerEnter}
+	onpointerleave={handlePointerLeave}
+/>

package/dist/components/ui/tooltip/tooltip-trigger.svelte.d.ts

@@ -1,4 +1,25 @@
 import { Tooltip as TooltipPrimitive } from "bits-ui";
-declare const TooltipTrigger: import("svelte").Component<TooltipPrimitive.TriggerProps, {}, "ref">;
-type TooltipTrigger = ReturnType<typeof TooltipTrigger>;
+declare function $$render<Payload = never>(): {
+    props: TooltipPrimitive.TriggerProps<Payload>;
+    exports: {};
+    bindings: "ref";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<Payload = never> {
+    props(): ReturnType<typeof $$render<Payload>>['props'];
+    events(): ReturnType<typeof $$render<Payload>>['events'];
+    slots(): ReturnType<typeof $$render<Payload>>['slots'];
+    bindings(): "ref";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <Payload = never>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<Payload>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<Payload>['props']>, ReturnType<__sveltets_Render<Payload>['events']>, ReturnType<__sveltets_Render<Payload>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<Payload>['bindings']>;
+    } & ReturnType<__sveltets_Render<Payload>['exports']>;
+    <Payload = never>(internal: unknown, props: ReturnType<__sveltets_Render<Payload>['props']> & {}): ReturnType<__sveltets_Render<Payload>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const TooltipTrigger: $$IsomorphicComponent;
+type TooltipTrigger<Payload = never> = InstanceType<typeof TooltipTrigger<Payload>>;
 export default TooltipTrigger;

package/dist/components/ui/tooltip/tooltip.svelte

@@ -1,10 +1,70 @@
-<script lang="ts">
+<script lang="ts" generics="Payload = never">
 	import { Tooltip as TooltipPrimitive } from "bits-ui";
+	import { onDestroy } from "svelte";
 	import TooltipProvider from "./tooltip-provider.svelte";
+	import {
+		getTooltipTetherBridge,
+		TooltipLayerContext,
+		setTooltipLayerContext,
+	} from "./tooltip-context.svelte.js";
 
-	let { open = $bindable(false), ...restProps }: TooltipPrimitive.RootProps = $props();
+	const uid = $props.id();
+	let {
+		open = $bindable(false),
+		triggerId = $bindable<string | null>(null),
+		disableHoverableContent,
+		onOpenChange,
+		onOpenChangeComplete,
+		tether,
+		...restProps
+	}: TooltipPrimitive.RootProps<Payload> = $props();
+	let observedInitialOpen = false;
+
+	function setOpen(value: boolean) {
+		if (open === value) return;
+		open = value;
+		onOpenChange?.(value);
+	}
+
+	const tooltipLayer = new TooltipLayerContext(
+		`tooltip-${uid}`,
+		() => open,
+		setOpen,
+		() => disableHoverableContent ?? false,
+		() => triggerId,
+		(activeTriggerId) =>
+			tether ? getTooltipTetherBridge(tether).getTrigger(activeTriggerId) : null,
+		() => onOpenChangeComplete
+	);
+	setTooltipLayerContext(tooltipLayer);
+
+	$effect(() => {
+		const currentTether = tether;
+		if (!currentTether) return;
+		return getTooltipTetherBridge(currentTether).registerLayer(tooltipLayer);
+	});
+
+	$effect(() => {
+		const currentOpen = open;
+		if (!observedInitialOpen) {
+			observedInitialOpen = true;
+			return;
+		}
+		tooltipLayer.transitionPresence(currentOpen);
+	});
+
+	onDestroy(() => {
+		tooltipLayer.destroy();
+	});
 </script>
 
 <TooltipProvider>
-	<TooltipPrimitive.Root bind:open {...restProps} />
+	<TooltipPrimitive.Root
+		bind:open
+		bind:triggerId
+		{disableHoverableContent}
+		{onOpenChange}
+		{tether}
+		{...restProps}
+	/>
 </TooltipProvider>

package/dist/components/ui/tooltip/tooltip.svelte.d.ts

@@ -1,4 +1,25 @@
 import { Tooltip as TooltipPrimitive } from "bits-ui";
-declare const Tooltip: import("svelte").Component<TooltipPrimitive.RootProps, {}, "open">;
-type Tooltip = ReturnType<typeof Tooltip>;
+declare function $$render<Payload = never>(): {
+    props: TooltipPrimitive.RootProps<Payload>;
+    exports: {};
+    bindings: "open" | "triggerId";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<Payload = never> {
+    props(): ReturnType<typeof $$render<Payload>>['props'];
+    events(): ReturnType<typeof $$render<Payload>>['events'];
+    slots(): ReturnType<typeof $$render<Payload>>['slots'];
+    bindings(): "open" | "triggerId";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <Payload = never>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<Payload>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<Payload>['props']>, ReturnType<__sveltets_Render<Payload>['events']>, ReturnType<__sveltets_Render<Payload>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<Payload>['bindings']>;
+    } & ReturnType<__sveltets_Render<Payload>['exports']>;
+    <Payload = never>(internal: unknown, props: ReturnType<__sveltets_Render<Payload>['props']> & {}): ReturnType<__sveltets_Render<Payload>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const Tooltip: $$IsomorphicComponent;
+type Tooltip<Payload = never> = InstanceType<typeof Tooltip<Payload>>;
 export default Tooltip;

package/dist/router-state.svelte.d.ts

@@ -1,4 +1,17 @@
 import type { RouterProvider } from '@svadmin/core';
+export interface RouterState {
+    readonly route: string;
+    readonly params: Record<string, string>;
+    readonly path: string;
+    readonly provider: RouterProvider | undefined;
+    init: (provider: RouterProvider | undefined) => void;
+    sync: () => void;
+    destroy: () => void;
+}
+export declare function createRouterState(): RouterState;
+/** Create and provide router state scoped to the current AdminApp tree. */
+export declare function provideRouterState(provider: RouterProvider | undefined): RouterState;
+export declare function getRouterState(): RouterState | undefined;
 export declare function initRouter(provider?: RouterProvider): void;
 export declare function getRoute(): string;
 export declare function getPath(): string;

package/dist/router-state.svelte.js

@@ -1,10 +1,5 @@
-// Shared reactive hash router state — .svelte.ts enables $state at module level
-import { matchRoute, setActiveRouterProvider } from '@svadmin/core/router';
-let _route = $state('/');
-let _params = $state({});
-let _path = $state('/');
-let _initialized = false;
-let _provider;
+import { createContext } from 'svelte';
+import { matchRoute } from '@svadmin/core/router';
 const ROUTES = [
     '/login',
     '/register',
@@ -56,47 +51,87 @@ const ROUTES = [
     '/:parent/:parentId/:resource/show/:id',
     '/:parent/:parentId/:resource/clone/:id',
 ];
-function sync() {
-    let path;
-    if (_provider) {
-        const parsed = _provider.parse();
-        path = parsed.pathname || '/';
-        const m = matchRoute(path, ROUTES);
-        _route = m?.route ?? '/';
-        _path = path;
-        _params = { ...(m?.params ?? {}), ...parsed.params };
+export function createRouterState() {
+    let route = $state('/');
+    let params = $state({});
+    let path = $state('/');
+    let provider;
+    let listenersAttached = false;
+    function sync() {
+        let nextPath;
+        let providerParams = {};
+        if (provider) {
+            const parsed = provider.parse();
+            nextPath = parsed.pathname || '/';
+            providerParams = parsed.params;
+        }
+        else {
+            nextPath = typeof window !== 'undefined'
+                ? window.location.hash.replace(/^#/, '') || '/'
+                : '/';
+        }
+        const match = matchRoute(nextPath, ROUTES);
+        route = match?.route ?? '/';
+        path = nextPath;
+        params = { ...providerParams, ...(match?.params ?? {}) };
     }
-    else {
-        path = typeof window !== 'undefined' ? window.location.hash.replace(/^#/, '') || '/' : '/';
-        const m = matchRoute(path, ROUTES);
-        _route = m?.route ?? '/';
-        _path = path;
-        _params = m?.params ?? {};
+    function attachListeners() {
+        if (listenersAttached || typeof window === 'undefined')
+            return;
+        window.addEventListener('hashchange', sync);
+        window.addEventListener('popstate', sync);
+        listenersAttached = true;
     }
+    return {
+        get route() { return route; },
+        get params() { return params; },
+        get path() { return path; },
+        get provider() { return provider; },
+        init(nextProvider) {
+            provider = nextProvider;
+            sync();
+            attachListeners();
+        },
+        sync,
+        destroy() {
+            if (!listenersAttached || typeof window === 'undefined')
+                return;
+            window.removeEventListener('hashchange', sync);
+            window.removeEventListener('popstate', sync);
+            listenersAttached = false;
+        },
+    };
 }
-export function initRouter(provider) {
-    _provider = provider;
-    setActiveRouterProvider(provider);
-    if (_initialized) {
-        sync(); // Re-sync manually since provider might have switched format/URLs
-        return;
+const [getRequiredRouterState, setRouterState] = createContext();
+/** Create and provide router state scoped to the current AdminApp tree. */
+export function provideRouterState(provider) {
+    const state = createRouterState();
+    state.init(provider);
+    setRouterState(state);
+    return state;
+}
+export function getRouterState() {
+    try {
+        return getRequiredRouterState();
     }
-    _initialized = true;
-    sync();
-    if (typeof window !== 'undefined') {
-        window.addEventListener('hashchange', sync);
-        window.addEventListener('popstate', sync);
+    catch {
+        return undefined;
     }
 }
+// Compatibility singleton for consumers that call initRouter outside AdminApp.
+const legacyRouterState = createRouterState();
+export function initRouter(provider) {
+    legacyRouterState.init(provider);
+}
 export function getRoute() {
-    return _route;
+    return getRouterState()?.route ?? legacyRouterState.route;
 }
 export function getPath() {
-    return _path;
+    return getRouterState()?.path ?? legacyRouterState.path;
 }
 export function getParams() {
-    return _params;
+    return getRouterState()?.params ?? legacyRouterState.params;
 }
 export function getRouterProviderInstance() {
-    return _provider;
+    return getRouterState()?.provider ?? legacyRouterState.provider;
 }