@brftech/filex-core 0.5.0 → 0.6.0

package/src/composables/useFileApi.ts

@@ -106,6 +106,23 @@ export interface UserSearchResponse {
   users: UserSuggestion[];
 }
 
+/* === calisma:d3 — node comments (inspector panel) === */
+
+/** Mirrors backend `model.NodeComment` (GET /api/files/comments?node_id=…). */
+export interface NodeComment {
+  id: number;
+  node_id: number;
+  user_id: number;
+  body: string;
+  created_at: string;
+  updated_at?: string;
+  /** Joined author display name (email fallback), filled by the backend. */
+  author_name?: string;
+  /** Whether the CURRENT caller may delete this row (author or admin). */
+  can_delete?: boolean;
+}
+/* === /calisma:d3 === */
+
 export interface InviteResponse {
   mode: 'granted' | 'user_created' | 'shared';
   user_id?: number;
@@ -741,6 +758,38 @@ export function useFileApi(config: ExplorerConfig) {
   }
   /* === /koru:k1 === */
 
+  /* === calisma:d3 — node comments (inspector panel) ===
+   * Same manager-URL derivation trick as versions/permissions so embedded
+   * proxies forwarding the whole /api/files/* subtree keep working.
+   *   GET    /api/files/comments?node_id=N → {comments, node_id}
+   *   POST   /api/files/comments           → {node_id, body}
+   *   DELETE /api/files/comments/{id}      → {ok}
+   */
+  function commentsUrl(sub = ''): string {
+    const base = endpoints.manager.replace(/\/manager(\?.*)?$/, '/comments');
+    return base + sub;
+  }
+  async function listComments(nodeId: number): Promise<NodeComment[]> {
+    const data = await jsonFetch<{ comments?: NodeComment[] | null }>(
+      commentsUrl() + '?node_id=' + encodeURIComponent(String(nodeId)),
+    );
+    return Array.isArray(data?.comments) ? data.comments : [];
+  }
+  async function addComment(nodeId: number, body: string): Promise<NodeComment> {
+    const data = await jsonFetch<{ comment: NodeComment }>(commentsUrl(), {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ node_id: nodeId, body }),
+    });
+    return data.comment;
+  }
+  async function deleteComment(id: number): Promise<void> {
+    await jsonFetch(commentsUrl('/' + encodeURIComponent(String(id))), {
+      method: 'DELETE',
+    });
+  }
+  /* === /calisma:d3 === */
+
   // Mint a short-lived WebSocket auth ticket for the realtime layer. Derived
   // from the manager URL (so it flows through the same host proxy) and uses the
   // same auth/creds as every other call. Returns null on any failure (a backend
@@ -790,6 +839,10 @@ export function useFileApi(config: ExplorerConfig) {
     listVersions,
     restoreVersion,
     snapshotVersion,
+    // Node comments (calisma:d3 inspector)
+    listComments,
+    addComment,
+    deleteComment,
     // Permissions (RBAC panel)
     listPermissions,
     resolveEmail,

package/src/composables/useKeyboardShortcuts.ts

@@ -38,6 +38,12 @@ export interface ShortcutHandlers {
   onShowHelp?: () => void; // ? (Shift+/ on most layouts)
   onToggleInspector?: () => void; // i (koru:k1 details panel)
   onQuickLook?: () => void; // Space (wiring:c2 quick-look overlay)
+  /* wiring:d1 — tab strip actions */
+  onTabNew?: () => void; // Ctrl+T
+  onTabClose?: () => void; // Ctrl+W
+  onTabNext?: () => void; // Ctrl+Tab
+  onTabPrev?: () => void; // Ctrl+Shift+Tab
+  /* /wiring:d1 */
   hasSelection?: () => boolean; // disambiguates Backspace
 }
 
@@ -87,6 +93,14 @@ export const SHORTCUT_ACTIONS: ShortcutActionDef[] = [
   { id: 'cut', defaultCombo: 'Ctrl+X', labelKey: 'shortcuts.cut', groupKey: 'shortcuts.group.file' },
   { id: 'copy', defaultCombo: 'Ctrl+C', labelKey: 'shortcuts.copy', groupKey: 'shortcuts.group.file' },
   { id: 'paste', defaultCombo: 'Ctrl+V', labelKey: 'shortcuts.paste', groupKey: 'shortcuts.group.file' },
+  /* wiring:d1 — tabs. Note: browsers reserve Ctrl+T/W/Tab in normal pages
+   * (preventDefault can't stop them there); they work in webcomponent/PWA/
+   * kiosk contexts and stay remappable through the settings modal. */
+  { id: 'tab-new', defaultCombo: 'Ctrl+T', labelKey: 'shortcuts.tab_new', groupKey: 'shortcuts.group.tabs' },
+  { id: 'tab-close', defaultCombo: 'Ctrl+W', labelKey: 'shortcuts.tab_close', groupKey: 'shortcuts.group.tabs' },
+  { id: 'tab-next', defaultCombo: 'Ctrl+Tab', labelKey: 'shortcuts.tab_next', groupKey: 'shortcuts.group.tabs' },
+  { id: 'tab-prev', defaultCombo: 'Ctrl+Shift+Tab', labelKey: 'shortcuts.tab_prev', groupKey: 'shortcuts.group.tabs' },
+  /* /wiring:d1 */
 ];
 
 /** action id → ShortcutHandlers callback name. */
@@ -105,6 +119,11 @@ const HANDLER_KEY: Record<string, keyof ShortcutHandlers> = {
   cut: 'onCut',
   copy: 'onCopy',
   paste: 'onPaste',
+  /* wiring:d1 */
+  'tab-new': 'onTabNew',
+  'tab-close': 'onTabClose',
+  'tab-next': 'onTabNext',
+  'tab-prev': 'onTabPrev',
 };
 
 // --------------------------------------------------------------------

package/src/composables/useTabs.ts

@@ -0,0 +1,222 @@
+/**
+ * useTabs — wiring:d1 sekmeler (çalışma alanı tab şeridi).
+ *
+ * A LAYER ABOVE FileExplorer's location state, never a replacement for
+ * it: each tab is a location snapshot `{ id, path, viewMode, split }`.
+ * The composable performs no fetching and owns no navigation — the host
+ * activates a tab by running its EXISTING `load(path)` pipeline and
+ * reports navigations back through `syncActive()`, which keeps the
+ * active snapshot glued to wherever the user actually is.
+ *
+ * `path` is stored in the SAME form as FileExplorer's `currentPath`
+ * (virtual `<storage>/<rel>` in multi-storage mode, bare relative path
+ * in single-storage mode) — i.e. the exact string `load(path)` accepts.
+ * Storing the wire form (`adapter://rel`) instead would break the
+ * rootPath-floor clamp inside load() (the floor is compared in user-path
+ * form), so the user-path form is deliberate.
+ *
+ * Persistence: localStorage under a host-supplied key (the host derives
+ * it from the pathPersist scope: disabled when `pathPersist: 'none'`,
+ * suffixed with the rootPath confine so embedded instances with
+ * different confines never clobber each other). Schema:
+ *
+ *   { "v": 1, "active": "<id>",
+ *     "tabs": [ { "id", "path", "viewMode", "split": {"path"}|null } ] }
+ */
+
+import { computed, ref, watch, type Ref } from 'vue';
+import type { ViewMode } from '../types/FileNode';
+
+/** Per-tab split state — the secondary pane's own location. */
+export interface TabSplit {
+  path: string;
+}
+
+export interface TabState {
+  id: string;
+  /** Location snapshot in `currentPath` form (see module docs). */
+  path: string;
+  viewMode: ViewMode;
+  split: TabSplit | null;
+}
+
+export interface UseTabsOptions {
+  /** localStorage key; null disables persistence entirely. */
+  storageKey: string | null;
+}
+
+function makeId(): string {
+  try {
+    return crypto.randomUUID();
+  } catch {
+    return `t${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+  }
+}
+
+export function useTabs(opts: UseTabsOptions) {
+  const tabs: Ref<TabState[]> = ref([]);
+  const activeId = ref<string>('');
+
+  const activeTab = computed<TabState | null>(
+    () => tabs.value.find((t) => t.id === activeId.value) ?? null,
+  );
+  const activeIndex = computed(() => tabs.value.findIndex((t) => t.id === activeId.value));
+  const hasMultiple = computed(() => tabs.value.length > 1);
+
+  // ------------------------------------------------------------------
+  // Persistence
+  // ------------------------------------------------------------------
+
+  /** Restore from storage. Returns true when at least one tab loaded. */
+  function restore(): boolean {
+    if (!opts.storageKey) return false;
+    try {
+      const raw = localStorage.getItem(opts.storageKey);
+      if (!raw) return false;
+      const parsed = JSON.parse(raw) as { v?: unknown; active?: unknown; tabs?: unknown };
+      if (!parsed || !Array.isArray(parsed.tabs) || parsed.tabs.length === 0) return false;
+      const clean: TabState[] = [];
+      for (const t of parsed.tabs as Array<Record<string, unknown>>) {
+        if (!t || typeof t.path !== 'string') continue;
+        // ViewMode is validated loosely on purpose: future modes (e.g. the
+        // gallery wave) must survive a round-trip through an older schema.
+        const vm =
+          typeof t.viewMode === 'string' && t.viewMode ? (t.viewMode as ViewMode) : 'list';
+        const rawSplit = t.split as { path?: unknown } | null | undefined;
+        const split =
+          rawSplit && typeof rawSplit === 'object' && typeof rawSplit.path === 'string'
+            ? { path: rawSplit.path }
+            : null;
+        clean.push({
+          id: typeof t.id === 'string' && t.id ? t.id : makeId(),
+          path: t.path,
+          viewMode: vm,
+          split,
+        });
+      }
+      if (clean.length === 0) return false;
+      tabs.value = clean;
+      activeId.value = clean.some((t) => t.id === parsed.active)
+        ? String(parsed.active)
+        : clean[0].id;
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  function persist(): void {
+    if (!opts.storageKey) return;
+    try {
+      localStorage.setItem(
+        opts.storageKey,
+        JSON.stringify({ v: 1, active: activeId.value, tabs: tabs.value }),
+      );
+    } catch {
+      /* private mode / quota */
+    }
+  }
+
+  watch([tabs, activeId], persist, { deep: true });
+
+  // ------------------------------------------------------------------
+  // Mutations
+  // ------------------------------------------------------------------
+
+  /** Create the first tab (no-op once any tab exists). */
+  function seed(path: string, viewMode: ViewMode): void {
+    if (tabs.value.length > 0) return;
+    const t: TabState = { id: makeId(), path, viewMode, split: null };
+    tabs.value = [t];
+    activeId.value = t.id;
+  }
+
+  /** Update the ACTIVE tab's snapshot (navigation / view-mode change). */
+  function syncActive(patch: Partial<Pick<TabState, 'path' | 'viewMode'>>): void {
+    const t = activeTab.value;
+    if (!t) return;
+    if (patch.path !== undefined) t.path = patch.path;
+    if (patch.viewMode !== undefined) t.viewMode = patch.viewMode;
+  }
+
+  /** Open a new tab right after the active one (browser convention). */
+  function openTab(
+    path: string,
+    o: { viewMode: ViewMode; background?: boolean; split?: TabSplit | null },
+  ): TabState {
+    const t: TabState = { id: makeId(), path, viewMode: o.viewMode, split: o.split ?? null };
+    const idx = activeIndex.value;
+    tabs.value.splice(idx === -1 ? tabs.value.length : idx + 1, 0, t);
+    if (!o.background) activeId.value = t.id;
+    return t;
+  }
+
+  /**
+   * Close a tab. The last remaining tab never closes. Returns the tab
+   * the host must ACTIVATE (right neighbour, else left) when the active
+   * one was closed; null when the visible location is unchanged.
+   */
+  function closeTab(id: string): TabState | null {
+    if (tabs.value.length <= 1) return null;
+    const idx = tabs.value.findIndex((t) => t.id === id);
+    if (idx === -1) return null;
+    const wasActive = tabs.value[idx].id === activeId.value;
+    tabs.value.splice(idx, 1);
+    if (!wasActive) return null;
+    const next = tabs.value[Math.min(idx, tabs.value.length - 1)];
+    activeId.value = next.id;
+    return next;
+  }
+
+  /** Make a tab active. Returns it when the active tab actually changed. */
+  function activate(id: string): TabState | null {
+    const t = tabs.value.find((x) => x.id === id);
+    if (!t || t.id === activeId.value) return null;
+    activeId.value = t.id;
+    return t;
+  }
+
+  /** Cycle: +1 = next, -1 = previous (wraps). */
+  function step(delta: number): TabState | null {
+    if (tabs.value.length < 2) return null;
+    const idx = activeIndex.value === -1 ? 0 : activeIndex.value;
+    const next = tabs.value[(idx + delta + tabs.value.length) % tabs.value.length];
+    return activate(next.id);
+  }
+
+  /** Drag-sort support: move the tab at `from` to position `to`. */
+  function move(from: number, to: number): void {
+    if (from === to) return;
+    if (from < 0 || to < 0 || from >= tabs.value.length || to >= tabs.value.length) return;
+    const list = [...tabs.value];
+    const [t] = list.splice(from, 1);
+    list.splice(to, 0, t);
+    tabs.value = list;
+  }
+
+  /** Set (or clear with null) the ACTIVE tab's split state. */
+  function setSplit(split: TabSplit | null): void {
+    const t = activeTab.value;
+    if (!t) return;
+    t.split = split;
+  }
+
+  return {
+    tabs,
+    activeId,
+    activeTab,
+    activeIndex,
+    hasMultiple,
+    restore,
+    seed,
+    syncActive,
+    openTab,
+    closeTab,
+    activate,
+    step,
+    move,
+    setSplit,
+  };
+}
+
+export type TabsApi = ReturnType<typeof useTabs>;

package/src/index.ts

@@ -127,3 +127,9 @@ export type {
   OperationsStore,
 } from './composables/useOperations';
 export { default as OperationsCenter } from './components/OperationsCenter.vue';
+/* wiring:d1 — sekmeler + split panel */
+export { useTabs } from './composables/useTabs';
+export type { TabState, TabSplit, TabsApi } from './composables/useTabs';
+export { default as TabBar } from './components/TabBar.vue';
+export { default as SecondaryPane } from './components/SecondaryPane.vue';
+/* /wiring:d1 */

package/src/locales/en.ts

@@ -332,4 +332,37 @@ export const en: Record<string, string> = {
   'toolbar.view_label': 'View',
   'list.aria': 'File list',
   'grid.aria': 'File grid',
+
+  /* === wiring:d1 — tabs + split pane === */
+  'tabs.strip': 'Tabs',
+  'tabs.new': 'New tab',
+  'tabs.close': 'Close tab',
+  'tabs.split': 'Split view',
+  'tabs.split_off': 'Close split',
+  'ctx.open_new_tab': 'Open in new tab',
+  'shortcuts.group.tabs': 'Tabs',
+  'shortcuts.tab_new': 'New tab',
+  'shortcuts.tab_close': 'Close tab',
+  'shortcuts.tab_next': 'Next tab',
+  'shortcuts.tab_prev': 'Previous tab',
+  'cmd.tab_new': 'Open a new tab',
+  'cmd.split_toggle': 'Toggle split view',
+  'split.pane': 'Secondary pane',
+  'split.close': 'Close the side pane',
+  'split.error': 'Could not load the listing',
+  'split.retry': 'Retry',
+  'split.copy_queued': 'Copy queued',
+  'split.cross_copy': 'Different storages — copy queued instead',
+  'split.cross_failed': 'Cross-storage copy is not supported by this server',
+  /* === /wiring:d1 === */
+  /* wiring:d2 — gallery view */
+  'toolbar.view.gallery': 'Gallery',
+  'gallery.aria': 'File gallery',
+  /* /wiring:d2 */
+  /* wiring:d3 — inspector node comments */
+  'inspector.section.comments': 'Comments',
+  'inspector.comments.empty': 'No comments yet.',
+  'inspector.comments.placeholder': 'Write a comment…',
+  'inspector.comments.send': 'Send',
+  'inspector.comments.delete': 'Delete comment',
 };

package/src/locales/tr.ts

@@ -332,4 +332,37 @@ export const tr: Record<string, string> = {
   'toolbar.view_label': 'Görünüm',
   'list.aria': 'Dosya listesi',
   'grid.aria': 'Dosya ızgarası',
+
+  /* === wiring:d1 — sekmeler + split panel === */
+  'tabs.strip': 'Sekmeler',
+  'tabs.new': 'Yeni sekme',
+  'tabs.close': 'Sekmeyi kapat',
+  'tabs.split': 'Görünümü böl',
+  'tabs.split_off': 'Bölmeyi kapat',
+  'ctx.open_new_tab': 'Yeni sekmede aç',
+  'shortcuts.group.tabs': 'Sekmeler',
+  'shortcuts.tab_new': 'Yeni sekme',
+  'shortcuts.tab_close': 'Sekmeyi kapat',
+  'shortcuts.tab_next': 'Sonraki sekme',
+  'shortcuts.tab_prev': 'Önceki sekme',
+  'cmd.tab_new': 'Yeni sekme aç',
+  'cmd.split_toggle': 'Görünümü böl / birleştir',
+  'split.pane': 'İkincil panel',
+  'split.close': 'Yan paneli kapat',
+  'split.error': 'Liste yüklenemedi',
+  'split.retry': 'Yeniden dene',
+  'split.copy_queued': 'Kopyalama kuyruğa alındı',
+  'split.cross_copy': 'Depolar farklı — kopyalama kuyruğa alındı',
+  'split.cross_failed': 'Depolar arası kopyalama bu sunucuda desteklenmiyor',
+  /* === /wiring:d1 === */
+  /* wiring:d2 — galeri görünümü */
+  'toolbar.view.gallery': 'Galeri',
+  'gallery.aria': 'Dosya galerisi',
+  /* /wiring:d2 */
+  /* wiring:d3 — Yorumlar (inspector node comments) */
+  'inspector.section.comments': 'Yorumlar',
+  'inspector.comments.empty': 'Henüz yorum yok.',
+  'inspector.comments.placeholder': 'Yorum yaz…',
+  'inspector.comments.send': 'Gönder',
+  'inspector.comments.delete': 'Yorumu sil',
 };