Files
Netcatty/application/state/usePortForwardingState.ts
T
LAPTOP-O016UC3M\Qi Chen 1d1c509cbb Persists view mode selection across app sections
Introduces persistent view mode storage for hosts, keys, snippets,
known hosts, and port forwarding by using dedicated storage keys
and a reusable view mode hook. Improves user experience by
remembering individual section preferences instead of defaulting
to "grid" on each visit.
2025-12-19 16:23:52 +08:00

294 lines
8.0 KiB
TypeScript

import { useCallback, useEffect, useMemo, useState } from "react";
import { Host, PortForwardingRule } from "../../domain/models";
import {
STORAGE_KEY_PF_PREFER_FORM_MODE,
STORAGE_KEY_PF_VIEW_MODE,
STORAGE_KEY_PORT_FORWARDING,
} from "../../infrastructure/config/storageKeys";
import { localStorageAdapter } from "../../infrastructure/persistence/localStorageAdapter";
import {
getActiveConnection,
getActiveRuleIds,
startPortForward,
stopPortForward,
} from "../../infrastructure/services/portForwardingService";
import { useStoredViewMode, ViewMode } from "./useStoredViewMode";
export type { ViewMode };
export type SortMode = "az" | "za" | "newest" | "oldest";
export interface UsePortForwardingStateResult {
rules: PortForwardingRule[];
selectedRuleId: string | null;
viewMode: ViewMode;
sortMode: SortMode;
search: string;
preferFormMode: boolean;
setSelectedRuleId: (id: string | null) => void;
setViewMode: (mode: ViewMode) => void;
setSortMode: (mode: SortMode) => void;
setSearch: (query: string) => void;
setPreferFormMode: (prefer: boolean) => void;
addRule: (
rule: Omit<PortForwardingRule, "id" | "createdAt" | "status">,
) => PortForwardingRule;
updateRule: (id: string, updates: Partial<PortForwardingRule>) => void;
deleteRule: (id: string) => void;
duplicateRule: (id: string) => void;
setRuleStatus: (
id: string,
status: PortForwardingRule["status"],
error?: string,
) => void;
startTunnel: (
rule: PortForwardingRule,
host: Host,
keys: { id: string; privateKey: string }[],
onStatusChange?: (status: PortForwardingRule["status"], error?: string) => void,
) => Promise<{ success: boolean; error?: string }>;
stopTunnel: (
ruleId: string,
onStatusChange?: (status: PortForwardingRule["status"]) => void,
) => Promise<{ success: boolean; error?: string }>;
filteredRules: PortForwardingRule[];
selectedRule: PortForwardingRule | undefined;
}
export const usePortForwardingState = (): UsePortForwardingStateResult => {
const [rules, setRules] = useState<PortForwardingRule[]>([]);
const [selectedRuleId, setSelectedRuleId] = useState<string | null>(null);
const [viewMode, setViewMode] = useStoredViewMode(
STORAGE_KEY_PF_VIEW_MODE,
"grid",
);
const [sortMode, setSortMode] = useState<SortMode>("newest");
const [search, setSearch] = useState("");
const [preferFormMode, setPreferFormModeState] = useState<boolean>(() => {
return localStorageAdapter.readBoolean(STORAGE_KEY_PF_PREFER_FORM_MODE) ?? false;
});
const setPreferFormMode = useCallback((prefer: boolean) => {
setPreferFormModeState(prefer);
localStorageAdapter.writeBoolean(STORAGE_KEY_PF_PREFER_FORM_MODE, prefer);
}, []);
// Load rules from storage on mount
useEffect(() => {
const saved = localStorageAdapter.read<PortForwardingRule[]>(
STORAGE_KEY_PORT_FORWARDING,
);
if (saved && Array.isArray(saved)) {
// Sync status with active connections in the service layer
const _activeRuleIds = getActiveRuleIds();
const withSyncedStatus = saved.map((r) => {
const conn = getActiveConnection(r.id);
if (conn) {
// This rule has an active connection, preserve its status
return { ...r, status: conn.status, error: conn.error };
}
// No active connection, reset to inactive
return { ...r, status: "inactive" as const, error: undefined };
});
setRules(withSyncedStatus);
}
}, []);
// Persist rules to storage whenever they change
const persistRules = useCallback((updatedRules: PortForwardingRule[]) => {
localStorageAdapter.write(STORAGE_KEY_PORT_FORWARDING, updatedRules);
}, []);
const addRule = useCallback(
(
rule: Omit<PortForwardingRule, "id" | "createdAt" | "status">,
): PortForwardingRule => {
const newRule: PortForwardingRule = {
...rule,
id: crypto.randomUUID(),
createdAt: Date.now(),
status: "inactive",
};
setRules((prev) => {
const updated = [...prev, newRule];
persistRules(updated);
return updated;
});
setSelectedRuleId(newRule.id);
return newRule;
},
[persistRules],
);
const updateRule = useCallback(
(id: string, updates: Partial<PortForwardingRule>) => {
setRules((prev) => {
const updated = prev.map((r) =>
r.id === id ? { ...r, ...updates } : r,
);
persistRules(updated);
return updated;
});
},
[persistRules],
);
const deleteRule = useCallback(
(id: string) => {
setRules((prev) => {
const updated = prev.filter((r) => r.id !== id);
persistRules(updated);
return updated;
});
if (selectedRuleId === id) {
setSelectedRuleId(null);
}
},
[selectedRuleId, persistRules],
);
const duplicateRule = useCallback(
(id: string) => {
const original = rules.find((r) => r.id === id);
if (!original) return;
const copy: PortForwardingRule = {
...original,
id: crypto.randomUUID(),
label: `${original.label} (Copy)`,
createdAt: Date.now(),
status: "inactive",
error: undefined,
lastUsedAt: undefined,
};
setRules((prev) => {
const updated = [...prev, copy];
persistRules(updated);
return updated;
});
setSelectedRuleId(copy.id);
},
[rules, persistRules],
);
const setRuleStatus = useCallback(
(id: string, status: PortForwardingRule["status"], error?: string) => {
setRules((prev) => {
const updated = prev.map((r) => {
if (r.id !== id) return r;
return {
...r,
status,
error,
lastUsedAt: status === "active" ? Date.now() : r.lastUsedAt,
};
});
persistRules(updated);
return updated;
});
},
[persistRules],
);
const startTunnel = useCallback(
async (
rule: PortForwardingRule,
host: Host,
keys: { id: string; privateKey: string }[],
onStatusChange?: (
status: PortForwardingRule["status"],
error?: string,
) => void,
) => {
return startPortForward(rule, host, keys, (status, error) => {
setRuleStatus(rule.id, status, error);
onStatusChange?.(status, error ?? undefined);
});
},
[setRuleStatus],
);
const stopTunnel = useCallback(
async (
ruleId: string,
onStatusChange?: (status: PortForwardingRule["status"]) => void,
) => {
return stopPortForward(ruleId, (status) => {
setRuleStatus(ruleId, status);
onStatusChange?.(status);
});
},
[setRuleStatus],
);
// Filter and sort rules
const filteredRules = useMemo(() => {
let result = [...rules];
// Filter by search
if (search.trim()) {
const s = search.toLowerCase();
result = result.filter(
(r) =>
r.label.toLowerCase().includes(s) ||
r.type.toLowerCase().includes(s) ||
r.localPort.toString().includes(s) ||
r.remoteHost?.toLowerCase().includes(s) ||
r.remotePort?.toString().includes(s),
);
}
// Sort
switch (sortMode) {
case "az":
result.sort((a, b) => a.label.localeCompare(b.label));
break;
case "za":
result.sort((a, b) => b.label.localeCompare(a.label));
break;
case "newest":
result.sort((a, b) => b.createdAt - a.createdAt);
break;
case "oldest":
result.sort((a, b) => a.createdAt - b.createdAt);
break;
}
return result;
}, [rules, search, sortMode]);
const selectedRule = rules.find((r) => r.id === selectedRuleId);
return {
rules,
selectedRuleId,
viewMode,
sortMode,
search,
preferFormMode,
setSelectedRuleId,
setViewMode,
setSortMode,
setSearch,
setPreferFormMode,
addRule,
updateRule,
deleteRule,
duplicateRule,
setRuleStatus,
startTunnel,
stopTunnel,
filteredRules,
selectedRule,
};
};