Skip to content

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.ts
index 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.ts
new file mode 100644
index 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, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&#39;');
+
+/**
+ * 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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 };
+}