Privacy-first password manager with built-in email aliasing. Fully encrypted and self-hostable.
Add use hooks (#2413)
Leendert de Borst1637d2c3d446
diff --git a/apps/browser-extension/src/entrypoints/popup/hooks/usePasswordConfig.ts b/apps/browser-extension/src/entrypoints/popup/hooks/usePasswordConfig.tsindex 7dcf352d3..67724f928 100644--- a/apps/browser-extension/src/entrypoints/popup/hooks/usePasswordConfig.ts+++ b/apps/browser-extension/src/entrypoints/popup/hooks/usePasswordConfig.ts@@ -9,17 +9,11 @@ import type { PasswordSettings } from '@aliasvault/models/vault';* Value returned by {@link usePasswordConfig}.*/export interface IPasswordConfig {- /** The current password settings being edited. */settings: PasswordSettings;- /** The live preview password/passphrase for the current settings. */previewPassword: string;- /** The Diceware wordlist language codes available from the core. */dicewareLanguages: string[];- /** Update a single setting, regenerating the preview with the stable seed. */handleSettingChange: (key: keyof PasswordSettings, value: boolean | number | string) => void;- /** Draw a fresh seed and regenerate the preview (genuinely new password). */handleRefreshPreview: () => void;- /** Re-initialize from the given settings with a fresh seed (e.g. when a dialog reopens). */reset: (settings: PasswordSettings) => void;}diff --git a/apps/web/src/hooks/useEmailBody.ts b/apps/web/src/hooks/useEmailBody.tsnew file mode 100644index 000000000..e8e844b71--- /dev/null+++ b/apps/web/src/hooks/useEmailBody.ts@@ -0,0 +1,113 @@+import { sanitizeEmailHtml } from '@aliasvault/client/email/EmailHtmlSanitizer';+import { useCallback, useEffect, useRef, useState } from 'react';+import { useTranslation } from 'react-i18next';++import { type EmailViewModel, getSourceText, hasSource } from '@/utils/EmailViewModel';++/** The formats an email can be shown in. */+export type EmailViewMode = 'html' | 'plain' | 'source';++/**+ * HTML-escape text for a pre block.+ */+const escapeHtml = (text: string): string => text.replace(/&/g, '&').replace(/</g, '<').replace(/>/g, '>').replace(/"/g, '"').replace(/'/g, ''');++/**+ * The formats available for an email: html and plain when the source had those parts, source whenever there is one.+ */+export const getAvailableModes = (email: EmailViewModel | null): EmailViewMode[] => {+ const modes: EmailViewMode[] = [];+ if (email && email.htmlBody !== null && email.htmlBody.trim().length > 0) {+ modes.push('html');+ }+ if (email && email.textBody !== null) {+ modes.push('plain');+ }+ if (email && hasSource(email)) {+ modes.push('source');+ }+ return modes;+};++/**+ * The rendered body of an email in the chosen format, cycling through the available formats.+ * @param email - the email, null while it loads+ * @param onBodyLoading - called with true before a heavy sanitize pass and false after, for a skeleton+ */+export function useEmailBody(email: EmailViewModel | null, onBodyLoading?: (loading: boolean) => void): { emailBody: string; viewMode: EmailViewMode; availableModes: EmailViewMode[]; formatLabel: string; cycleViewMode: () => void } {+ const { t } = useTranslation();+ const [emailBody, setEmailBody] = useState('');+ const [viewMode, setViewMode] = useState<EmailViewMode>('html');+ const renderedEmailId = useRef<number | null>(null);+ const sequence = useRef(0);+ const noBody = t('components.main.email.emailModal.NoEmailBody');++ /**+ * Render the body in a format.+ */+ const applyViewMode = useCallback(async (target: EmailViewModel, mode: EmailViewMode): Promise<string> => {+ switch (mode) {+ case 'html':+ return target.htmlBody !== null && target.htmlBody.trim().length > 0 ? sanitizeEmailHtml(target.htmlBody) : noBody;+ case 'plain':+ return target.textBody !== null ? `<pre style='font-family: system-ui, -apple-system, sans-serif; white-space: pre-wrap; word-wrap: break-word; margin: 0;'>${escapeHtml(target.textBody)}</pre>` : noBody;+ case 'source': {+ const source = await getSourceText(target);+ return source.trim().length > 0 ? `<pre style='font-family: monospace; white-space: pre-wrap; word-wrap: break-word; margin: 0; font-size: 12px; line-height: 1.4;'>${escapeHtml(source)}</pre>` : noBody;+ }+ default:+ return noBody;+ }+ }, [noBody]);++ /*+ * Only (re)compute the body when the email actually changes.+ */+ useEffect(() => {+ if (email?.id === renderedEmailId.current && email !== null) {+ return;+ }+ renderedEmailId.current = email?.id ?? null;+ setEmailBody('');+ if (!email) {+ return;+ }++ const current = ++sequence.current;+ onBodyLoading?.(true);+ setTimeout(async () => {+ if (current !== sequence.current) {+ return;+ }+ const modes = getAvailableModes(email);+ const mode = modes[0] ?? 'html';+ const body = modes.length > 0 ? await applyViewMode(email, mode) : noBody;+ if (current !== sequence.current) {+ return;+ }+ setViewMode(mode);+ setEmailBody(body);+ onBodyLoading?.(false);+ }, 1);+ }, [applyViewMode, email, noBody, onBodyLoading]);++ const availableModes = getAvailableModes(email);++ /**+ * Switch to the next available format.+ */+ const cycleViewMode = useCallback((): void => {+ if (!email || availableModes.length <= 1) {+ return;+ }+ const next = availableModes[(availableModes.indexOf(viewMode) + 1) % availableModes.length];+ void applyViewMode(email, next).then((body) => {+ setViewMode(next);+ setEmailBody(body);+ });+ }, [applyViewMode, availableModes, email, viewMode]);++ const formatLabel = viewMode === 'html' ? t('sharedResources.EmailFormatHtml') : viewMode === 'plain' ? t('sharedResources.EmailFormatPlain') : t('sharedResources.EmailFormatSource');++ return { emailBody, viewMode, availableModes, formatLabel, cycleViewMode };+}diff --git a/apps/web/src/hooks/usePageTitle.ts b/apps/web/src/hooks/usePageTitle.tsnew file mode 100644index 000000000..04359ed94--- /dev/null+++ b/apps/web/src/hooks/usePageTitle.ts@@ -0,0 +1,11 @@+import { useEffect } from 'react';++/**+ * Set the document title in the "{title} - AliasVault" form.+ * @param title - the page title+ */+export function usePageTitle(title: string): void {+ useEffect(() => {+ document.title = `${title} - AliasVault`;+ }, [title]);+}diff --git a/apps/web/src/hooks/usePasswordConfig.ts b/apps/web/src/hooks/usePasswordConfig.tsnew file mode 100644index 000000000..53d6e5cb9--- /dev/null+++ b/apps/web/src/hooks/usePasswordConfig.ts@@ -0,0 +1,96 @@+import * as RustCore from '@aliasvault/client/rust/RustCore';+import { useState, useEffect, useCallback, useRef } from 'react';++import type { PasswordSettings } from '@aliasvault/models/vault';++/**+ * Value returned by {@link usePasswordConfig}.+ */+export interface IPasswordConfig {+ settings: PasswordSettings;+ previewPassword: string;+ dicewareLanguages: string[];+ handleSettingChange: (key: keyof PasswordSettings, value: boolean | number | string) => void;+ handleRefreshPreview: () => void;+ reset: (settings: PasswordSettings) => void;+}++/**+ * Shared state + preview logic for the password generator UI.+ *+ * @param initialSettings - The settings to start from.+ * @param onSettingsChange - Optional callback fired with the full settings on every change.+ * @returns The password config state and handlers.+ */+export function usePasswordConfig(+ initialSettings: PasswordSettings,+ onSettingsChange?: (settings: PasswordSettings) => void+): IPasswordConfig {+ const [settings, setSettings] = useState<PasswordSettings>(initialSettings);+ const [previewPassword, setPreviewPassword] = useState<string>('');+ const [dicewareLanguages, setDicewareLanguages] = useState<string[]>([]);+ const seedRef = useRef<string>('');++ const generatePreview = useCallback(async (currentSettings: PasswordSettings, currentSeed: string): Promise<void> => {+ try {+ const password = await RustCore.generatePassword(currentSettings, currentSeed);+ setPreviewPassword(password);+ } catch (error) {+ console.error('Error generating preview password:', error);+ setPreviewPassword('');+ }+ }, []);++ // Initialize the seed + preview once on mount.+ useEffect(() => {+ seedRef.current = RustCore.generateSeed();+ void generatePreview(initialSettings, seedRef.current);+ // eslint-disable-next-line react-hooks/exhaustive-deps+ }, []);++ // Load the available Diceware languages once.+ useEffect(() => {+ let cancelled = false;+ void RustCore.getDicewareLanguages().then((languages) => {+ if (!cancelled) {+ setDicewareLanguages(languages);+ }+ });+ return (): void => {+ cancelled = true;+ };+ }, []);++ const handleSettingChange = useCallback((key: keyof PasswordSettings, value: boolean | number | string) => {+ setSettings((prev): PasswordSettings => {+ const newSettings = { ...prev, [key]: value };+ // Reuse the stable seed so only the changed option affects the preview.+ void generatePreview(newSettings, seedRef.current);+ onSettingsChange?.(newSettings);+ return newSettings;+ });+ }, [generatePreview, onSettingsChange]);++ const handleRefreshPreview = useCallback(() => {+ seedRef.current = RustCore.generateSeed();+ setSettings((prev): PasswordSettings => {+ void generatePreview(prev, seedRef.current);+ return prev;+ });+ }, [generatePreview]);++ const reset = useCallback((newSettings: PasswordSettings) => {+ seedRef.current = RustCore.generateSeed();+ setSettings(newSettings);+ void generatePreview(newSettings, seedRef.current);+ }, [generatePreview]);++ return {+ settings,+ previewPassword,+ dicewareLanguages,+ handleSettingChange,+ handleRefreshPreview,+ reset+ };+}diff --git a/apps/web/src/hooks/useSaveItem.ts b/apps/web/src/hooks/useSaveItem.tsnew file mode 100644index 000000000..df809675a--- /dev/null+++ b/apps/web/src/hooks/useSaveItem.ts@@ -0,0 +1,64 @@+import { FaviconService } from '@aliasvault/client/items/FaviconService';+import { FieldKey } from '@aliasvault/models/vault';+import { useCallback } from 'react';++import { useDb } from '@/context/DbContext';+import { useWebApi } from '@/context/WebApiContext';+import { useVaultMutate } from '@/hooks/useVaultMutate';+import { type ItemEdit, itemEditToItem } from '@/models/ItemEdit';++import type { ItemRef } from '@aliasvault/client/database/ItemRef';++/**+ * How an item form is saved.+ */+export type SaveItemOptions = {+ original?: ItemRef;+ originalAttachmentIds?: string[];+ originalTotpCodeIds?: string[];+ deletePasskeys?: boolean;+};++/**+ * Save an item form to the vault and push it to the server.+ */+export function useSaveItem(): { saveItem: (edit: ItemEdit, options?: SaveItemOptions) => Promise<ItemRef> } {+ const dbContext = useDb();+ const webApi = useWebApi();+ const { executeVaultMutationAsync } = useVaultMutate();++ const saveItem = useCallback(async (edit: ItemEdit, options: SaveItemOptions = {}): Promise<ItemRef> => {+ const client = dbContext.sqliteClient;+ if (!client) {+ throw new Error('Vault is locked');+ }++ let item = itemEditToItem(edit);+ const urlValue = item.Fields.find(f => f.FieldKey === FieldKey.LoginUrl)?.Value;+ if (urlValue && urlValue.length > 0) {+ item = await FaviconService.fetchAndAttachFavicon(item, urlValue, client.logos, webApi);+ } else {+ item.Logo = undefined;+ }++ let saved: ItemRef = { Id: item.Id, ManifestId: item.ManifestId };+ await executeVaultMutationAsync(async () => {+ const original = options.original;+ if (original) {+ // A folder change can move the item to another manifest; the update reports where it ended up.+ saved = await client.items.update(original, item, options.originalAttachmentIds ?? [], edit.Attachments, options.originalTotpCodeIds ?? [], edit.TotpCodes) ?? original;+ if (options.deletePasskeys) {+ for (const passkey of edit.Passkeys) {+ await client.passkeys.deleteById(passkey.Id, saved.ManifestId);+ }+ }+ } else {+ saved = await client.items.create(item, edit.Attachments.filter(a => !a.IsDeleted), edit.TotpCodes.filter(c => !c.IsDeleted));+ }+ });++ return saved;+ }, [dbContext.sqliteClient, executeVaultMutationAsync, webApi]);++ return { saveItem };+}