@dskripchenko/laravel-admin 1.41.0 → 1.42.0

package/dist/components/shell/breadcrumbs.d.ts

@@ -1,9 +1,9 @@
 /**
  * The top bar's breadcrumbs, derived from where the visitor is.
  *
- * The trail is the sidebar's: the menu item that matches the route — the way
- * AdminSidebarNode marks its active item — preceded by its group and its
- * parent items. A resource route adds what lies below the list: the record
+ * The trail is the sidebar's: the menu item that matches the route — the very
+ * one AdminSidebarNode marks active, through the shared findMenuTrail() —
+ * preceded by its group and its parent items. A resource route adds what lies below the list: the record
  * (named by its title, name or label, else #id) and "Editing" or "Creating".
  * A page the menu does not hold is named by its own title.
  *
@@ -11,24 +11,10 @@
  */
 import { type ComputedRef } from 'vue';
 import { type RouteLocationRaw } from 'vue-router';
-import { type MenuItem } from '../../stores/menu';
+import { findMenuTrail, menuMatchScore } from './menuTrail';
 export interface Crumb {
     label: string;
     to?: RouteLocationRaw | null;
 }
-interface RouteLike {
-    name?: unknown;
-    path: string;
-    params: Record<string, unknown>;
-    meta: Record<string, unknown>;
-}
-/** How well a menu item matches the route: 0 is no match, an exact one beats a prefix. */
-export declare function menuMatchScore(item: MenuItem, route: RouteLike): number;
-/**
- * The best-matching menu item with the chain of its parents, outermost first.
- * When several items lead to the same page, the shallowest one wins, then the
- * first in menu order.
- */
-export declare function findMenuTrail(items: MenuItem[], route: RouteLike): MenuItem[];
+export { findMenuTrail, menuMatchScore };
 export declare function useBreadcrumbs(): ComputedRef<Crumb[]>;
-export {};

package/dist/components/shell/menuTrail.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Which menu item the current page belongs to — one answer for the whole shell.
+ *
+ * The sidebar and the breadcrumbs used to decide this each on their own: the
+ * sidebar lit up every item that matched the route, the breadcrumbs picked one.
+ * With the same page reachable from two places (`/r/orders` under Shop and
+ * again under Showcase › Navigation › Nested menu) the sidebar opened one
+ * branch and the breadcrumbs named the other. Both now ask findMenuTrail().
+ *
+ * The rule, in order:
+ *   1. the most specific match: an exact one (route name or url) beats a
+ *      prefix one, and a longer prefix beats a shorter one;
+ *   2. the canonical node: one that points at the page by its route name (what
+ *      MenuNode::resource()/screen() produce) beats one that only repeats its
+ *      url;
+ *   3. the shallowest node: the page's home section rather than a shortcut
+ *      to it from deep inside another branch;
+ *   4. the first declared, in the menu's own order.
+ */
+import { type ComputedRef, type InjectionKey } from 'vue';
+import { type MenuItem } from '../../stores/menu';
+export interface RouteLike {
+    name?: unknown;
+    path: string;
+    params: Record<string, unknown>;
+    meta: Record<string, unknown>;
+}
+/** How well a menu item matches the route: 0 is no match, an exact one beats a prefix. */
+export declare function menuMatchScore(item: MenuItem, route: RouteLike): number;
+/**
+ * The best-matching menu item with the chain of its parents, outermost first;
+ * empty when no item matches. See the module's comment for the rule.
+ */
+export declare function findMenuTrail(items: MenuItem[], route: RouteLike): MenuItem[];
+/**
+ * Where a sidebar node sits: the keys from the root down to it.
+ *
+ * The nodes are matched against the trail by this path, not by object
+ * identity: the menu store rebuilds its items whenever the permissions are
+ * re-read, and the same key may appear in two branches (MenuNode::resource()
+ * gives every copy of a resource the key `resource.{slug}`).
+ */
+export declare const MENU_NODE_PATH: InjectionKey<string[]>;
+/** Whether the node at `path` lies on the trail; `exact` — whether it is its last item. */
+export declare function pathOnTrail(path: string[], trail: MenuItem[], exact?: boolean): boolean;
+/** The active trail the sidebar shares with its nodes. */
+export declare const ACTIVE_MENU_TRAIL: InjectionKey<ComputedRef<MenuItem[]>>;
+/** The active trail over the whole visible menu, for the current route. */
+export declare function useActiveMenuTrail(): ComputedRef<MenuItem[]>;
+/** The trail provided by the sidebar, or null outside of one. */
+export declare function injectActiveMenuTrail(): ComputedRef<MenuItem[]> | null;

package/dist/components/shell/menuTrail.test.d.ts

@@ -0,0 +1 @@
+export {};