@shwfed/config 2.12.5 → 2.12.6

package/dist/runtime/components/table/columns/2026-06-14/com.shwfed.table.column.tree-combobox-single/config.vue.d.ts

@@ -36,19 +36,19 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {},
         }[]] | undefined;
         readonly keywords?: string | undefined;
         readonly readonly?: string | undefined;
+        readonly binding: string;
+        readonly derived?: {
+            readonly mode: "formula" | "prefill";
+            readonly expression: string;
+        } | undefined;
         readonly dataSource: {
             readonly data: string;
             readonly request?: string | undefined;
         };
+        readonly enableSorting?: boolean | undefined;
         readonly nodeKey: string;
         readonly nodeChildren: string;
         readonly nodeLabel: string;
-        readonly enableSorting?: boolean | undefined;
-        readonly binding: string;
-        readonly derived?: {
-            readonly mode: "formula" | "prefill";
-            readonly expression: string;
-        } | undefined;
         readonly nodeTooltip?: readonly [{
             readonly locale: "zh";
             readonly message: string;
@@ -94,19 +94,19 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {},
         }[]] | undefined;
         readonly keywords?: string | undefined;
         readonly readonly?: string | undefined;
+        readonly binding: string;
+        readonly derived?: {
+            readonly mode: "formula" | "prefill";
+            readonly expression: string;
+        } | undefined;
         readonly dataSource: {
             readonly data: string;
             readonly request?: string | undefined;
         };
+        readonly enableSorting?: boolean | undefined;
         readonly nodeKey: string;
         readonly nodeChildren: string;
         readonly nodeLabel: string;
-        readonly enableSorting?: boolean | undefined;
-        readonly binding: string;
-        readonly derived?: {
-            readonly mode: "formula" | "prefill";
-            readonly expression: string;
-        } | undefined;
         readonly nodeTooltip?: readonly [{
             readonly locale: "zh";
             readonly message: string;

package/dist/runtime/components/table/schema.d.ts

@@ -157,40 +157,6 @@ export declare function TableConfig(configure: (env: Environment) => void): Sche
             readonly message: string;
         }[]] | undefined;
     }[];
-    readonly query?: {
-        readonly style?: string | undefined;
-        readonly id?: string | undefined;
-        readonly initial?: {
-            readonly data: string;
-            readonly request?: string | undefined;
-        } | undefined;
-        readonly displayName?: string | undefined;
-        readonly kind: "shwfed.component.form";
-        readonly fields: readonly any[];
-        readonly layouts: readonly {
-            readonly name: string;
-            readonly layout: {
-                readonly style?: string | undefined;
-                readonly columns: number;
-                readonly gap?: number | undefined;
-                readonly rows?: number | undefined;
-                readonly placements: {
-                    readonly [x: string]: {
-                        readonly area: readonly [readonly [number, number], readonly [number, number]];
-                        readonly v?: "stretch" | "center" | "end" | "start" | undefined;
-                        readonly h?: "stretch" | "center" | "end" | "start" | undefined;
-                    };
-                };
-            };
-            readonly media?: string | undefined;
-        }[];
-        readonly readonly?: string | undefined;
-    } | undefined;
-    readonly dataSource?: {
-        readonly data: string;
-        readonly total?: string | undefined;
-        readonly request?: string | undefined;
-    } | undefined;
     readonly actions?: {
         readonly size: "default" | "sm" | "xs";
         readonly style?: string | undefined;
@@ -258,6 +224,40 @@ export declare function TableConfig(configure: (env: Environment) => void): Sche
             readonly variant?: "default" | "link" | "destructive" | "primary" | "ghost" | undefined;
         }[];
     } | undefined;
+    readonly query?: {
+        readonly style?: string | undefined;
+        readonly id?: string | undefined;
+        readonly initial?: {
+            readonly data: string;
+            readonly request?: string | undefined;
+        } | undefined;
+        readonly displayName?: string | undefined;
+        readonly kind: "shwfed.component.form";
+        readonly fields: readonly any[];
+        readonly layouts: readonly {
+            readonly name: string;
+            readonly layout: {
+                readonly style?: string | undefined;
+                readonly columns: number;
+                readonly gap?: number | undefined;
+                readonly rows?: number | undefined;
+                readonly placements: {
+                    readonly [x: string]: {
+                        readonly area: readonly [readonly [number, number], readonly [number, number]];
+                        readonly v?: "stretch" | "center" | "end" | "start" | undefined;
+                        readonly h?: "stretch" | "center" | "end" | "start" | undefined;
+                    };
+                };
+            };
+            readonly media?: string | undefined;
+        }[];
+        readonly readonly?: string | undefined;
+    } | undefined;
+    readonly dataSource?: {
+        readonly data: string;
+        readonly total?: string | undefined;
+        readonly request?: string | undefined;
+    } | undefined;
     readonly bottomActions?: {
         readonly size: "default" | "sm" | "xs";
         readonly style?: string | undefined;
@@ -826,40 +826,6 @@ export declare function createTableConfig(body: Omit<Schema.Schema.Type<ReturnTy
             readonly message: string;
         }[]] | undefined;
     }[];
-    query?: {
-        readonly style?: string | undefined;
-        readonly id?: string | undefined;
-        readonly initial?: {
-            readonly data: string;
-            readonly request?: string | undefined;
-        } | undefined;
-        readonly displayName?: string | undefined;
-        readonly kind: "shwfed.component.form";
-        readonly fields: readonly any[];
-        readonly layouts: readonly {
-            readonly name: string;
-            readonly layout: {
-                readonly style?: string | undefined;
-                readonly columns: number;
-                readonly gap?: number | undefined;
-                readonly rows?: number | undefined;
-                readonly placements: {
-                    readonly [x: string]: {
-                        readonly area: readonly [readonly [number, number], readonly [number, number]];
-                        readonly v?: "stretch" | "center" | "end" | "start" | undefined;
-                        readonly h?: "stretch" | "center" | "end" | "start" | undefined;
-                    };
-                };
-            };
-            readonly media?: string | undefined;
-        }[];
-        readonly readonly?: string | undefined;
-    } | undefined;
-    dataSource?: {
-        readonly data: string;
-        readonly total?: string | undefined;
-        readonly request?: string | undefined;
-    } | undefined;
     actions?: {
         readonly size: "default" | "sm" | "xs";
         readonly style?: string | undefined;
@@ -927,6 +893,40 @@ export declare function createTableConfig(body: Omit<Schema.Schema.Type<ReturnTy
             readonly variant?: "default" | "link" | "destructive" | "primary" | "ghost" | undefined;
         }[];
     } | undefined;
+    query?: {
+        readonly style?: string | undefined;
+        readonly id?: string | undefined;
+        readonly initial?: {
+            readonly data: string;
+            readonly request?: string | undefined;
+        } | undefined;
+        readonly displayName?: string | undefined;
+        readonly kind: "shwfed.component.form";
+        readonly fields: readonly any[];
+        readonly layouts: readonly {
+            readonly name: string;
+            readonly layout: {
+                readonly style?: string | undefined;
+                readonly columns: number;
+                readonly gap?: number | undefined;
+                readonly rows?: number | undefined;
+                readonly placements: {
+                    readonly [x: string]: {
+                        readonly area: readonly [readonly [number, number], readonly [number, number]];
+                        readonly v?: "stretch" | "center" | "end" | "start" | undefined;
+                        readonly h?: "stretch" | "center" | "end" | "start" | undefined;
+                    };
+                };
+            };
+            readonly media?: string | undefined;
+        }[];
+        readonly readonly?: string | undefined;
+    } | undefined;
+    dataSource?: {
+        readonly data: string;
+        readonly total?: string | undefined;
+        readonly request?: string | undefined;
+    } | undefined;
     bottomActions?: {
         readonly size: "default" | "sm" | "xs";
         readonly style?: string | undefined;

package/dist/runtime/components/table/utils/row-reorder.d.ts

@@ -1,5 +1,6 @@
-export type RowReorderInstruction = 'reorder-above' | 'reorder-below';
-export declare function applyReorder<T>(rows: ReadonlyArray<T>, sourceIndex: number, targetIndex: number, position: RowReorderInstruction): ReadonlyArray<T>;
+import type { ReorderInstruction as RowReorderInstruction } from '../../../share/reorder.js';
+export type { ReorderInstruction as RowReorderInstruction } from '../../../share/reorder.js';
+export { applyReorder } from '../../../share/reorder.js';
 export interface UseRowReorderOptions {
     onReorder: (sourceId: string, targetId: string, position: RowReorderInstruction) => void;
     isEnabled: () => boolean;

package/dist/runtime/components/table/utils/row-reorder.js

@@ -9,18 +9,7 @@ import {
   attachInstruction,
   extractInstruction
 } from "@atlaskit/pragmatic-drag-and-drop-hitbox/tree-item";
-export function applyReorder(rows, sourceIndex, targetIndex, position) {
-  if (sourceIndex === targetIndex) return rows;
-  if (sourceIndex < 0 || sourceIndex >= rows.length) return rows;
-  if (targetIndex < 0 || targetIndex >= rows.length) return rows;
-  let insertIdx = targetIndex + (position === "reorder-below" ? 1 : 0);
-  if (sourceIndex < targetIndex) insertIdx -= 1;
-  if (insertIdx === sourceIndex) return rows;
-  const next = rows.slice();
-  const [moved] = next.splice(sourceIndex, 1);
-  next.splice(insertIdx, 0, moved);
-  return next;
-}
+export { applyReorder } from "../../../share/reorder.js";
 const SOURCE_KIND = "shwfed-table-row";
 export function useRowReorder(options) {
   const instruction = ref(null);

package/dist/runtime/components/tabs/index.d.vue.ts

@@ -0,0 +1,9 @@
+type __VLS_Props = {
+    storageKey?: string;
+    home?: string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    home: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/tabs/index.vue

@@ -0,0 +1,92 @@
+<script setup>
+import { onBeforeUnmount, onMounted } from "vue";
+import { useI18n } from "vue-i18n";
+import { navigateTo, useHead, useRoute, useRouter, useRuntimeConfig } from "#app";
+import ShwfedTab from "./tab.vue";
+import { useTabStore } from "./use-tabs";
+import { useTabReorder } from "./use-reorder";
+defineOptions({ name: "ShwfedTabs" });
+const props = defineProps({
+  storageKey: { type: String, required: false },
+  home: { type: String, required: false, default: "/" }
+});
+const runtimeConfig = useRuntimeConfig();
+const job = runtimeConfig.public.shwfed.ci.job;
+const store = useTabStore(props.storageKey ?? `shwfed:tabs:${job ?? "default"}`);
+const tabs = store.tabs;
+const activePath = store.activePath;
+const router = useRouter();
+const route = useRoute();
+const { locale } = useI18n({ useScope: "global", inheritLocale: true });
+useHead(() => {
+  const tab = tabs.value.find((t) => t.path === activePath.value);
+  return tab ? { title: store.resolveTitle(tab, locale.value) } : {};
+});
+let stopAfterEach;
+onMounted(() => {
+  store.openOrFocus(route.path, route.fullPath);
+  stopAfterEach = router.afterEach((to) => {
+    store.openOrFocus(to.path, to.fullPath);
+  });
+});
+onBeforeUnmount(() => stopAfterEach?.());
+const reorder = useTabReorder({
+  onReorder: (sourcePath, targetPath, edge) => {
+    store.reorder(sourcePath, targetPath, edge === "left" ? "reorder-above" : "reorder-below");
+  }
+});
+function onActivate(tab) {
+  if (tab.path !== activePath.value) void navigateTo(tab.fullPath);
+}
+function onClose(path) {
+  const dest = store.close(path, props.home);
+  if (dest) void navigateTo(dest);
+}
+function onCloseOthers(path) {
+  const dest = store.closeOthers(path);
+  if (dest) void navigateTo(dest);
+}
+function onCloseRight(path) {
+  const dest = store.closeToRight(path);
+  if (dest) void navigateTo(dest);
+}
+function onWheel(event) {
+  const el = event.currentTarget;
+  if (!el) return;
+  if (Math.abs(event.deltaY) <= Math.abs(event.deltaX)) return;
+  el.scrollLeft += event.deltaY;
+  event.preventDefault();
+}
+</script>
+
+<template>
+  <ClientOnly>
+    <div
+      v-if="tabs.length"
+      class="w-full border-b border-zinc-200 bg-zinc-50"
+    >
+      <!-- Scroller: overflow-x with the native scrollbar hidden (Firefox +
+           WebKit). The vertical-wheel handler drives horizontal scroll, so no
+           scrollbar is shown at all. -->
+      <div
+        class="flex h-9 overflow-x-auto overflow-y-hidden [scrollbar-width:none] [&::-webkit-scrollbar]:hidden"
+        @wheel="onWheel"
+      >
+        <ShwfedTab
+          v-for="tab in tabs"
+          :key="tab.path"
+          :title="store.resolveTitle(tab, locale)"
+          :active="tab.path === activePath"
+          :edge="reorder.edgeFor(tab.path)"
+          :dragging="reorder.isDragging(tab.path)"
+          :closable="tabs.length > 1"
+          :register="(el) => reorder.setTab(tab.path, el)"
+          @activate="onActivate(tab)"
+          @close="onClose(tab.path)"
+          @close-others="onCloseOthers(tab.path)"
+          @close-right="onCloseRight(tab.path)"
+        />
+      </div>
+    </div>
+  </ClientOnly>
+</template>

package/dist/runtime/components/tabs/index.vue.d.ts

@@ -0,0 +1,9 @@
+type __VLS_Props = {
+    storageKey?: string;
+    home?: string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    home: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/tabs/tab.d.vue.ts

@@ -0,0 +1,22 @@
+import type { TabEdge } from './use-reorder.js';
+type __VLS_Props = {
+    title: string;
+    active: boolean;
+    edge: TabEdge | null;
+    dragging: boolean;
+    closable: boolean;
+    register: (el: HTMLElement | null) => void;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    close: () => any;
+    activate: () => any;
+    closeOthers: () => any;
+    closeRight: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: (() => any) | undefined;
+    onActivate?: (() => any) | undefined;
+    onCloseOthers?: (() => any) | undefined;
+    onCloseRight?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/tabs/tab.vue

@@ -0,0 +1,85 @@
+<script setup>
+import { onBeforeUnmount, onMounted, ref } from "vue";
+import { Icon } from "@iconify/vue";
+import { useI18n } from "vue-i18n";
+import {
+  ContextMenu,
+  ContextMenuContent,
+  ContextMenuItem,
+  ContextMenuTrigger
+} from "../ui/context-menu";
+defineOptions({ name: "ShwfedTab" });
+const props = defineProps({
+  title: { type: String, required: true },
+  active: { type: Boolean, required: true },
+  edge: { type: [String, null], required: true },
+  dragging: { type: Boolean, required: true },
+  closable: { type: Boolean, required: true },
+  register: { type: Function, required: true }
+});
+const emit = defineEmits(["activate", "close", "closeOthers", "closeRight"]);
+const { t } = useI18n({
+  inheritLocale: true,
+  useScope: "global",
+  messages: {
+    zh: { close: "\u5173\u95ED", closeOthers: "\u5173\u95ED\u5176\u4ED6", closeRight: "\u5173\u95ED\u53F3\u4FA7" },
+    en: { close: "Close", closeOthers: "Close others", closeRight: "Close to the right" },
+    ja: { close: "\u9589\u3058\u308B", closeOthers: "\u4ED6\u3092\u9589\u3058\u308B", closeRight: "\u53F3\u5074\u3092\u9589\u3058\u308B" },
+    ko: { close: "\uB2EB\uAE30", closeOthers: "\uB2E4\uB978 \uD0ED \uB2EB\uAE30", closeRight: "\uC624\uB978\uCABD \uD0ED \uB2EB\uAE30" }
+  }
+});
+const root = ref(null);
+onMounted(() => props.register(root.value));
+onBeforeUnmount(() => props.register(null));
+</script>
+
+<template>
+  <ContextMenu>
+    <ContextMenuTrigger
+      as-child
+      :disabled="!closable"
+    >
+      <!-- Fixed width so consecutive closes keep every close button in the same
+           spot (Chrome-style). The close button stays in layout (`opacity-0`, not
+           hidden) and only reveals on hover / focus-within, so nothing reflows. -->
+      <div
+        ref="root"
+        class="group relative flex h-full w-40 shrink-0 cursor-default select-none items-center gap-1.5 border-r border-zinc-200 px-3 text-sm outline-none transition-colors"
+        :class="[
+  active ? 'bg-white text-zinc-900' : 'bg-zinc-50 text-zinc-400 hover:bg-zinc-100 hover:text-zinc-600',
+  dragging ? 'opacity-50' : ''
+]"
+        @click="emit('activate')"
+      >
+        <span class="flex-1 truncate">{{ title }}</span>
+        <button
+          v-if="closable"
+          type="button"
+          class="flex size-4 shrink-0 items-center justify-center rounded-sm text-zinc-400 opacity-0 outline-none transition-opacity group-hover:opacity-100 group-focus-within:opacity-100 hover:bg-zinc-200 hover:text-zinc-700"
+          @click.stop="emit('close')"
+        >
+          <Icon icon="fluent:dismiss-12-regular" />
+        </button>
+        <span
+          v-if="edge"
+          class="absolute inset-y-0 z-10 w-0.5 bg-(--primary)"
+          :class="edge === 'left' ? '-left-px' : '-right-px'"
+        />
+      </div>
+    </ContextMenuTrigger>
+    <ContextMenuContent class="min-w-44">
+      <ContextMenuItem @select="emit('close')">
+        <Icon icon="fluent:dismiss-20-regular" />
+        {{ t("close") }}
+      </ContextMenuItem>
+      <ContextMenuItem @select="emit('closeOthers')">
+        <Icon icon="fluent:dismiss-circle-20-regular" />
+        {{ t("closeOthers") }}
+      </ContextMenuItem>
+      <ContextMenuItem @select="emit('closeRight')">
+        <Icon icon="fluent:panel-right-20-regular" />
+        {{ t("closeRight") }}
+      </ContextMenuItem>
+    </ContextMenuContent>
+  </ContextMenu>
+</template>

package/dist/runtime/components/tabs/tab.vue.d.ts

@@ -0,0 +1,22 @@
+import type { TabEdge } from './use-reorder.js';
+type __VLS_Props = {
+    title: string;
+    active: boolean;
+    edge: TabEdge | null;
+    dragging: boolean;
+    closable: boolean;
+    register: (el: HTMLElement | null) => void;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    close: () => any;
+    activate: () => any;
+    closeOthers: () => any;
+    closeRight: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: (() => any) | undefined;
+    onActivate?: (() => any) | undefined;
+    onCloseOthers?: (() => any) | undefined;
+    onCloseRight?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/tabs/types.d.ts

@@ -0,0 +1,19 @@
+/**
+ * One open tab in the app-level MDI strip.
+ *
+ * Identity is `path` alone — `/orders?status=open` and `/orders?status=closed`
+ * are the SAME `/orders` tab. Dedupe, ordering, persistence, and the context
+ * menu all key off `path`. The query is page state (read by the page via CEL
+ * `location`), never a tab-identity dimension.
+ *
+ * `fullPath` is the last full URL (path + query) the tab was navigated to, so
+ * returning to a tab restores its query view rather than dropping the query.
+ *
+ * `pinned` (no UI yet) marks a tab that bulk-close operations spare and that
+ * `close` refuses to remove — reserved for a future home / pinned-tab feature.
+ */
+export interface Tab {
+    path: string;
+    fullPath: string;
+    pinned?: boolean;
+}

package/dist/runtime/components/tabs/use-reorder.d.ts

@@ -0,0 +1,10 @@
+export type TabEdge = 'left' | 'right';
+export interface UseTabReorderOptions {
+    onReorder: (sourcePath: string, targetPath: string, edge: TabEdge) => void;
+}
+export interface TabReorderApi {
+    setTab: (path: string, el: HTMLElement | null) => void;
+    edgeFor: (path: string) => TabEdge | null;
+    isDragging: (path: string) => boolean;
+}
+export declare function useTabReorder(options: UseTabReorderOptions): TabReorderApi;

package/dist/runtime/components/tabs/use-reorder.js

@@ -0,0 +1,90 @@
+import { onBeforeUnmount, ref } from "vue";
+import { combine } from "@atlaskit/pragmatic-drag-and-drop/combine";
+import {
+  draggable,
+  dropTargetForElements
+} from "@atlaskit/pragmatic-drag-and-drop/element/adapter";
+import {
+  attachClosestEdge,
+  extractClosestEdge
+} from "@atlaskit/pragmatic-drag-and-drop-hitbox/closest-edge";
+const SOURCE_KIND = "shwfed-tab";
+export function useTabReorder(options) {
+  const indicator = ref(null);
+  const dragging = ref(null);
+  const regs = /* @__PURE__ */ new Map();
+  function rewire(path, reg) {
+    reg.cleanup?.();
+    if (!reg.el) {
+      reg.cleanup = null;
+      return;
+    }
+    const el = reg.el;
+    reg.cleanup = combine(
+      draggable({
+        element: el,
+        getInitialData: () => ({ kind: SOURCE_KIND, path }),
+        onDragStart: () => {
+          dragging.value = path;
+        },
+        onDrop: () => {
+          dragging.value = null;
+          if (indicator.value) indicator.value = null;
+        }
+      }),
+      dropTargetForElements({
+        element: el,
+        canDrop: ({ source }) => source.data.kind === SOURCE_KIND && source.data.path !== path,
+        getIsSticky: () => true,
+        getData: ({ input, element }) => attachClosestEdge(
+          { kind: `${SOURCE_KIND}-target`, path },
+          { input, element, allowedEdges: ["left", "right"] }
+        ),
+        onDrag: ({ self }) => {
+          const edge = extractClosestEdge(self.data);
+          if (edge === "left" || edge === "right") indicator.value = { path, edge };
+          else if (indicator.value?.path === path) indicator.value = null;
+        },
+        onDragLeave: () => {
+          if (indicator.value?.path === path) indicator.value = null;
+        },
+        onDrop: ({ source, self }) => {
+          indicator.value = null;
+          const edge = extractClosestEdge(self.data);
+          const sourcePath = typeof source.data.path === "string" ? source.data.path : null;
+          if ((edge === "left" || edge === "right") && sourcePath && sourcePath !== path) {
+            options.onReorder(sourcePath, path, edge);
+          }
+        }
+      })
+    );
+  }
+  function setTab(path, el) {
+    let reg = regs.get(path);
+    if (!reg) {
+      reg = { el: null, cleanup: null };
+      regs.set(path, reg);
+    }
+    if (reg.el === el) return;
+    reg.el = el;
+    rewire(path, reg);
+    if (!reg.el && !reg.cleanup) {
+      regs.delete(path);
+      if (indicator.value?.path === path) indicator.value = null;
+      if (dragging.value === path) dragging.value = null;
+    }
+  }
+  function edgeFor(path) {
+    return indicator.value?.path === path ? indicator.value.edge : null;
+  }
+  function isDragging(path) {
+    return dragging.value === path;
+  }
+  onBeforeUnmount(() => {
+    for (const reg of regs.values()) reg.cleanup?.();
+    regs.clear();
+    indicator.value = null;
+    dragging.value = null;
+  });
+  return { setTab, edgeFor, isDragging };
+}

package/dist/runtime/components/tabs/use-tabs.d.ts

@@ -0,0 +1,46 @@
+import { type Ref } from 'vue';
+import { type ReorderInstruction } from '../../share/reorder.js';
+import type { Tab } from './types.js';
+/**
+ * The app-level tab store — a client singleton (per the module's "runtime
+ * singletons, not Nuxt injections" direction). Holds the open tabs (persisted to
+ * `sessionStorage` so they survive a refresh but die with the browser tab) and
+ * the resolved title logic.
+ *
+ * Deliberately framework-free: it never touches the router. Mutations that imply
+ * a navigation RETURN the `fullPath` the caller should navigate to (or `null`
+ * when no navigation is needed); the `ShwfedTabs` strip performs the actual
+ * `navigateTo`. This keeps the store trivially unit-testable and lets other
+ * call sites (the page `close` operation) reuse it without a router in scope.
+ */
+export interface TabStore {
+    tabs: Ref<Tab[]>;
+    activePath: Ref<string | null>;
+    /** Ensure a tab for `path` exists and mark it active (route-change driven). */
+    openOrFocus: (path: string, fullPath: string) => void;
+    /** Remove a tab; returns the fullPath to navigate to when the active tab was closed. */
+    close: (path: string, home?: string) => string | null;
+    /** Keep only `path` (and pinned tabs); returns a nav target if the active tab was closed. */
+    closeOthers: (path: string) => string | null;
+    /** Close non-pinned tabs to the right of `path`; returns a nav target if active was closed. */
+    closeToRight: (path: string) => string | null;
+    reorder: (sourcePath: string, targetPath: string, instruction: ReorderInstruction) => void;
+    /**
+     * Title precedence: page title (by path) → nav label (query-specific by
+     * fullPath, else by path) → raw path. Takes the tab so the title can reflect
+     * the current query variant while identity stays path-only.
+     */
+    resolveTitle: (tab: {
+        path: string;
+        fullPath: string;
+    }, locale: string) => string;
+    hasTab: (path: string) => boolean;
+}
+export declare function createTabStore(storageKey: string): TabStore;
+/**
+ * Access the shared tab store. Created once, in a detached effect scope so its
+ * `sessionStorage` reactivity is not disposed when the first component that
+ * touched it unmounts. `storageKey` only takes effect on first creation (there
+ * is one strip per app).
+ */
+export declare function useTabStore(storageKey?: string): TabStore;