@simon_he/vue-tui 1.0.0 → 1.0.1

package/dist/vue/components/TVirtualRows.d.ts

@@ -77,6 +77,13 @@ export declare const TVirtualRows: import("vue").DefineComponent<import("vue").E
         type: NumberConstructor;
         required: true;
     };
+    itemChangedRange: {
+        type: PropType<() => {
+            start: number;
+            end: number;
+        } | null | undefined>;
+        default: undefined;
+    };
     getItem: {
         type: PropType<(index: number) => unknown>;
         required: true;
@@ -156,6 +163,13 @@ export declare const TVirtualRows: import("vue").DefineComponent<import("vue").E
         type: NumberConstructor;
         required: true;
     };
+    itemChangedRange: {
+        type: PropType<() => {
+            start: number;
+            end: number;
+        } | null | undefined>;
+        default: undefined;
+    };
     getItem: {
         type: PropType<(index: number) => unknown>;
         required: true;
@@ -241,6 +255,10 @@ export declare const TVirtualRows: import("vue").DefineComponent<import("vue").E
     rowScrollMode: TVirtualRowsRowScrollMode;
     scrollTop: number;
     selectionText: (item: unknown, index: number) => string;
+    itemChangedRange: () => {
+        start: number;
+        end: number;
+    } | null | undefined;
     renderItemNodes: (ctx: TVirtualRowsRenderNodesContext) => VNodeChild;
     selectionSpanText: (ctx: TVirtualRowsSelectionSpanTextContext) => string;
     wheelScroll: boolean;

package/dist/vue/transcript/types.d.ts

@@ -56,6 +56,10 @@ export type TTranscriptDataSource = Readonly<{
     getRow(index: number): TTranscriptRow;
     getRowKey?: (index: number) => string | number;
     getRowVersion?: (index: number) => string | number;
+    getChangedRange?: () => {
+        start: number;
+        end: number;
+    } | null | undefined;
     firstRowIndex?: () => number;
 }>;
 export type TTranscriptVisualSegment = Readonly<{

package/dist/vue.cjs

@@ -7457,22 +7457,40 @@ function normalizeVisibleLimit(value) {
 function isCommandPaletteRowSelectable(item) {
   return Boolean(item && item.kind !== "separator" && item.kind !== "group" && !item.disabled);
 }
-function substringMatcher(item, query) {
-  const q = query.trim().toLowerCase();
-  if (!q)
-    return { score: 0 };
-  const labelRanges = computeCommandPaletteMatchRanges(item.label, q);
-  const detailRanges = item.detail ? computeCommandPaletteMatchRanges(item.detail, q) : [];
-  const keywordMatch = (item.keywords ?? []).some(
-    (keyword) => String(keyword ?? "").toLowerCase().includes(q)
-  );
-  if (!labelRanges.length && !detailRanges.length && !keywordMatch)
-    return null;
-  return {
-    score: labelRanges.length ? 100 : detailRanges.length ? 50 : 10,
-    labelRanges,
-    detailRanges
-  };
+function defaultSubstringEntries(sourceItems, query) {
+  const q = query.trim();
+  if (!q) {
+    return sourceItems.map((item, sourceIndex) => ({
+      item,
+      sourceIndex,
+      match: { score: 0 }
+    }));
+  }
+  const needle = q.toLowerCase();
+  const labelMatches = [];
+  const detailMatches = [];
+  const keywordMatches = [];
+  for (let sourceIndex = 0; sourceIndex < sourceItems.length; sourceIndex++) {
+    const item = sourceItems[sourceIndex];
+    if (item.kind === "separator" || item.kind === "group")
+      continue;
+    const label = String(item.label ?? "");
+    const detail = item.detail == null ? "" : String(item.detail);
+    if (label.toLowerCase().includes(needle)) {
+      labelMatches.push({ item, sourceIndex, match: { score: 100 } });
+      continue;
+    }
+    if (detail.toLowerCase().includes(needle)) {
+      detailMatches.push({ item, sourceIndex, match: { score: 50 } });
+      continue;
+    }
+    if ((item.keywords ?? []).some(
+      (keyword) => String(keyword ?? "").toLowerCase().includes(needle)
+    )) {
+      keywordMatches.push({ item, sourceIndex, match: { score: 10 } });
+    }
+  }
+  return labelMatches.concat(detailMatches, keywordMatches);
 }
 function fuzzyMatcher(item, query) {
   const q = query.trim().toLowerCase();
@@ -7640,14 +7658,22 @@ var TCommandPalette = (0, import_vue15.defineComponent)({
     const filteredEntries = (0, import_vue15.computed)(() => {
       const q = query.value.trim();
       const sourceItems = props.itemsProvider ? providerItems.value ?? [] : props.items;
-      const matcher = props.matcher ?? (props.filterStrategy === "fuzzy" ? fuzzyMatcher : substringMatcher);
-      const entries = sourceItems.flatMap((item, sourceIndex) => {
+      if (!props.matcher && props.filterStrategy === "substring") {
+        return defaultSubstringEntries(sourceItems, q);
+      }
+      const matcher = props.matcher ?? fuzzyMatcher;
+      const entries = [];
+      for (let sourceIndex = 0; sourceIndex < sourceItems.length; sourceIndex++) {
+        const item = sourceItems[sourceIndex];
         if (item.kind === "separator" || item.kind === "group") {
-          return q ? [] : [{ item, sourceIndex, match: { score: 0 } }];
+          if (!q)
+            entries.push({ item, sourceIndex, match: { score: 0 } });
+          continue;
         }
         const match = matcher(item, q);
-        return match ? [{ item, sourceIndex, match }] : [];
-      });
+        if (match)
+          entries.push({ item, sourceIndex, match });
+      }
       entries.sort((a, b) => b.match.score - a.match.score || a.sourceIndex - b.sourceIndex);
       return entries;
     });
@@ -8371,6 +8397,20 @@ function rowKey(row, index, key) {
 function sameRowKey(a, b) {
   return Object.is(a, b);
 }
+function selectedRowKeyIndex(keys) {
+  if (!keys?.length)
+    return null;
+  const indexed = /* @__PURE__ */ new Set();
+  for (let index = 0; index < keys.length; index++) {
+    if (!(index in keys))
+      continue;
+    const key = keys[index];
+    if (typeof key === "number" && key === 0)
+      return null;
+    indexed.add(key);
+  }
+  return indexed;
+}
 var TTable = (0, import_vue16.defineComponent)({
   name: "TTable",
   props: {
@@ -8443,10 +8483,22 @@ var TTable = (0, import_vue16.defineComponent)({
     const activeRowStyle = (0, import_vue16.computed)(
       () => mergeStyle(theme.value.components.TTable?.activeStyle, props.activeStyle)
     );
+    const selectedRowKeysIndex = (0, import_vue16.computed)(() => selectedRowKeyIndex(props.selectedRowKeys));
     const bodyRows = (0, import_vue16.computed)(() => {
       const top = props.header ? 2 : 0;
       return props.rows.slice(0, Math.max(0, props.h - top));
     });
+    function isRowSelected(key) {
+      if (props.selectedRowKey !== void 0 && sameRowKey(key, props.selectedRowKey))
+        return true;
+      const selectedKeys = props.selectedRowKeys;
+      if (!selectedKeys?.length)
+        return false;
+      const indexed = selectedRowKeysIndex.value;
+      if (indexed)
+        return indexed.has(key);
+      return selectedKeys.some((candidate) => sameRowKey(candidate, key));
+    }
     return () => {
       const children = [];
       if (props.header && props.h > 0) {
@@ -8524,7 +8576,7 @@ var TTable = (0, import_vue16.defineComponent)({
         const row = bodyRows.value[index];
         const y = (props.header ? 2 : 0) + index;
         const key = rowKey(row, index, props.rowKey);
-        const selected = props.selectedRowKey !== void 0 && sameRowKey(key, props.selectedRowKey) || Boolean(props.selectedRowKeys?.some((candidate) => sameRowKey(candidate, key)));
+        const selected = isRowSelected(key);
         const active = props.activeRowKey !== void 0 && sameRowKey(key, props.activeRowKey);
         children.push(
           (0, import_vue16.h)(
@@ -8693,44 +8745,59 @@ var TDataTable = (0, import_vue17.defineComponent)({
   },
   setup(props, { emit }) {
     const innerScrollTop = (0, import_vue17.ref)(0);
-    const indexedRows = (0, import_vue17.computed)(
-      () => props.rows.map((row, originalIndex) => ({ row, originalIndex }))
+    const hasLocalFilter = (0, import_vue17.computed)(
+      () => !props.manualFilter && props.filterable && Boolean(props.filter.trim())
+    );
+    const hasLocalSort = (0, import_vue17.computed)(
+      () => !props.manualSort && props.sortable && Boolean(props.sortBy)
     );
+    const indexedRows = (0, import_vue17.computed)(() => {
+      if (!hasLocalFilter.value && !hasLocalSort.value)
+        return null;
+      return props.rows.map((row, originalIndex) => ({ row, originalIndex }));
+    });
     const filteredRows = (0, import_vue17.computed)(() => {
-      if (props.manualFilter)
-        return indexedRows.value;
-      if (!props.filterable || !props.filter.trim())
-        return indexedRows.value;
+      const rows = indexedRows.value;
+      if (!rows)
+        return null;
+      if (!hasLocalFilter.value)
+        return rows;
       const query = props.filter.trim().toLowerCase();
       if (props.filterPredicate) {
-        return indexedRows.value.filter(
+        return rows.filter(
           ({ row, originalIndex }) => props.filterPredicate(row, query, props.columns, originalIndex)
         );
       }
-      return indexedRows.value.filter(
+      return rows.filter(
         ({ row, originalIndex }) => props.columns.some(
           (column) => displayValue(column, row, originalIndex).toLowerCase().includes(query)
         )
       );
     });
     const sortedRows = (0, import_vue17.computed)(() => {
-      const rows = [...filteredRows.value];
-      if (props.manualSort || !props.sortable || !props.sortBy)
+      const rows = filteredRows.value;
+      if (!rows)
+        return null;
+      if (!hasLocalSort.value)
         return rows;
+      const sorted = [...rows];
       const column = props.columns.find((candidate) => candidate.key === props.sortBy);
-      rows.sort((a, b) => {
+      sorted.sort((a, b) => {
         const result = props.sorter && column ? props.sorter(a.row, b.row, column) : compareValues(a.row[props.sortBy], b.row[props.sortBy]);
         return props.sortDirection === "desc" ? -result : result;
       });
-      return rows;
+      return sorted;
     });
     function nonNegativeInteger(value) {
       const n = Math.floor(Number(value));
       return Number.isFinite(n) ? Math.max(0, n) : 0;
     }
     const visibleRowCapacity = (0, import_vue17.computed)(() => Math.max(0, nonNegativeInteger(props.h) - 2));
+    function processedRowCount() {
+      return sortedRows.value?.length ?? props.rows.length;
+    }
     function maxScrollTop2() {
-      return Math.max(0, sortedRows.value.length - visibleRowCapacity.value);
+      return Math.max(0, processedRowCount() - visibleRowCapacity.value);
     }
     function clampScrollTop2(value) {
       return Math.min(maxScrollTop2(), nonNegativeInteger(value));
@@ -8754,12 +8821,27 @@ var TDataTable = (0, import_vue17.defineComponent)({
       },
       { immediate: true }
     );
-    const visibleRows = (0, import_vue17.computed)(
-      () => sortedRows.value.slice(
-        normalizedScrollTop.value,
-        normalizedScrollTop.value + visibleRowCapacity.value
-      )
-    );
+    function dataEntryAt(absoluteIndex) {
+      const rows = sortedRows.value;
+      if (rows)
+        return rows[absoluteIndex];
+      const row = props.rows[absoluteIndex];
+      return row ? { row, originalIndex: absoluteIndex } : void 0;
+    }
+    function originalIndexForAbsoluteIndex(absoluteIndex) {
+      return dataEntryAt(absoluteIndex)?.originalIndex ?? absoluteIndex;
+    }
+    const visibleRows = (0, import_vue17.computed)(() => {
+      const top = normalizedScrollTop.value;
+      const bottom = top + visibleRowCapacity.value;
+      const rows = sortedRows.value;
+      if (rows)
+        return rows.slice(top, bottom);
+      return props.rows.slice(top, bottom).map((row, index) => ({
+        row,
+        originalIndex: top + index
+      }));
+    });
     const tableRows = (0, import_vue17.computed)(() => visibleRows.value.map(({ row }) => row));
     const activeAbsoluteIndex = (0, import_vue17.ref)(null);
     const activeRowIdentity = (0, import_vue17.ref)(NO_ACTIVE_ROW);
@@ -8768,7 +8850,7 @@ var TDataTable = (0, import_vue17.defineComponent)({
       () => props.columns.map((column) => {
         const format = column.format ? (value, row, visibleIndex) => {
           const absoluteIndex = normalizedScrollTop.value + visibleIndex;
-          const originalIndex = sortedRows.value[absoluteIndex]?.originalIndex ?? absoluteIndex;
+          const originalIndex = originalIndexForAbsoluteIndex(absoluteIndex);
           return column.format(value, row, originalIndex);
         } : void 0;
         if (!props.sortable || column.key !== props.sortBy) {
@@ -8780,7 +8862,7 @@ var TDataTable = (0, import_vue17.defineComponent)({
     );
     function originalIndexAt(index) {
       const absoluteIndex = normalizedScrollTop.value + index;
-      return sortedRows.value[absoluteIndex]?.originalIndex ?? absoluteIndex;
+      return originalIndexForAbsoluteIndex(absoluteIndex);
     }
     function dataTableRowKey(row, index) {
       return rowKey2(row, originalIndexAt(index), props.rowKey);
@@ -8801,14 +8883,28 @@ var TDataTable = (0, import_vue17.defineComponent)({
     const activeRowKey = (0, import_vue17.computed)(
       () => activeRowIdentity.value === NO_ACTIVE_ROW ? void 0 : activeRowIdentity.value
     );
+    const activeRawRowKey = (0, import_vue17.computed)(() => {
+      if (activeAbsoluteIndex.value == null || sortedRows.value)
+        return NO_ACTIVE_ROW;
+      const index = activeAbsoluteIndex.value;
+      const row = props.rows[index];
+      return row ? rowKey2(row, index, props.rowKey) : NO_ACTIVE_ROW;
+    });
+    function findDataIndexByKey(key) {
+      const rows = sortedRows.value;
+      if (rows) {
+        return rows.findIndex((entry) => Object.is(dataRowKey(entry), key));
+      }
+      return props.rows.findIndex(
+        (row, index) => Object.is(rowKey2(row, index, props.rowKey), key)
+      );
+    }
     (0, import_vue17.watch)(
-      () => [props.rowKey, ...sortedRows.value.map((entry) => dataRowKey(entry))],
+      () => [props.rowKey, props.rows, sortedRows.value, activeRowIdentity.value],
       () => {
         if (activeRowIdentity.value === NO_ACTIVE_ROW)
           return;
-        const nextIndex = sortedRows.value.findIndex(
-          (entry) => Object.is(dataRowKey(entry), activeRowIdentity.value)
-        );
+        const nextIndex = findDataIndexByKey(activeRowIdentity.value);
         if (nextIndex < 0) {
           clearActiveRow();
           return;
@@ -8816,9 +8912,22 @@ var TDataTable = (0, import_vue17.defineComponent)({
         activeAbsoluteIndex.value = nextIndex;
       }
     );
+    (0, import_vue17.watch)(
+      () => [props.rowKey, activeRawRowKey.value],
+      ([, key]) => {
+        if (activeRowIdentity.value === NO_ACTIVE_ROW)
+          return;
+        if (key === NO_ACTIVE_ROW) {
+          clearActiveRow();
+          return;
+        }
+        if (!Object.is(activeRowIdentity.value, key))
+          activeRowIdentity.value = key;
+      }
+    );
     function setActiveAbsoluteIndex(absoluteIndex) {
-      const clamped = Math.max(0, Math.min(sortedRows.value.length - 1, absoluteIndex));
-      const entry = sortedRows.value[clamped];
+      const clamped = Math.max(0, Math.min(processedRowCount() - 1, absoluteIndex));
+      const entry = dataEntryAt(clamped);
       if (!entry) {
         clearActiveRow();
         return null;
@@ -8894,7 +9003,7 @@ var TDataTable = (0, import_vue17.defineComponent)({
         const active = setActiveAbsoluteIndex(current);
         if (!active)
           return;
-        const entry = sortedRows.value[active.dataIndex];
+        const entry = dataEntryAt(active.dataIndex);
         if (!entry)
           return;
         const visibleIndex = active.dataIndex - active.scrollTop;
@@ -22493,6 +22602,49 @@ var TSelect = (0, import_vue41.defineComponent)({
     const typeaheadQuery = (0, import_vue41.ref)("");
     const query = (0, import_vue41.computed)(() => props.query ?? innerQuery.value);
     const options = (0, import_vue41.computed)(() => providerOptions.value ?? props.options);
+    function getOptionLabel(opt) {
+      return isOptionObject(opt) ? opt.label : opt;
+    }
+    function getOptionKind(opt) {
+      return isOptionObject(opt) ? opt.kind : void 0;
+    }
+    function getOptionValue(opt, index) {
+      if (props.valueMode === "index")
+        return index;
+      if (props.valueMode === "option")
+        return opt;
+      return isOptionObject(opt) && "value" in opt ? opt.value : getOptionLabel(opt);
+    }
+    const optionValueIndex = (0, import_vue41.computed)(() => {
+      if (props.valueMode === "index")
+        return null;
+      const indexed = /* @__PURE__ */ new Map();
+      const opts = options.value;
+      for (let index = 0; index < opts.length; index++) {
+        const value = getOptionValue(opts[index], index);
+        if (typeof value === "number" && value === 0)
+          continue;
+        if (!indexed.has(value))
+          indexed.set(value, index);
+      }
+      return indexed;
+    });
+    function valuesEqual(a, b) {
+      return Object.is(a, b);
+    }
+    function modelIndex(value, useValueIndex = props.multiple) {
+      if (props.valueMode === "index")
+        return normalizeModelIndex(value);
+      if (useValueIndex) {
+        const indexed = optionValueIndex.value;
+        const cached = indexed?.get(value);
+        if (cached != null)
+          return cached;
+      }
+      return options.value.findIndex(
+        (opt, optIndex) => valuesEqual(getOptionValue(opt, optIndex), value)
+      );
+    }
     const initialActive = (() => {
       const max = Math.max(0, options.value.length - 1);
       if (!props.multiple) {
@@ -22550,29 +22702,6 @@ var TSelect = (0, import_vue41.defineComponent)({
       }
       innerActive.value = clamp11(active.value, 0, max);
     });
-    function getOptionLabel(opt) {
-      return isOptionObject(opt) ? opt.label : opt;
-    }
-    function getOptionKind(opt) {
-      return isOptionObject(opt) ? opt.kind : void 0;
-    }
-    function getOptionValue(opt, index) {
-      if (props.valueMode === "index")
-        return index;
-      if (props.valueMode === "option")
-        return opt;
-      return isOptionObject(opt) && "value" in opt ? opt.value : getOptionLabel(opt);
-    }
-    function valuesEqual(a, b) {
-      return Object.is(a, b);
-    }
-    function modelIndex(value) {
-      if (props.valueMode === "index")
-        return normalizeModelIndex(value);
-      return options.value.findIndex(
-        (opt, optIndex) => valuesEqual(getOptionValue(opt, optIndex), value)
-      );
-    }
     function isOptionInteractive(opt) {
       if (!opt)
         return false;
@@ -23356,16 +23485,24 @@ var TTransition = (0, import_vue42.defineComponent)({
 
 // src/vue/components/TTree.ts
 var import_vue43 = require("vue");
-function flattenTree(nodes, expanded, depth = 0, out = []) {
+function flattenTree(nodes, expanded, limit, depth = 0, out = []) {
+  if (out.length >= limit)
+    return out;
   for (const node of nodes) {
+    if (out.length >= limit)
+      break;
     const expandable = Boolean(node.children?.length);
     const isExpanded = expanded.has(node.id);
     out.push({ node, depth, expandable, expanded: isExpanded });
     if (expandable && isExpanded)
-      flattenTree(node.children, expanded, depth + 1, out);
+      flattenTree(node.children, expanded, limit, depth + 1, out);
   }
   return out;
 }
+function visibleRowLimit(height) {
+  const limit = Math.floor(height);
+  return Number.isFinite(limit) ? Math.max(0, limit) : 0;
+}
 var TTree = (0, import_vue43.defineComponent)({
   name: "TTree",
   props: {
@@ -23399,7 +23536,9 @@ var TTree = (0, import_vue43.defineComponent)({
     const { defaultStyle } = useTerminal();
     const baseStyle = (0, import_vue43.computed)(() => mergeStyle(defaultStyle.value, props.style));
     const expandedSet = (0, import_vue43.computed)(() => new Set(props.expandedIds));
-    const rows = (0, import_vue43.computed)(() => flattenTree(props.nodes, expandedSet.value).slice(0, props.h));
+    const rows = (0, import_vue43.computed)(
+      () => flattenTree(props.nodes, expandedSet.value, visibleRowLimit(props.h))
+    );
     function toggle(item) {
       if (item.node.disabled || !item.expandable)
         return;

package/dist/vue.js

@@ -8,9 +8,9 @@ import { TView, createTheme, linkifyTextSegments, tuiDefaultTheme } from "./link
 import "./runtime-rfcZCyJq.js";
 import "./trace-CjzYeIxN.js";
 import "./env-Cl8qmNFN.js";
-import { TAutocompleteInput, TBadge, TCheckbox, TCode, TDataTable, TDivider, TForm, TFormContextKey, TFormField, TLink, TLinkifyText, TList, TPasswordInput, TProgress, TRadioGroup, TSlider, TSpinner, TSwitch, TTable, TTag, TToastViewport, TTree, TerminalProvider, createTInputHostPlugin, useTForm } from "./TTree-DK_DQBYm.js";
+import { TAutocompleteInput, TBadge, TCheckbox, TCode, TDataTable, TDivider, TForm, TFormContextKey, TFormField, TLink, TLinkifyText, TList, TPasswordInput, TProgress, TRadioGroup, TSlider, TSpinner, TSwitch, TTable, TTag, TToastViewport, TTree, TerminalProvider, createTInputHostPlugin, useTForm } from "./TTree-ChOot2Bh.js";
 import "./terminal-selection-DBinO6p5.js";
-import { TBox, TCommandPalette, TDialog, TInput, TRenderPlane, TSelect, TText, clamp as clamp$1, clamp$1 as clamp, computeCommandPaletteMatchRanges, createOverlayFocusStack, fitCellText, isCommitMention, isWhitespace, mentionChipStyle, mergeStyle, padEndByCells as padEndByCells$1, resolveOverlayPlacement, sliceByCellsWindow, textCellWidth as textCellWidth$1 } from "./TSelect-BwJJbuTt.js";
+import { TBox, TCommandPalette, TDialog, TInput, TRenderPlane, TSelect, TText, clamp as clamp$1, clamp$1 as clamp, computeCommandPaletteMatchRanges, createOverlayFocusStack, fitCellText, isCommitMention, isWhitespace, mentionChipStyle, mergeStyle, padEndByCells as padEndByCells$1, resolveOverlayPlacement, sliceByCellsWindow, textCellWidth as textCellWidth$1 } from "./TSelect-HzILuti9.js";
 import "./frame-perf-C6Xfg85O.js";
 import { normalizePath, stripTrailingSlash } from "./path-mnSgEpCm.js";
 import { parsePathQuery, resolveUserPath, suggestPaths } from "./path-suggest-BNqcuE3-.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simon_he/vue-tui",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Vue 3 terminal UI toolkit for browser DOM and CLI stdout renderers",
   "keywords": [
     "ansi",
@@ -180,23 +180,23 @@
     "@arethetypeswrong/core": "^0.18.2",
     "@playwright/test": "^1.60.0",
     "@types/node": "^18.19.130",
-    "@vitest/coverage-v8": "^4.1.6",
+    "@vitest/coverage-v8": "^4.1.7",
     "bumpp": "^8.2.1",
     "esbuild": "^0.20.2",
     "happy-dom": "^17.6.3",
     "lint-staged": "^13.3.0",
     "oxfmt": "^0.47.0",
-    "oxlint": "^1.65.0",
+    "oxlint": "^1.67.0",
     "picocolors": "^1.1.1",
     "pinia": "^3.0.4",
     "publint": "^0.3.21",
     "rimraf": "^3.0.2",
     "tsdown": "^0.9.9",
-    "tsx": "^4.22.0",
+    "tsx": "^4.22.3",
     "typescript": "^5.9.3",
     "vite": "6.4.1",
     "vitepress": "^1.6.4",
-    "vitest": "^4.1.6",
+    "vitest": "^4.1.7",
     "vue": "^3.5.34"
   },
   "peerDependencies": {
@@ -247,6 +247,7 @@
     "release": "pnpm run release:workflow-only",
     "release:verify": "pnpm run release:dry-run",
     "release:ci": "pnpm run release:verify",
+    "publish:npm:patch": "pnpm exec bumpp patch --yes --no-commit --no-tag --no-push && (npm whoami >/dev/null 2>&1 || npm login) && VUE_TUI_ALLOW_DIRECT_PUBLISH=1 pnpm publish --access public --no-git-checks",
     "release:local": "pnpm run release:dry-run && VUE_TUI_ALLOW_DIRECT_PUBLISH=1 npm publish .release/*.tgz --access public --tag rc",
     "release:local:dry-run": "pnpm run release:dry-run && VUE_TUI_ALLOW_DIRECT_PUBLISH=1 npm publish .release/*.tgz --access public --dry-run --tag rc",
     "release:bench": "pnpm run bench:baseline",