@workbench-kit/react 0.0.2-prototype.0.1.4 → 0.0.2-prototype.0.2.10

package/src/workbench/commands/command-model.ts

@@ -0,0 +1,279 @@
+import type { CommandMenuItem, ResolvedCommandMenuCommandItem } from '@workbench-kit/platform';
+
+import {
+  getWorkbenchStatusLabel,
+  isWorkbenchStatusDisabled,
+  type WorkbenchStatus,
+} from '../shell/status';
+
+export type WorkbenchCommandStatus = WorkbenchStatus;
+
+export interface WorkbenchCommandExecution {
+  kind: 'agent' | 'local' | 'remote' | 'composite' | (string & {});
+  label?: string | undefined;
+}
+
+export type WorkbenchCommandFeedback = 'none' | 'status' | 'timeline';
+export type WorkbenchCommandOutput = 'none' | 'message' | 'event' | 'artifact';
+export type WorkbenchCommandSideEffect = 'none' | 'workspace-write' | 'external-write';
+export type WorkbenchCommandExecutionPolicy = 'auto-allow' | 'approval-required' | 'auto-deny';
+export type WorkbenchCommandRunSource = 'grouped-list' | 'list' | 'palette' | 'suggest';
+export type WorkbenchCommandGroupBy =
+  'category' | 'danger' | 'execution' | 'feedback' | 'keyword' | 'output' | 'sideEffect' | 'status';
+
+export interface WorkbenchCommandDescriptor {
+  category?: string | undefined;
+  danger?: boolean | undefined;
+  description?: string | undefined;
+  disabled?: boolean | undefined;
+  disabledReason?: string | undefined;
+  execution?: WorkbenchCommandExecution | undefined;
+  executionPolicy?: WorkbenchCommandExecutionPolicy | undefined;
+  feedback?: WorkbenchCommandFeedback | undefined;
+  icon?: string | undefined;
+  id: string;
+  keywords?: readonly string[] | undefined;
+  label: string;
+  metadata?: Record<string, unknown> | undefined;
+  output?: WorkbenchCommandOutput | undefined;
+  shortcut?: string | undefined;
+  sideEffect?: WorkbenchCommandSideEffect | undefined;
+  status?: WorkbenchCommandStatus | undefined;
+}
+
+export interface WorkbenchCommandRunContext {
+  groupId?: string | undefined;
+  groupLabel?: string | undefined;
+  index: number;
+  query: string;
+  source: WorkbenchCommandRunSource;
+}
+
+export interface WorkbenchCommandFilterInput {
+  commands: readonly WorkbenchCommandDescriptor[];
+  limit?: number | undefined;
+  query?: string | undefined;
+}
+
+export interface WorkbenchCommandNavigationInput {
+  commands: readonly WorkbenchCommandDescriptor[];
+  currentIndex: number;
+  direction: 'next' | 'previous';
+}
+
+export interface WorkbenchCommandGroup {
+  commands: readonly WorkbenchCommandDescriptor[];
+  id: string;
+  label: string;
+}
+
+export interface WorkbenchCommandGroupingInput {
+  commands: readonly WorkbenchCommandDescriptor[];
+  fallbackGroupLabel?: string | undefined;
+  groupBy?: WorkbenchCommandGroupBy | undefined;
+}
+
+export type WorkbenchCommandDescriptorOverrides = Partial<
+  Omit<WorkbenchCommandDescriptor, 'danger' | 'disabled' | 'icon' | 'id' | 'label' | 'shortcut'>
+>;
+
+const commandExecutionLabels: Record<string, string> = {
+  agent: 'Agent',
+  composite: 'Composite',
+  local: 'Local',
+  remote: 'Remote',
+};
+
+const commandFeedbackLabels: Record<WorkbenchCommandFeedback, string> = {
+  none: 'No feedback',
+  status: 'Status',
+  timeline: 'Timeline',
+};
+
+const commandOutputLabels: Record<WorkbenchCommandOutput, string> = {
+  artifact: 'Artifact',
+  event: 'Event',
+  message: 'Message',
+  none: 'No output',
+};
+
+const commandSideEffectLabels: Record<WorkbenchCommandSideEffect, string> = {
+  'external-write': 'External write',
+  none: 'No side effect',
+  'workspace-write': 'Workspace write',
+};
+
+function normalizedSearchText(value: string) {
+  return value.trim().toLocaleLowerCase();
+}
+
+function commandSearchText(command: WorkbenchCommandDescriptor) {
+  return normalizedSearchText(
+    [
+      command.id,
+      command.label,
+      command.description,
+      command.category,
+      command.shortcut,
+      ...(command.keywords ?? []),
+    ]
+      .filter(Boolean)
+      .join(' '),
+  );
+}
+
+export function normalizeWorkbenchCommandQuery(query = '') {
+  const trimmed = query.trimStart();
+
+  return trimmed.startsWith('>') ? trimmed.slice(1).trimStart() : query;
+}
+
+export function getWorkbenchCommandStatusLabel(status: WorkbenchCommandStatus) {
+  return getWorkbenchStatusLabel(status);
+}
+
+export function getWorkbenchCommandExecutionLabel(execution: WorkbenchCommandExecution) {
+  return execution.label ?? commandExecutionLabels[execution.kind] ?? execution.kind;
+}
+
+export function isWorkbenchCommandRunnable(command: WorkbenchCommandDescriptor) {
+  return !(command.disabled || (command.status && isWorkbenchStatusDisabled(command.status)));
+}
+
+function normalizeWorkbenchCommandGroupId(label: string) {
+  const normalized = normalizedSearchText(label)
+    .replace(/[^\p{L}\p{N}]+/gu, '-')
+    .replace(/^-+|-+$/g, '');
+
+  return normalized || 'group';
+}
+
+function getWorkbenchCommandGroupLabels({
+  command,
+  fallbackGroupLabel,
+  groupBy = 'category',
+}: {
+  command: WorkbenchCommandDescriptor;
+  fallbackGroupLabel: string;
+  groupBy?: WorkbenchCommandGroupBy | undefined;
+}) {
+  if (groupBy === 'keyword') {
+    return command.keywords?.length ? [...command.keywords] : [fallbackGroupLabel];
+  }
+
+  if (groupBy === 'category') return [command.category ?? fallbackGroupLabel];
+  if (groupBy === 'danger') return [command.danger ? 'Danger' : 'Default'];
+  if (groupBy === 'execution') {
+    return [
+      command.execution ? getWorkbenchCommandExecutionLabel(command.execution) : fallbackGroupLabel,
+    ];
+  }
+  if (groupBy === 'feedback')
+    return [command.feedback ? commandFeedbackLabels[command.feedback] : fallbackGroupLabel];
+  if (groupBy === 'output')
+    return [command.output ? commandOutputLabels[command.output] : fallbackGroupLabel];
+  if (groupBy === 'sideEffect') {
+    return [command.sideEffect ? commandSideEffectLabels[command.sideEffect] : fallbackGroupLabel];
+  }
+
+  const status = command.status ?? (command.disabled ? 'disabled' : undefined);
+  return [status ? getWorkbenchCommandStatusLabel(status) : fallbackGroupLabel];
+}
+
+export function groupWorkbenchCommands({
+  commands,
+  fallbackGroupLabel = 'Other',
+  groupBy = 'category',
+}: WorkbenchCommandGroupingInput): WorkbenchCommandGroup[] {
+  const groups = new Map<string, { commands: WorkbenchCommandDescriptor[]; label: string }>();
+
+  commands.forEach((command) => {
+    getWorkbenchCommandGroupLabels({ command, fallbackGroupLabel, groupBy }).forEach((label) => {
+      const id = normalizeWorkbenchCommandGroupId(`${groupBy}-${label}`);
+      const group = groups.get(id) ?? { commands: [], label };
+
+      group.commands.push(command);
+      groups.set(id, group);
+    });
+  });
+
+  return Array.from(groups, ([id, group]) => ({
+    commands: group.commands,
+    id,
+    label: group.label,
+  }));
+}
+
+export function filterWorkbenchCommands({
+  commands,
+  limit,
+  query = '',
+}: WorkbenchCommandFilterInput) {
+  const tokens = normalizedSearchText(normalizeWorkbenchCommandQuery(query))
+    .split(/\s+/)
+    .filter(Boolean);
+  const filtered = tokens.length
+    ? commands.filter((command) => {
+        const searchText = commandSearchText(command);
+        return tokens.every((token) => searchText.includes(token));
+      })
+    : [...commands];
+
+  return typeof limit === 'number' ? filtered.slice(0, limit) : filtered;
+}
+
+export function getNextWorkbenchCommandIndex({
+  commands,
+  currentIndex,
+  direction,
+}: WorkbenchCommandNavigationInput) {
+  if (commands.length === 0) return -1;
+
+  const step = direction === 'next' ? 1 : -1;
+  const startIndex =
+    currentIndex >= 0 && currentIndex < commands.length
+      ? currentIndex
+      : direction === 'next'
+        ? -1
+        : 0;
+
+  for (let offset = 1; offset <= commands.length; offset += 1) {
+    const nextIndex = (startIndex + step * offset + commands.length) % commands.length;
+    const command = commands[nextIndex];
+    if (command && isWorkbenchCommandRunnable(command)) return nextIndex;
+  }
+
+  return -1;
+}
+
+export function commandMenuItemToWorkbenchCommandDescriptor(
+  item: ResolvedCommandMenuCommandItem,
+  overrides: WorkbenchCommandDescriptorOverrides = {},
+): WorkbenchCommandDescriptor {
+  const metadata = {
+    menuItemId: item.id,
+    ...overrides.metadata,
+  };
+
+  return {
+    ...overrides,
+    danger: item.danger,
+    disabled: item.disabled,
+    icon: item.icon,
+    id: item.commandId,
+    label: item.label,
+    metadata,
+    shortcut: item.shortcut,
+  };
+}
+
+export function commandMenuItemsToWorkbenchCommandDescriptors(
+  items: readonly CommandMenuItem[],
+  overridesByCommandId: Record<string, WorkbenchCommandDescriptorOverrides> = {},
+) {
+  return items.flatMap((item) =>
+    item.type === 'command'
+      ? [commandMenuItemToWorkbenchCommandDescriptor(item, overridesByCommandId[item.commandId])]
+      : [],
+  );
+}

package/src/workbench/{commands.ts → commands/commands.ts}

@@ -10,13 +10,16 @@ import {
   type CommandValue,
 } from '@workbench-kit/platform';
 
-import type { ContextMenuItem } from '../overlay/ContextMenu';
+import type { ContextMenuItem } from '../../overlay/ContextMenu';
 
 export const WORKBENCH_OPEN_SETTINGS_COMMAND_ID = 'workbench.openSettings';
 export const WORKBENCH_TOGGLE_PRIMARY_SIDEBAR_COMMAND_ID = 'workbench.togglePrimarySidebar';
 export const WORKBENCH_EDITOR_SAVE_COMMAND_ID = 'editor.save';
 export const WORKBENCH_EDITOR_DISCARD_CHANGES_COMMAND_ID = 'editor.discardChanges';
 export const WORKBENCH_EDITOR_COPY_PATH_COMMAND_ID = 'editor.copyPath';
+export const WORKBENCH_EDITOR_TOGGLE_PINNED_COMMAND_ID = 'editor.togglePinned';
+export const WORKBENCH_EDITOR_SPLIT_RIGHT_COMMAND_ID = 'editor.splitRight';
+export const WORKBENCH_EDITOR_SPLIT_DOWN_COMMAND_ID = 'editor.splitDown';
 export const WORKBENCH_EDITOR_CLOSE_COMMAND_ID = 'editor.close';
 export const WORKBENCH_EDITOR_CLOSE_OTHERS_COMMAND_ID = 'editor.closeOthers';
 export const WORKBENCH_EDITOR_CLOSE_ALL_COMMAND_ID = 'editor.closeAll';
@@ -100,8 +103,7 @@ export interface WorkbenchShellCommandPresetOptions<TActivityId extends string =
   settingsLabel?: string | undefined;
   sidebarIcon?: string | undefined;
   commandOverrides?:
-    | WorkbenchCommandOverrides<WorkbenchShellCommandContext<TActivityId>>
-    | undefined;
+    WorkbenchCommandOverrides<WorkbenchShellCommandContext<TActivityId>> | undefined;
 }
 
 export interface WorkbenchEditorCommandContext {
@@ -112,6 +114,9 @@ export interface WorkbenchEditorCommandContext {
   canDeletePath: boolean;
   canDiscardFile: boolean;
   canSaveFile: boolean;
+  canSplitDown: boolean;
+  canSplitRight: boolean;
+  canTogglePinned: boolean;
   closeAll: () => void;
   closeOthers: () => void;
   closePath: () => void;
@@ -122,7 +127,11 @@ export interface WorkbenchEditorCommandContext {
   hasMultipleOpenFiles: boolean;
   hasOpenFiles: boolean;
   hasUnsavedChanges: boolean;
+  isPinned: boolean;
   saveFile: () => void;
+  splitDown: () => void;
+  splitRight: () => void;
+  togglePinned: () => void;
 }
 
 export interface WorkbenchWorkspaceCommandContext {
@@ -177,6 +186,7 @@ export function createWorkbenchShellCommands<TActivityId extends string>({
       label: ({ isPrimarySidebarVisible }) =>
         isPrimarySidebarVisible ? 'Hide primary sidebar' : 'Show primary sidebar',
       run: ({ togglePrimarySidebar }) => togglePrimarySidebar(),
+      title: 'Toggle primary sidebar',
     });
   }
 
@@ -186,6 +196,7 @@ export function createWorkbenchShellCommands<TActivityId extends string>({
       icon: settingsIcon,
       label: settingsLabel,
       run: ({ openSettings }) => openSettings(),
+      title: settingsLabel,
     });
   }
 
@@ -264,6 +275,30 @@ export function createWorkbenchEditorCommands({
         label: 'Copy path',
         run: ({ copyPath }) => copyPath(),
       },
+      {
+        id: WORKBENCH_EDITOR_TOGGLE_PINNED_COMMAND_ID,
+        icon: 'codicon-pinned',
+        isEnabled: ({ canTogglePinned, filePath }) => Boolean(filePath && canTogglePinned),
+        isVisible: ({ canTogglePinned, filePath }) => Boolean(filePath && canTogglePinned),
+        label: ({ isPinned }) => (isPinned ? 'Unpin' : 'Pin'),
+        run: ({ togglePinned }) => togglePinned(),
+      },
+      {
+        id: WORKBENCH_EDITOR_SPLIT_RIGHT_COMMAND_ID,
+        icon: 'codicon-split-horizontal',
+        isEnabled: ({ canSplitRight, filePath }) => Boolean(filePath && canSplitRight),
+        isVisible: ({ canSplitRight, filePath }) => Boolean(filePath && canSplitRight),
+        label: 'Split Right',
+        run: ({ splitRight }) => splitRight(),
+      },
+      {
+        id: WORKBENCH_EDITOR_SPLIT_DOWN_COMMAND_ID,
+        icon: 'codicon-split-vertical',
+        isEnabled: ({ canSplitDown, filePath }) => Boolean(filePath && canSplitDown),
+        isVisible: ({ canSplitDown, filePath }) => Boolean(filePath && canSplitDown),
+        label: 'Split Down',
+        run: ({ splitDown }) => splitDown(),
+      },
       {
         id: WORKBENCH_EDITOR_CLOSE_COMMAND_ID,
         icon: 'codicon-close',
@@ -309,10 +344,35 @@ export function createWorkbenchEditorTabListMenuEntries(): CommandMenuEntry<Work
 
 export function createWorkbenchEditorTabMenuEntries(): CommandMenuEntry<WorkbenchEditorCommandContext>[] {
   return [
+    commandMenuEntry<WorkbenchEditorCommandContext>(WORKBENCH_EDITOR_TOGGLE_PINNED_COMMAND_ID, {
+      surfaces: [WORKBENCH_COMMAND_SURFACE_EDITOR],
+    }),
+    commandMenuEntry<WorkbenchEditorCommandContext>(WORKBENCH_EDITOR_SPLIT_RIGHT_COMMAND_ID, {
+      surfaces: [WORKBENCH_COMMAND_SURFACE_EDITOR],
+    }),
+    commandMenuEntry<WorkbenchEditorCommandContext>(WORKBENCH_EDITOR_SPLIT_DOWN_COMMAND_ID, {
+      surfaces: [WORKBENCH_COMMAND_SURFACE_EDITOR],
+    }),
+    commandMenuSeparator('tab-layout-separator'),
     commandMenuEntry<WorkbenchEditorCommandContext>(WORKBENCH_EDITOR_COPY_PATH_COMMAND_ID, {
       surfaces: [WORKBENCH_COMMAND_SURFACE_EDITOR],
     }),
     commandMenuSeparator('tab-file-separator'),
+    ...createWorkbenchStandaloneEditorTabMenuEntries(),
+    commandMenuSeparator('tab-danger-separator'),
+    commandMenuEntry<WorkbenchEditorCommandContext>(WORKBENCH_EDITOR_DELETE_COMMAND_ID, {
+      surfaces: [WORKBENCH_COMMAND_SURFACE_EDITOR],
+    }),
+  ];
+}
+
+/**
+ * Close-only tab menu entries for chrome hosts that own tab state without pin,
+ * split, copy-path, or delete actions (for example `WorkbenchStandaloneShell`
+ * secondary areas using `WorkbenchEditorTabs`).
+ */
+export function createWorkbenchStandaloneEditorTabMenuEntries(): CommandMenuEntry<WorkbenchEditorCommandContext>[] {
+  return [
     commandMenuEntry<WorkbenchEditorCommandContext>(WORKBENCH_EDITOR_CLOSE_COMMAND_ID, {
       surfaces: [WORKBENCH_COMMAND_SURFACE_EDITOR],
     }),
@@ -322,10 +382,6 @@ export function createWorkbenchEditorTabMenuEntries(): CommandMenuEntry<Workbenc
     commandMenuEntry<WorkbenchEditorCommandContext>(WORKBENCH_EDITOR_CLOSE_ALL_COMMAND_ID, {
       surfaces: [WORKBENCH_COMMAND_SURFACE_EDITOR],
     }),
-    commandMenuSeparator('tab-danger-separator'),
-    commandMenuEntry<WorkbenchEditorCommandContext>(WORKBENCH_EDITOR_DELETE_COMMAND_ID, {
-      surfaces: [WORKBENCH_COMMAND_SURFACE_EDITOR],
-    }),
   ];
 }
 

package/src/workbench/commands/workbenchContextMenu.ts

@@ -0,0 +1,18 @@
+import type { MouseEvent } from 'react';
+
+const NATIVE_CONTEXT_MENU_SELECTOR =
+  'input, textarea, select, [contenteditable="true"], .monaco-editor, .workspace-editor__monaco, .cm-editor';
+
+export function shouldAllowNativeBrowserContextMenu(target: EventTarget | null): boolean {
+  if (!(target instanceof Element)) {
+    return false;
+  }
+
+  return Boolean(target.closest(NATIVE_CONTEXT_MENU_SELECTOR));
+}
+
+export function suppressNativeBrowserContextMenu(event: MouseEvent<HTMLElement>) {
+  if (!shouldAllowNativeBrowserContextMenu(event.target)) {
+    event.preventDefault();
+  }
+}

package/src/workbench/editor/WorkbenchEditorTabs.tsx

@@ -0,0 +1,52 @@
+import { EditorTabs, type EditorTabsProps } from '../../primitives/workbench-editor';
+import { useWorkbenchEditorTabContextMenu } from './useWorkbenchEditorTabContextMenu';
+
+export interface WorkbenchEditorTabsProps extends EditorTabsProps {
+  /**
+   * Optional bulk close. Defaults to calling `onClose` for every closable tab.
+   */
+  readonly onCloseAll?: (() => void) | undefined;
+  /**
+   * Optional close-others. Defaults to calling `onClose` for every other closable tab.
+   */
+  readonly onCloseOthers?: ((tabId: string) => void) | undefined;
+}
+
+/**
+ * Editor tab strip with a built-in Close / Close others / Close all context menu.
+ * Intended for `WorkbenchStandaloneShell` secondary areas that own tab state in the host.
+ * Tabs with `closable: false` keep Close disabled and are skipped by Close others / Close all.
+ */
+export function WorkbenchEditorTabs({
+  onClose,
+  onCloseAll,
+  onCloseOthers,
+  onSelect,
+  onTabContextMenu,
+  tabs,
+  ...props
+}: WorkbenchEditorTabsProps) {
+  const tabContextMenu = useWorkbenchEditorTabContextMenu({
+    onClose: onClose ?? (() => undefined),
+    onCloseAll,
+    onCloseOthers,
+    onSelectTab: onSelect,
+    tabs,
+  });
+
+  return (
+    <>
+      <EditorTabs
+        {...props}
+        onClose={onClose}
+        onSelect={onSelect}
+        onTabContextMenu={(tabId, event) => {
+          tabContextMenu.onTabContextMenu(tabId, event);
+          onTabContextMenu?.(tabId, event);
+        }}
+        tabs={tabs}
+      />
+      {tabContextMenu.contextMenu}
+    </>
+  );
+}

package/src/workbench/editor/editor-tabs-dnd.ts

@@ -0,0 +1,162 @@
+import type { EditorTabDropPosition } from '../../primitives/workbench-editor';
+
+export const EDITOR_TAB_DRAG_DATA_TYPE = 'application/x-workbench-kit-editor-tab' as const;
+
+export interface EditorTabDragPayload {
+  readonly groupId: string;
+  readonly tabId: string;
+}
+
+export interface EditorTabDropTarget {
+  readonly position: EditorTabDropPosition;
+  readonly tabId: string;
+  readonly targetIndex: number;
+}
+
+interface EditorDropTargetElement {
+  getBoundingClientRect(): Pick<DOMRect, 'left' | 'width'>;
+}
+
+interface EditorTabLike {
+  readonly id: string;
+}
+
+export function readEditorTabDragPayload(
+  dataTransfer: Pick<DataTransfer, 'getData'>,
+): EditorTabDragPayload | null {
+  try {
+    const rawPayload = dataTransfer.getData(EDITOR_TAB_DRAG_DATA_TYPE);
+    if (!rawPayload) {
+      return null;
+    }
+
+    const payload = JSON.parse(rawPayload) as Partial<EditorTabDragPayload>;
+    if (typeof payload.groupId !== 'string' || typeof payload.tabId !== 'string') {
+      return null;
+    }
+
+    return {
+      groupId: payload.groupId,
+      tabId: payload.tabId,
+    };
+  } catch {
+    return null;
+  }
+}
+
+export function isEditorTabsScrollerEventTarget(target: EventTarget | null): boolean {
+  if (!(target instanceof Element)) {
+    return false;
+  }
+
+  if (target.closest('.ui-editor-tabs__tab')) {
+    return false;
+  }
+
+  return Boolean(target.closest('.ui-editor-tabs__scroller'));
+}
+
+export function resolveEditorTabDropTarget<TTab extends EditorTabLike>({
+  clientX,
+  draggedTab,
+  groupId,
+  preferredPosition,
+  tabs,
+  target,
+  targetTabId,
+}: {
+  readonly clientX: number;
+  readonly draggedTab: EditorTabDragPayload;
+  readonly groupId: string;
+  readonly preferredPosition?: EditorTabDropPosition | undefined;
+  readonly tabs: readonly TTab[];
+  readonly target: EditorDropTargetElement;
+  readonly targetTabId: string;
+}): EditorTabDropTarget | null {
+  const targetTabIndex = tabs.findIndex((tab) => tab.id === targetTabId);
+  if (targetTabIndex < 0) {
+    return null;
+  }
+
+  const position = preferredPosition ?? getEditorTabDropPosition(target, clientX);
+  const targetIndex = position === 'after' ? targetTabIndex + 1 : targetTabIndex;
+  if (isEditorTabMoveNoop({ draggedTab, groupId, tabs, targetIndex })) {
+    return null;
+  }
+
+  return {
+    position,
+    tabId: targetTabId,
+    targetIndex,
+  };
+}
+
+export function resolveEditorTabStripDropTarget<TTab extends EditorTabLike>({
+  draggedTab,
+  groupId,
+  tabs,
+}: {
+  readonly draggedTab: EditorTabDragPayload;
+  readonly groupId: string;
+  readonly tabs: readonly TTab[];
+}): EditorTabDropTarget | null {
+  const lastTab = tabs[tabs.length - 1];
+  if (!lastTab) {
+    return null;
+  }
+
+  const targetIndex = tabs.length;
+  if (isEditorTabMoveNoop({ draggedTab, groupId, tabs, targetIndex })) {
+    return null;
+  }
+
+  return {
+    position: 'after',
+    tabId: lastTab.id,
+    targetIndex,
+  };
+}
+
+export function isEditorTabMoveNoop<TTab extends EditorTabLike>({
+  draggedTab,
+  groupId,
+  tabs,
+  targetIndex,
+}: {
+  readonly draggedTab: EditorTabDragPayload;
+  readonly groupId: string;
+  readonly tabs: readonly TTab[];
+  readonly targetIndex: number;
+}): boolean {
+  if (draggedTab.groupId !== groupId) {
+    return false;
+  }
+
+  const sourceIndex = tabs.findIndex((tab) => tab.id === draggedTab.tabId);
+  return sourceIndex >= 0 && (targetIndex === sourceIndex || targetIndex === sourceIndex + 1);
+}
+
+export function getEditorTabDropPosition(
+  target: EditorDropTargetElement,
+  clientX: number,
+): EditorTabDropPosition {
+  const rect = target.getBoundingClientRect();
+  if (rect.width <= 0) {
+    return 'after';
+  }
+
+  return clientX < rect.left + rect.width / 2 ? 'before' : 'after';
+}
+
+export function normalizeEditorTabReorderIndex({
+  index,
+  sourceIndex,
+  tabCount,
+}: {
+  index: number;
+  sourceIndex: number;
+  tabCount: number;
+}): number {
+  const clampedIndex = Math.max(0, Math.min(index, tabCount));
+  return clampedIndex > sourceIndex ? clampedIndex - 1 : clampedIndex;
+}