[Init] Initial commit - NetMesh terminal manager

application/state/pluginViewTabStore.ts

@@ -0,0 +1,147 @@
+import { useSyncExternalStore } from 'react';
+
+import { activeTabStore } from './activeTabStore';
+
+export const PLUGIN_VIEW_TAB_PREFIX = 'plugin-view:';
+
+export interface PluginViewTab {
+  id: string;
+  pluginId: string;
+  pluginName: string;
+  viewId: string;
+  title: string;
+  icon?: NetcattyPluginIconReference;
+  context?: Record<string, unknown>;
+}
+
+export interface ClosedPluginViewTabEvent {
+  tab: PluginViewTab;
+}
+
+export function toPluginViewTabId(pluginId: string, viewId: string): string {
+  return `${PLUGIN_VIEW_TAB_PREFIX}${pluginId}:${viewId}`;
+}
+
+export function isPluginViewTabId(tabId: string): boolean {
+  return tabId.startsWith(PLUGIN_VIEW_TAB_PREFIX);
+}
+
+export function resolveBatchTabCloseFocus({
+  orderedTabIds,
+  closingTabIds,
+  activeTabId,
+}: {
+  orderedTabIds: readonly string[];
+  closingTabIds: ReadonlySet<string>;
+  activeTabId: string;
+}): string {
+  if (!closingTabIds.has(activeTabId)) return activeTabId;
+  const activeIndex = orderedTabIds.indexOf(activeTabId);
+  if (activeIndex === -1) return 'vault';
+  for (let distance = 1; distance < orderedTabIds.length; distance += 1) {
+    const left = orderedTabIds[activeIndex - distance];
+    if (left && !closingTabIds.has(left)) return left;
+    const right = orderedTabIds[activeIndex + distance];
+    if (right && !closingTabIds.has(right)) return right;
+  }
+  return 'vault';
+}
+
+export function resolvePluginViewRequest(
+  requested: { viewId: string; context?: Record<string, unknown> } | null,
+  activeTab: Pick<PluginViewTab, 'viewId' | 'context'> | null,
+): { viewId: string; context?: Record<string, unknown> } | null {
+  if (requested) return requested;
+  return activeTab ? { viewId: activeTab.viewId, context: activeTab.context } : null;
+}
+
+export class PluginViewTabStore {
+  private tabs: readonly PluginViewTab[] = Object.freeze([]);
+  private listeners = new Set<() => void>();
+  private closeListeners = new Set<(event: ClosedPluginViewTabEvent) => void>();
+
+  constructor(private readonly activeTabs: Pick<typeof activeTabStore, 'getActiveTabId' | 'setActiveTabId'> = activeTabStore) {}
+
+  getTabs = () => this.tabs;
+
+  getTab(tabId: string): PluginViewTab | undefined {
+    return this.tabs.find((tab) => tab.id === tabId);
+  }
+
+  open(input: Omit<PluginViewTab, 'id'>): PluginViewTab {
+    const id = toPluginViewTabId(input.pluginId, input.viewId);
+    const tab = Object.freeze({ ...input, id });
+    const index = this.tabs.findIndex((candidate) => candidate.id === id);
+    this.tabs = Object.freeze(index === -1
+      ? [...this.tabs, tab]
+      : this.tabs.map((candidate) => candidate.id === id ? tab : candidate));
+    this.emit();
+    this.activeTabs.setActiveTabId(id);
+    return tab;
+  }
+
+  close(tabId: string): void {
+    const closed = this.tabs.find((tab) => tab.id === tabId);
+    if (!closed) return;
+    const next = this.tabs.filter((tab) => tab.id !== tabId);
+    this.tabs = Object.freeze(next);
+    if (this.activeTabs.getActiveTabId() === tabId) this.activeTabs.setActiveTabId('vault');
+    this.emit();
+    this.emitClosed(closed);
+  }
+
+  retain(viewIds: ReadonlySet<string>): void {
+    const next = this.tabs.filter((tab) => viewIds.has(tab.viewId));
+    if (next.length === this.tabs.length) return;
+    const removed = this.tabs.filter((tab) => !viewIds.has(tab.viewId));
+    const activeTabId = this.activeTabs.getActiveTabId();
+    this.tabs = Object.freeze(next);
+    if (isPluginViewTabId(activeTabId) && !next.some((tab) => tab.id === activeTabId)) {
+      this.activeTabs.setActiveTabId('vault');
+    }
+    this.emit();
+    for (const tab of removed) this.emitClosed(tab);
+  }
+
+  refreshMetadata(entries: readonly Omit<PluginViewTab, 'id' | 'context'>[]): void {
+    const metadata = new Map(entries.map((entry) => [toPluginViewTabId(entry.pluginId, entry.viewId), entry]));
+    let changed = false;
+    const next = this.tabs.map((tab) => {
+      const entry = metadata.get(tab.id);
+      if (!entry) return tab;
+      if (entry.pluginName === tab.pluginName
+        && entry.title === tab.title
+        && JSON.stringify(entry.icon ?? null) === JSON.stringify(tab.icon ?? null)) return tab;
+      changed = true;
+      return Object.freeze({ ...tab, ...entry, id: tab.id });
+    });
+    if (!changed) return;
+    this.tabs = Object.freeze(next);
+    this.emit();
+  }
+
+  subscribe = (listener: () => void) => {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  };
+
+  onDidClose = (listener: (event: ClosedPluginViewTabEvent) => void) => {
+    this.closeListeners.add(listener);
+    return () => this.closeListeners.delete(listener);
+  };
+
+  private emit(): void {
+    for (const listener of this.listeners) listener();
+  }
+
+  private emitClosed(tab: PluginViewTab): void {
+    const event = Object.freeze({ tab });
+    for (const listener of this.closeListeners) listener(event);
+  }
+}
+
+export const pluginViewTabStore = new PluginViewTabStore();
+
+export function usePluginViewTabs(): readonly PluginViewTab[] {
+  return useSyncExternalStore(pluginViewTabStore.subscribe, pluginViewTabStore.getTabs, pluginViewTabStore.getTabs);
+}