@shwfed/config 2.12.4 → 2.12.6

package/dist/runtime/components/table/utils/customization.js

@@ -0,0 +1,315 @@
+import { ref } from "vue";
+const STORAGE_PREFIX = "shwfed.table.customization.";
+function isRecordOf(x, check) {
+  return typeof x === "object" && x !== null && !Array.isArray(x) && Object.values(x).every(check);
+}
+const isBoolean = (v) => typeof v === "boolean";
+const isFiniteNumber = (v) => typeof v === "number" && Number.isFinite(v);
+const isStringArray = (x) => Array.isArray(x) && x.every((v) => typeof v === "string");
+export function parseSnapshot(raw) {
+  if (!raw) return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return void 0;
+  const record = parsed;
+  if (record.v !== 1) return void 0;
+  const snapshot = { v: 1 };
+  if (isRecordOf(record.columnVisibility, isBoolean)) snapshot.columnVisibility = record.columnVisibility;
+  if (isStringArray(record.columnOrder)) snapshot.columnOrder = record.columnOrder;
+  {
+    const pinning = record.columnPinning;
+    if (pinning && isStringArray(pinning.left) && isStringArray(pinning.right)) {
+      snapshot.columnPinning = { left: pinning.left, right: pinning.right };
+    }
+  }
+  if (isRecordOf(record.columnSizing, isFiniteNumber)) snapshot.columnSizing = record.columnSizing;
+  if (isFiniteNumber(record.pageSize)) snapshot.pageSize = record.pageSize;
+  return snapshot;
+}
+function pruneRecord(record, ids) {
+  if (!record) return {};
+  return Object.fromEntries(Object.entries(record).filter(([id]) => ids.has(id)));
+}
+function pruneList(list, ids) {
+  return (list ?? []).filter((id) => ids.has(id));
+}
+export function pruneSnapshot(snapshot, ctx) {
+  const pruned = { v: 1 };
+  if (snapshot.columnVisibility) {
+    pruned.columnVisibility = pruneRecord(snapshot.columnVisibility, ctx.columnIds);
+  }
+  if (snapshot.columnSizing) {
+    pruned.columnSizing = pruneRecord(snapshot.columnSizing, ctx.columnIds);
+  }
+  if (snapshot.columnOrder) {
+    const order = pruneList(snapshot.columnOrder, ctx.columnIds);
+    if (order.length > 0 || snapshot.columnOrder.length === 0) pruned.columnOrder = order;
+  }
+  if (snapshot.columnPinning) {
+    const left = pruneList(snapshot.columnPinning.left, ctx.columnIds);
+    const right = pruneList(snapshot.columnPinning.right, ctx.columnIds);
+    const hadEntries = snapshot.columnPinning.left.length + snapshot.columnPinning.right.length > 0;
+    if (left.length + right.length > 0 || !hadEntries) pruned.columnPinning = { left, right };
+  }
+  if (snapshot.pageSize !== void 0 && ctx.paginationEnabled && Number.isInteger(snapshot.pageSize) && snapshot.pageSize > 0 && ctx.pageSizes.includes(snapshot.pageSize)) {
+    pruned.pageSize = snapshot.pageSize;
+  }
+  return pruned;
+}
+export function mergeCustomization(design, snapshot, ctx, options) {
+  if (!snapshot && !options?.explicit) return { state: design };
+  const pruned = snapshot ? pruneSnapshot(snapshot, ctx) : { v: 1 };
+  const designPinning = design?.columnPinning;
+  const prunedDesignPinning = designPinning ? {
+    left: pruneList(designPinning.left, ctx.columnIds),
+    right: pruneList(designPinning.right, ctx.columnIds)
+  } : void 0;
+  const state = {
+    ...design,
+    columnVisibility: {
+      ...pruneRecord(design?.columnVisibility, ctx.columnIds),
+      ...pruned.columnVisibility
+    },
+    columnSizing: {
+      ...pruneRecord(design?.columnSizing, ctx.columnIds),
+      ...pruned.columnSizing
+    },
+    columnOrder: pruned.columnOrder ?? pruneList(design?.columnOrder, ctx.columnIds),
+    columnPinning: pruned.columnPinning ?? prunedDesignPinning ?? { left: [], right: [] }
+  };
+  return { state, pageSize: pruned.pageSize };
+}
+export function weaveLockedColumns(currentLeafOrder, lockedIds, draftOrder) {
+  const draftQueue = draftOrder.filter((id) => !lockedIds.has(id));
+  const out = [];
+  const used = /* @__PURE__ */ new Set();
+  let next = 0;
+  for (const id of currentLeafOrder) {
+    if (lockedIds.has(id)) {
+      out.push(id);
+      used.add(id);
+      continue;
+    }
+    while (next < draftQueue.length && used.has(draftQueue[next])) next++;
+    if (next < draftQueue.length) {
+      const draftId = draftQueue[next++];
+      out.push(draftId);
+      used.add(draftId);
+    } else if (!used.has(id)) {
+      out.push(id);
+      used.add(id);
+    }
+  }
+  for (; next < draftQueue.length; next++) {
+    const draftId = draftQueue[next];
+    if (!used.has(draftId)) {
+      out.push(draftId);
+      used.add(draftId);
+    }
+  }
+  for (const id of currentLeafOrder) {
+    if (!used.has(id)) {
+      out.push(id);
+      used.add(id);
+    }
+  }
+  return out;
+}
+const ALL_BANDS = ["left", "main", "right", "hidden"];
+const VISIBLE_BANDS = ["left", "main", "right"];
+function cloneBands(b) {
+  return { left: [...b.left], main: [...b.main], right: [...b.right], hidden: [...b.hidden] };
+}
+export function bandOf(bands, id) {
+  return ALL_BANDS.find((band) => bands[band].includes(id));
+}
+export function groupVisibleMembers(bands, groupOf, groupId) {
+  const out = [];
+  for (const band of VISIBLE_BANDS) {
+    for (const id of bands[band]) if (groupOf(id) === groupId) out.push(id);
+  }
+  return out;
+}
+export function groupHiddenMembers(bands, groupOf, groupId) {
+  return bands.hidden.filter((id) => groupOf(id) === groupId);
+}
+function groupRun(bands, groupOf, groupId) {
+  const visible = groupVisibleMembers(bands, groupOf, groupId);
+  return visible.length > 0 ? visible : groupHiddenMembers(bands, groupOf, groupId);
+}
+export function bandOfGroup(bands, groupOf, groupId) {
+  return VISIBLE_BANDS.find((band) => bands[band].some((id) => groupOf(id) === groupId));
+}
+export function groupEdgeMember(bands, groupOf, groupId, edge) {
+  const m = groupVisibleMembers(bands, groupOf, groupId);
+  return edge === "first" ? m[0] : m[m.length - 1];
+}
+export function moveRun(bands, runIds, band, anchor) {
+  if (runIds.length === 0) return cloneBands(bands);
+  const drop = new Set(runIds);
+  const next = {
+    left: bands.left.filter((id) => !drop.has(id)),
+    main: bands.main.filter((id) => !drop.has(id)),
+    right: bands.right.filter((id) => !drop.has(id)),
+    hidden: bands.hidden.filter((id) => !drop.has(id))
+  };
+  const list = next[band];
+  let index = list.length;
+  if (anchor.at !== "append") {
+    const i = list.indexOf(anchor.ref);
+    if (i >= 0) index = anchor.at === "before" ? i : i + 1;
+  }
+  list.splice(index, 0, ...runIds);
+  return next;
+}
+function weldWithin(list, groupOf) {
+  const members = /* @__PURE__ */ new Map();
+  for (const id of list) {
+    const gid = groupOf(id);
+    if (!gid) continue;
+    const run = members.get(gid);
+    if (run) run.push(id);
+    else members.set(gid, [id]);
+  }
+  if (members.size === 0) return [...list];
+  const out = [];
+  const emitted = /* @__PURE__ */ new Set();
+  for (const id of list) {
+    const gid = groupOf(id);
+    if (!gid) {
+      out.push(id);
+      continue;
+    }
+    if (emitted.has(gid)) continue;
+    out.push(...members.get(gid) ?? [id]);
+    emitted.add(gid);
+  }
+  return out;
+}
+export function weldGroups(bands, groupOf) {
+  const next = cloneBands(bands);
+  const homeBand = /* @__PURE__ */ new Map();
+  const members = /* @__PURE__ */ new Map();
+  for (const band of VISIBLE_BANDS) {
+    for (const id of bands[band]) {
+      const gid = groupOf(id);
+      if (!gid) continue;
+      if (!homeBand.has(gid)) homeBand.set(gid, band);
+      const run = members.get(gid);
+      if (run) run.push(id);
+      else members.set(gid, [id]);
+    }
+  }
+  if (homeBand.size > 0) {
+    const emitted = /* @__PURE__ */ new Set();
+    for (const band of VISIBLE_BANDS) {
+      const rebuilt = [];
+      for (const id of bands[band]) {
+        const gid = groupOf(id);
+        if (!gid) {
+          rebuilt.push(id);
+          continue;
+        }
+        if (homeBand.get(gid) !== band || emitted.has(gid)) continue;
+        rebuilt.push(...members.get(gid) ?? [id]);
+        emitted.add(gid);
+      }
+      next[band] = rebuilt;
+    }
+  }
+  next.hidden = weldWithin(bands.hidden, groupOf);
+  return next;
+}
+export function applyRowDrop(bands, groupOf, drop) {
+  const { sourceKind, sourceId, sourceGroupId, targetKind, targetId, before } = drop;
+  const edge = before ? "first" : "last";
+  const place = before ? "before" : "after";
+  if (sourceKind === "group") {
+    const run = groupRun(bands, groupOf, sourceId);
+    if (run.length === 0) return cloneBands(bands);
+    if (targetKind === "group") {
+      if (targetId === sourceId) return cloneBands(bands);
+      const band3 = bandOfGroup(bands, groupOf, targetId);
+      const ref2 = groupEdgeMember(bands, groupOf, targetId, edge);
+      if (!band3 || !ref2) return cloneBands(bands);
+      return moveRun(bands, run, band3, { at: place, ref: ref2 });
+    }
+    const band2 = bandOf(bands, targetId);
+    if (!band2 || band2 === "hidden" || groupOf(targetId)) return cloneBands(bands);
+    return moveRun(bands, run, band2, { at: place, ref: targetId });
+  }
+  if (targetKind === "group") {
+    const band2 = bandOfGroup(bands, groupOf, targetId);
+    const ref2 = groupEdgeMember(bands, groupOf, targetId, edge);
+    if (!band2 || !ref2) return cloneBands(bands);
+    return moveRun(bands, [sourceId], band2, { at: place, ref: ref2 });
+  }
+  if (sourceId === targetId) return cloneBands(bands);
+  const band = bandOf(bands, targetId);
+  if (!band || band === "hidden") return cloneBands(bands);
+  const tgtGid = groupOf(targetId);
+  const sameGroup = Boolean(sourceGroupId) && tgtGid === sourceGroupId;
+  const bothStandalone = !sourceGroupId && !tgtGid;
+  if (sameGroup || bothStandalone) {
+    return moveRun(bands, [sourceId], band, { at: place, ref: targetId });
+  }
+  return cloneBands(bands);
+}
+export function applyZoneDrop(bands, groupOf, drop) {
+  const run = drop.sourceKind === "group" ? groupRun(bands, groupOf, drop.sourceId) : [drop.sourceId];
+  return moveRun(bands, run, drop.band, { at: "append" });
+}
+export function useTableCustomization(tableId) {
+  let current;
+  let everCustomized = false;
+  const revision = ref(0);
+  const enabled = () => Boolean(tableId) && typeof window !== "undefined";
+  const key = () => `${STORAGE_PREFIX}${tableId}`;
+  function load() {
+    if (!enabled()) return;
+    let parsed;
+    try {
+      parsed = parseSnapshot(window.localStorage.getItem(key()));
+    } catch {
+      return;
+    }
+    if (parsed) {
+      current = parsed;
+      everCustomized = true;
+      revision.value++;
+    }
+  }
+  function snapshot() {
+    return current;
+  }
+  function persistPatch(patch) {
+    if (!enabled()) return;
+    current = { ...current ?? { v: 1 }, ...patch, v: 1 };
+    everCustomized = true;
+    try {
+      window.localStorage.setItem(key(), JSON.stringify(current));
+    } catch {
+    }
+  }
+  function clear() {
+    if (!enabled()) return;
+    current = void 0;
+    try {
+      window.localStorage.removeItem(key());
+    } catch {
+    }
+    revision.value++;
+  }
+  return {
+    revision,
+    load,
+    snapshot,
+    persistPatch,
+    clear,
+    wasCustomized: () => everCustomized
+  };
+}

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;