[Init] Initial commit - NetMesh terminal manager

application/state/useWorkSurfaceHostEditor.ts

@@ -0,0 +1,171 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+
+import { upsertHostById } from '../../domain/host';
+import type { Host } from '../../types';
+
+export type WorkSurfaceHostEditorMode = 'new' | 'edit';
+
+export type WorkSurfaceHostEditorTarget =
+  | { mode: 'new'; defaultGroup: string | null; requestId: number }
+  | { mode: 'edit'; openedHost: Host; requestId: number };
+
+interface UseWorkSurfaceHostEditorOptions {
+  hosts: Host[];
+  onUpdateHosts: (hosts: Host[]) => void;
+  onSaved?: (mode: WorkSurfaceHostEditorMode) => void;
+}
+
+export function buildWorkSurfaceHostEditorKey(target: WorkSurfaceHostEditorTarget): string {
+  if (target.mode === 'edit') {
+    return `edit:${target.openedHost.id}:${target.requestId}`;
+  }
+  return `new:${target.defaultGroup ?? 'root'}:${target.requestId}`;
+}
+
+export function shouldCloseDeletedWorkSurfaceHost(
+  hosts: Host[],
+  target: WorkSurfaceHostEditorTarget | null,
+): boolean {
+  return target?.mode === 'edit'
+    && !hosts.some((host) => host.id === target.openedHost.id);
+}
+
+function isPlainRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function areDraftValuesEqual(left: unknown, right: unknown): boolean {
+  if (Object.is(left, right)) return true;
+  if (Array.isArray(left) || Array.isArray(right)) {
+    return Array.isArray(left)
+      && Array.isArray(right)
+      && left.length === right.length
+      && left.every((value, index) => areDraftValuesEqual(value, right[index]));
+  }
+  if (!isPlainRecord(left) || !isPlainRecord(right)) return false;
+  const leftKeys = Object.keys(left);
+  const rightKeys = Object.keys(right);
+  return leftKeys.length === rightKeys.length
+    && leftKeys.every((key) => Object.hasOwn(right, key)
+      && areDraftValuesEqual(left[key], right[key]));
+}
+
+function mergeWorkSurfaceDraftValue(
+  openedValue: unknown,
+  draftValue: unknown,
+  latestValue: unknown,
+): unknown {
+  if (areDraftValuesEqual(draftValue, openedValue)) return latestValue;
+  if (!isPlainRecord(draftValue) || !isPlainRecord(latestValue)) {
+    return draftValue;
+  }
+
+  const openedRecord = isPlainRecord(openedValue) ? openedValue : {};
+  const merged: Record<string, unknown> = { ...latestValue };
+  const draftKeys = new Set([...Object.keys(openedRecord), ...Object.keys(draftValue)]);
+  for (const key of draftKeys) {
+    if (!Object.hasOwn(draftValue, key)) {
+      delete merged[key];
+      continue;
+    }
+    merged[key] = mergeWorkSurfaceDraftValue(
+      openedRecord[key],
+      draftValue[key],
+      latestValue[key],
+    );
+  }
+  return merged;
+}
+
+export function mergeWorkSurfaceHostDraft(
+  openedHost: Host,
+  draft: Host,
+  latestHost: Host,
+): Host {
+  return mergeWorkSurfaceDraftValue(openedHost, draft, latestHost) as Host;
+}
+
+export function saveWorkSurfaceHostDraft(
+  hosts: Host[],
+  target: WorkSurfaceHostEditorTarget,
+  draft: Host,
+): Host[] | null {
+  if (target.mode === 'new') {
+    return upsertHostById(hosts, draft);
+  }
+
+  const latestHost = hosts.find((host) => host.id === target.openedHost.id);
+  if (!latestHost) return null;
+
+  return upsertHostById(
+    hosts,
+    mergeWorkSurfaceHostDraft(target.openedHost, draft, latestHost),
+  );
+}
+
+export function useWorkSurfaceHostEditor({
+  hosts,
+  onUpdateHosts,
+  onSaved,
+}: UseWorkSurfaceHostEditorOptions) {
+  const [target, setTarget] = useState<WorkSurfaceHostEditorTarget | null>(null);
+  const requestIdRef = useRef(0);
+
+  const nextRequestId = useCallback(() => {
+    requestIdRef.current += 1;
+    return requestIdRef.current;
+  }, []);
+
+  const openNew = useCallback((defaultGroup?: string | null) => {
+    setTarget({
+      mode: 'new',
+      defaultGroup: defaultGroup || null,
+      requestId: nextRequestId(),
+    });
+  }, [nextRequestId]);
+
+  const openEdit = useCallback((host: Host) => {
+    setTarget({ mode: 'edit', openedHost: host, requestId: nextRequestId() });
+  }, [nextRequestId]);
+
+  const close = useCallback(() => {
+    setTarget(null);
+  }, []);
+
+  const save = useCallback((draft: Host) => {
+    if (!target) return;
+    let saved = false;
+    onUpdateHosts((prevHosts) => {
+      const nextHosts = saveWorkSurfaceHostDraft(prevHosts, target, draft);
+      if (!nextHosts) return prevHosts;
+      saved = true;
+      return nextHosts;
+    });
+    if (!saved) {
+      close();
+      return;
+    }
+    onSaved?.(target.mode);
+    close();
+  }, [close, onSaved, onUpdateHosts, target]);
+
+  useEffect(() => {
+    if (shouldCloseDeletedWorkSurfaceHost(hosts, target)) {
+      close();
+    }
+  }, [close, hosts, target]);
+
+  const editorKey = useMemo(
+    () => (target ? buildWorkSurfaceHostEditorKey(target) : null),
+    [target],
+  );
+
+  return {
+    target,
+    editorKey,
+    openNew,
+    openEdit,
+    close,
+    save,
+  };
+}