[Init] Initial commit - NetMesh terminal manager

components/vault/useHostTreeInlineGroupActions.ts

@@ -0,0 +1,157 @@
+import { useCallback } from 'react';
+
+import { hostTreeInlineGroupDeleteStore } from '../../application/state/hostTreeInlineGroupDeleteStore';
+import { hostTreeInlineGroupEditStore } from '../../application/state/hostTreeInlineGroupEditStore';
+import { hostTreeInlineHostEditStore } from '../../application/state/hostTreeInlineHostEditStore';
+import {
+  allocateUnnamedGroupPath,
+  applyGroupPathRename,
+  ensureAncestorPathsExpanded,
+  groupDisplayName,
+} from '../../domain/hostGroupPathMutations';
+import type { Host, ManagedSource } from '../../types';
+import { toast } from '../ui/toast';
+
+type UseHostTreeInlineGroupActionsParams = {
+  customGroups: string[];
+  hosts: Host[];
+  managedSources: ManagedSource[];
+  onUpdateCustomGroups: (groups: string[]) => void;
+  onCommitGroupPathChange: (
+    sourcePath: string,
+    nextPath: string,
+  ) => Promise<
+    | { ok: true }
+    | { ok: false; error?: string; superseded?: true }
+  >;
+  selectedGroupPath: string | null;
+  setSelectedGroupPath: (path: string | null) => void;
+  ensurePathExpanded: (path: string) => void;
+  unnamedGroupLabel: string;
+  t: (key: string) => string;
+};
+
+export function useHostTreeInlineGroupActions({
+  customGroups,
+  hosts,
+  managedSources,
+  onUpdateCustomGroups,
+  onCommitGroupPathChange,
+  selectedGroupPath,
+  setSelectedGroupPath,
+  ensurePathExpanded,
+  unnamedGroupLabel,
+  t,
+}: UseHostTreeInlineGroupActionsParams) {
+  const startInlineNewGroup = useCallback((parentPath?: string) => {
+    hostTreeInlineHostEditStore.clear();
+    const parent = parentPath ?? null;
+    const { name, path } = allocateUnnamedGroupPath(customGroups, parent, unnamedGroupLabel);
+    onUpdateCustomGroups(Array.from(new Set([...customGroups, path])));
+    if (parent) {
+      ensureAncestorPathsExpanded(parent, ensurePathExpanded);
+      ensurePathExpanded(parent);
+    }
+    hostTreeInlineGroupEditStore.startEdit({
+      groupPath: path,
+      initialName: name,
+      isNew: true,
+    });
+  }, [customGroups, ensurePathExpanded, onUpdateCustomGroups, unnamedGroupLabel]);
+
+  const startInlineRenameGroup = useCallback((groupPath: string) => {
+    hostTreeInlineHostEditStore.clear();
+    hostTreeInlineGroupEditStore.startEdit({
+      groupPath,
+      initialName: groupDisplayName(groupPath),
+      isNew: false,
+    });
+  }, []);
+
+  const cancelInlineGroupEdit = useCallback(() => {
+    const edit = hostTreeInlineGroupEditStore.getEdit();
+    if (!edit) return;
+    if (edit.isNew) {
+      onUpdateCustomGroups(customGroups.filter((groupPath) => groupPath !== edit.groupPath));
+    }
+    hostTreeInlineGroupEditStore.clear();
+  }, [customGroups, onUpdateCustomGroups]);
+
+  const commitInlineGroupRename = useCallback(async (rawName: string): Promise<boolean> => {
+    const edit = hostTreeInlineGroupEditStore.getEdit();
+    if (!edit) return false;
+
+    const result = applyGroupPathRename({
+      renameTargetPath: edit.groupPath,
+      nextName: rawName,
+      customGroups,
+      hosts,
+      managedSources,
+    });
+
+    if (result.ok === false) {
+      if (result.error === 'unchanged') {
+        hostTreeInlineGroupEditStore.clear();
+        return true;
+      }
+      if (result.error === 'required') {
+        if (edit.isNew) {
+          cancelInlineGroupEdit();
+          return true;
+        }
+        toast.error(t('vault.groups.errors.required'));
+        return false;
+      }
+      if (result.error === 'invalidChars') {
+        toast.error(t('vault.groups.errors.invalidChars'));
+        return false;
+      }
+      if (result.error === 'duplicatePath') {
+        toast.error(t('vault.groups.errors.duplicatePath'));
+        return false;
+      }
+      return false;
+    }
+
+    const committed = await onCommitGroupPathChange(edit.groupPath, result.nextPath);
+    if (!committed.ok) {
+      toast.error(committed.error || t('common.error'));
+      return false;
+    }
+
+    if (
+      selectedGroupPath
+      && (selectedGroupPath === edit.groupPath
+        || selectedGroupPath.startsWith(`${edit.groupPath}/`))
+    ) {
+      const suffix = selectedGroupPath === edit.groupPath
+        ? ''
+        : selectedGroupPath.slice(edit.groupPath.length);
+      setSelectedGroupPath(result.nextPath + suffix);
+    }
+
+    hostTreeInlineGroupEditStore.clear();
+    return true;
+  }, [
+    cancelInlineGroupEdit,
+    customGroups,
+    hosts,
+    managedSources,
+    onCommitGroupPathChange,
+    selectedGroupPath,
+    setSelectedGroupPath,
+    t,
+  ]);
+
+  const startInlineDeleteGroup = useCallback((groupPath: string) => {
+    hostTreeInlineGroupDeleteStore.open(groupPath);
+  }, []);
+
+  return {
+    startInlineNewGroup,
+    startInlineRenameGroup,
+    commitInlineGroupRename,
+    cancelInlineGroupEdit,
+    startInlineDeleteGroup,
+  };
+}