[Init] Initial commit - NetMesh terminal manager

application/state/vaultImportProgress.ts

@@ -0,0 +1,234 @@
+export type VaultImportProgressStage =
+  | "reading"
+  | "parsing"
+  | "preparing"
+  | "saving"
+  | "complete"
+  | "failed";
+
+export interface VaultImportProgress {
+  status: "running" | "complete" | "error";
+  stage: VaultImportProgressStage;
+  percent: number;
+  formatLabel: string;
+  fileName: string;
+  completedFiles?: number;
+  totalFiles?: number;
+  currentFileName?: string;
+  imported?: number;
+  skipped?: number;
+  duplicates?: number;
+  error?: string;
+}
+
+export type VaultHostPersistenceResult = boolean | void | "superseded";
+
+export function countVaultImportDuplicates({
+  importedHostCount,
+  newHostCount,
+  fileDuplicateCount,
+  managed,
+}: {
+  importedHostCount: number;
+  newHostCount: number;
+  fileDuplicateCount: number;
+  managed: boolean;
+}): number {
+  const existingDuplicateCount = managed
+    ? 0
+    : Math.max(0, importedHostCount - newHostCount);
+  return fileDuplicateCount + existingDuplicateCount;
+}
+
+export async function ensureVaultImportPersisted(
+  persisted: Exclude<VaultHostPersistenceResult, "superseded">,
+  errorMessage: string,
+  onPersisted?: () => unknown | Promise<unknown>,
+  onPersistenceFailed?: () => unknown | Promise<unknown>,
+): Promise<void> {
+  if (persisted === false) {
+    try {
+      await onPersistenceFailed?.();
+    } catch {
+      // Keep the original persistence error visible even if rollback also fails.
+    }
+    throw new Error(errorMessage);
+  }
+  await onPersisted?.();
+}
+
+const importFieldMatches = (left: unknown, right: unknown): boolean => (
+  JSON.stringify(left) === JSON.stringify(right)
+);
+
+const hostMatchesAppliedImport = (currentHost: Host, appliedHost: Host): boolean => {
+  const { order: _currentOrder, ...currentComparable } = currentHost;
+  const { order: _appliedOrder, ...appliedComparable } = appliedHost;
+  return importFieldMatches(currentComparable, appliedComparable);
+};
+
+export function rebaseVaultImportedHosts({
+  currentHosts,
+  baselineHosts,
+  appliedHosts,
+}: {
+  currentHosts: Host[];
+  baselineHosts: Host[];
+  appliedHosts: Host[];
+}): Host[] {
+  const baselineById = new Map(baselineHosts.map((host) => [host.id, host]));
+  const appliedById = new Map(appliedHosts.map((host) => [host.id, host]));
+  const currentIds = new Set(currentHosts.map((host) => host.id));
+
+  const rebasedHosts = currentHosts.map((currentHost) => {
+    const baselineHost = baselineById.get(currentHost.id);
+    const appliedHost = appliedById.get(currentHost.id);
+    if (!baselineHost || !appliedHost) return currentHost;
+
+    const fieldNames = new Set([
+      ...Object.keys(baselineHost),
+      ...Object.keys(appliedHost),
+    ] as Array<keyof Host>);
+    const rebased = { ...currentHost } as Record<string, unknown>;
+    for (const field of fieldNames) {
+      if (importFieldMatches(baselineHost[field], appliedHost[field])) continue;
+      if (!importFieldMatches(currentHost[field], baselineHost[field])) continue;
+      if (Object.prototype.hasOwnProperty.call(appliedHost, field)) {
+        rebased[field as string] = appliedHost[field];
+      } else {
+        delete rebased[field as string];
+      }
+    }
+    return rebased as Host;
+  });
+
+  for (const appliedHost of appliedHosts) {
+    if (!baselineById.has(appliedHost.id) && !currentIds.has(appliedHost.id)) {
+      rebasedHosts.push(appliedHost);
+    }
+  }
+  return rebasedHosts;
+}
+
+export function mergeVaultImportedGroups({
+  currentGroups,
+  baselineGroups,
+  appliedGroups,
+}: {
+  currentGroups: string[];
+  baselineGroups: string[];
+  appliedGroups: string[];
+}): string[] {
+  const baseline = new Set(baselineGroups);
+  const importedGroups = appliedGroups.filter((group) => !baseline.has(group));
+  return Array.from(new Set([...currentGroups, ...importedGroups]));
+}
+
+export function resolveUniqueManagedImportGroupName({
+  baseName,
+  customGroups,
+  hosts,
+  managedSources,
+  ownerSourceId,
+}: {
+  baseName: string;
+  customGroups: string[];
+  hosts: Host[];
+  managedSources: ManagedSource[];
+  ownerSourceId?: string;
+}): string {
+  const existingGroupNames = new Set([
+    ...customGroups,
+    ...managedSources
+      .filter((source) => source.id !== ownerSourceId)
+      .map((source) => source.groupName),
+    ...hosts
+      .filter((host) => host.managedSourceId !== ownerSourceId)
+      .map((host) => host.group)
+      .filter((group): group is string => Boolean(group)),
+  ]);
+  const initialName = `${baseName} - Managed`;
+  let groupName = initialName;
+  let suffix = 1;
+  while (existingGroupNames.has(groupName)) {
+    groupName = `${initialName} (${suffix})`;
+    suffix++;
+  }
+  return groupName;
+}
+
+export function rollbackVaultImportedHosts({
+  currentHosts,
+  baselineHosts,
+  appliedHosts,
+}: {
+  currentHosts: Host[];
+  baselineHosts: Host[];
+  appliedHosts: Host[];
+}): Host[] {
+  const baselineById = new Map(baselineHosts.map((host) => [host.id, host]));
+  const appliedById = new Map(appliedHosts.map((host) => [host.id, host]));
+  const addedHostIds = new Set(
+    appliedHosts.filter((host) => !baselineById.has(host.id)).map((host) => host.id),
+  );
+
+  return currentHosts.flatMap((currentHost) => {
+    if (addedHostIds.has(currentHost.id)) {
+      const appliedHost = appliedById.get(currentHost.id);
+      return appliedHost && hostMatchesAppliedImport(currentHost, appliedHost)
+        ? []
+        : [currentHost];
+    }
+    const baselineHost = baselineById.get(currentHost.id);
+    const appliedHost = appliedById.get(currentHost.id);
+    if (!baselineHost || !appliedHost) return [currentHost];
+
+    const fieldNames = new Set([
+      ...Object.keys(baselineHost),
+      ...Object.keys(appliedHost),
+    ] as Array<keyof Host>);
+    const changedFields = [...fieldNames].filter((field) => (
+      !importFieldMatches(baselineHost[field], appliedHost[field])
+    ));
+    if (changedFields.length === 0) return [currentHost];
+    const restored = { ...currentHost } as Record<string, unknown>;
+    for (const field of changedFields) {
+      if (!importFieldMatches(currentHost[field], appliedHost[field])) continue;
+      if (Object.prototype.hasOwnProperty.call(baselineHost, field)) {
+        restored[field as string] = baselineHost[field];
+      } else {
+        delete restored[field as string];
+      }
+    }
+    return [restored as Host];
+  });
+}
+
+interface VaultImportPaintWaitOptions {
+  requestFrame?: (callback: () => void) => unknown;
+  setTimer?: (callback: () => void, delayMs: number) => unknown;
+  clearTimer?: (timer: unknown) => void;
+}
+
+export function waitForVaultImportProgressPaint({
+  requestFrame = typeof requestAnimationFrame === "function"
+    ? (callback) => requestAnimationFrame(callback)
+    : undefined,
+  setTimer = (callback, delayMs) => setTimeout(callback, delayMs),
+  clearTimer = (timer) => clearTimeout(timer as ReturnType<typeof setTimeout>),
+}: VaultImportPaintWaitOptions = {}): Promise<void> {
+  return new Promise((resolve) => {
+    let completed = false;
+    let timer: unknown;
+    const complete = () => {
+      if (completed) return;
+      completed = true;
+      if (timer !== undefined) clearTimer(timer);
+      resolve();
+    };
+
+    timer = setTimer(complete, 100);
+    requestFrame?.(complete);
+  });
+}
+import type { Host, ManagedSource } from "../../domain/models";