Skip to content

Privacy-first password manager with built-in email aliasing. Fully encrypted and self-hostable.

Refactor ItemAddEdit.tsx (#1404)

Leendert de Borst7e13be17297b
diff --git a/apps/browser-extension/src/entrypoints/popup/components/Forms/EmailDomainField.tsx b/apps/browser-extension/src/entrypoints/popup/components/Forms/EmailDomainField.tsx
index 8da549038..faca52ee0 100644
--- a/apps/browser-extension/src/entrypoints/popup/components/Forms/EmailDomainField.tsx
+++ b/apps/browser-extension/src/entrypoints/popup/components/Forms/EmailDomainField.tsx
@@ -24,6 +24,16 @@ type EmailDomainFieldProps = {
* clicking "Generate alias email" will call this instead of just toggling mode.
*/
onGenerateAlias?: () => void;
+ /**
+ * Controlled mode: when provided, this controls whether the field is in "email" (free text) mode.
+ * When true, shows free text input; when false, shows domain chooser.
+ * Use with onEmailModeChange for full controlled behavior.
+ */
+ isEmailMode?: boolean;
+ /**
+ * Callback when the email/alias mode changes. Required when using controlled mode (isEmailMode prop).
+ */
+ onEmailModeChange?: (isEmailMode: boolean) => void;
}
/**
@@ -39,11 +49,31 @@ const EmailDomainField: React.FC<EmailDomainFieldProps> = ({
required = false,
defaultToFreeText = false,
onRemove,
- onGenerateAlias
+ onGenerateAlias,
+ isEmailMode,
+ onEmailModeChange
}) => {
const { t } = useTranslation();
const dbContext = useDb();
- const [isCustomDomain, setIsCustomDomain] = useState(defaultToFreeText);
+
+ // Support both controlled and uncontrolled modes
+ const isControlled = isEmailMode !== undefined;
+ const [internalIsCustomDomain, setInternalIsCustomDomain] = useState(defaultToFreeText);
+
+ // Use controlled value if provided, otherwise use internal state
+ const isCustomDomain = isControlled ? isEmailMode : internalIsCustomDomain;
+
+ /**
+ * Update the isCustomDomain state, supporting both controlled and uncontrolled modes.
+ */
+ const setIsCustomDomain = useCallback((newValue: boolean | ((prev: boolean) => boolean)) => {
+ const resolvedValue = typeof newValue === 'function' ? newValue(isCustomDomain) : newValue;
+ if (isControlled && onEmailModeChange) {
+ onEmailModeChange(resolvedValue);
+ } else {
+ setInternalIsCustomDomain(resolvedValue);
+ }
+ }, [isControlled, onEmailModeChange, isCustomDomain]);
const [localPart, setLocalPart] = useState('');
const [selectedDomain, setSelectedDomain] = useState('');
const [isPopupVisible, setIsPopupVisible] = useState(false);
@@ -93,12 +123,18 @@ const EmailDomainField: React.FC<EmailDomainFieldProps> = ({
setLocalPart(local);
setSelectedDomain(domain);
- // Check if it's a known domain (public, private, or hidden private)
- const isKnownDomain = publicEmailDomains.includes(domain) ||
- privateEmailDomains.includes(domain) ||
- hiddenPrivateEmailDomains.includes(domain);
- // Switch to domain chooser mode if domain is recognized
- setIsCustomDomain(!isKnownDomain);
+ /*
+ * Only auto-switch modes in uncontrolled mode.
+ * In controlled mode, the parent manages the mode state.
+ */
+ if (!isControlled) {
+ // Check if it's a known domain (public, private, or hidden private)
+ const isKnownDomain = publicEmailDomains.includes(domain) ||
+ privateEmailDomains.includes(domain) ||
+ hiddenPrivateEmailDomains.includes(domain);
+ // Switch to domain chooser mode if domain is recognized
+ setIsCustomDomain(!isKnownDomain);
+ }
} else {
setLocalPart(value);
// Don't reset isCustomDomain here - preserve the current mode
@@ -113,13 +149,19 @@ const EmailDomainField: React.FC<EmailDomainFieldProps> = ({
}
}
// eslint-disable-next-line react-hooks/exhaustive-deps
- }, [value, privateEmailDomains, hiddenPrivateEmailDomains, showPrivateDomains]);
+ }, [value, privateEmailDomains, hiddenPrivateEmailDomains, showPrivateDomains, isControlled]);
/*
* Re-check domain mode when private domains finish loading.
* This handles the case where value was set before domains were loaded.
+ * Only applies in uncontrolled mode - in controlled mode, parent manages the state.
*/
useEffect(() => {
+ // Skip auto-correction in controlled mode
+ if (isControlled) {
+ return;
+ }
+
if (!value || !value.includes('@')) {
return;
}
@@ -138,7 +180,7 @@ const EmailDomainField: React.FC<EmailDomainFieldProps> = ({
if (isKnownDomain && isCustomDomain) {
setIsCustomDomain(false);
}
- }, [publicEmailDomains, privateEmailDomains, hiddenPrivateEmailDomains, value, isCustomDomain]);
+ }, [publicEmailDomains, privateEmailDomains, hiddenPrivateEmailDomains, value, isCustomDomain, isControlled, setIsCustomDomain]);
// Handle local part changes
const handleLocalPartChange = useCallback((e: React.ChangeEvent<HTMLInputElement>) => {
@@ -165,7 +207,7 @@ const EmailDomainField: React.FC<EmailDomainFieldProps> = ({
} else if (selectedDomain) {
onChange(`${newLocalPart}@${selectedDomain}`);
}
- }, [isCustomDomain, selectedDomain, onChange]);
+ }, [isCustomDomain, selectedDomain, onChange, setIsCustomDomain]);
// Select a domain from the popup
const selectDomain = useCallback((domain: string) => {
@@ -179,7 +221,7 @@ const EmailDomainField: React.FC<EmailDomainFieldProps> = ({
}
setIsCustomDomain(false);
setIsPopupVisible(false);
- }, [localPart, onChange]);
+ }, [localPart, onChange, setIsCustomDomain]);
// Toggle between custom domain and domain chooser
const toggleCustomDomain = useCallback(() => {
@@ -216,7 +258,7 @@ const EmailDomainField: React.FC<EmailDomainFieldProps> = ({
onChange(`${value}@${defaultDomain}`);
}
}
- }, [isCustomDomain, value, localPart, showPrivateDomains, publicEmailDomains, privateEmailDomains, onChange, defaultToFreeText]);
+ }, [isCustomDomain, value, localPart, showPrivateDomains, publicEmailDomains, privateEmailDomains, onChange, defaultToFreeText, setIsCustomDomain]);
// Handle clicks outside the popup
useEffect(() => {
@@ -247,7 +289,7 @@ const EmailDomainField: React.FC<EmailDomainFieldProps> = ({
}
// Always switch to domain chooser mode
setIsCustomDomain(false);
- }, [onGenerateAlias]);
+ }, [onGenerateAlias, setIsCustomDomain]);
return (
<div className="space-y-2">
@@ -315,7 +357,6 @@ const EmailDomainField: React.FC<EmailDomainFieldProps> = ({
} focus:ring-primary-500 focus:border-primary-500 dark:bg-gray-700 dark:text-white`}
value={isCustomDomain ? value : localPart}
onChange={handleLocalPartChange}
- placeholder={isCustomDomain ? t('credentials.enterEmailAddress') : t('credentials.enterEmailPrefix')}
/>
{!isCustomDomain && (
diff --git a/apps/browser-extension/src/entrypoints/popup/hooks/useFormPersistence.ts b/apps/browser-extension/src/entrypoints/popup/hooks/useFormPersistence.ts
new file mode 100644
index 000000000..002c7d77e
--- /dev/null
+++ b/apps/browser-extension/src/entrypoints/popup/hooks/useFormPersistence.ts
@@ -0,0 +1,192 @@
+import { useCallback, useEffect, useRef } from 'react';
+import { sendMessage } from 'webext-bridge/popup';
+
+/**
+ * Generic form persistence hook for saving and restoring form state.
+ *
+ * Persists form data to the background script (encrypted storage) and automatically:
+ * - Saves state whenever dependencies change
+ * - Clears persisted state when the component unmounts
+ *
+ * The form data type is generic, allowing this hook to be reused across different forms.
+ *
+ * @template T - The type of form data to persist
+ */
+type UseFormPersistenceOptions<T> = {
+ /**
+ * Unique identifier for the form instance (e.g., item ID or null for new items).
+ * Used to verify we're restoring data for the correct form.
+ */
+ formId: string | null;
+
+ /**
+ * Whether the form is still loading initial data.
+ * Persistence is disabled while loading to avoid overwriting restored state.
+ */
+ isLoading: boolean;
+
+ /**
+ * The current form data to persist.
+ */
+ formData: T;
+
+ /**
+ * Callback to restore form data when loaded from storage.
+ */
+ onRestore: (data: T) => void;
+
+ /**
+ * Whether to skip restoration on mount (e.g., when opening from popout button).
+ * If true, loadPersistedValues() returns false immediately without loading.
+ */
+ skipRestore?: boolean;
+};
+
+type UseFormPersistenceReturn = {
+ /**
+ * Manually load persisted values from storage.
+ * Returns true if data was restored, false otherwise.
+ */
+ loadPersistedValues: () => Promise<boolean>;
+
+ /**
+ * Manually clear persisted values from storage.
+ */
+ clearPersistedValues: () => Promise<void>;
+
+ /**
+ * Manually persist current values to storage.
+ * Usually not needed as auto-persistence handles this.
+ */
+ persistFormValues: () => Promise<void>;
+};
+
+/**
+ * Persisted data wrapper that includes form ID for validation.
+ */
+type PersistedDataWrapper<T> = {
+ formId: string | null;
+ data: T;
+};
+
+/**
+ * Hook for persisting form state to encrypted background storage.
+ *
+ * @example
+ * ```tsx
+ * const { loadPersistedValues, clearPersistedValues } = useFormPersistence({
+ * formId: id || null,
+ * isLoading: localLoading,
+ * formData: { item, fieldValues, customFields },
+ * onRestore: (data) => {
+ * setItem(data.item);
+ * setFieldValues(data.fieldValues);
+ * setCustomFields(data.customFields);
+ * },
+ * });
+ * ```
+ */
+const useFormPersistence = <T>({
+ formId,
+ isLoading,
+ formData,
+ onRestore,
+ skipRestore = false,
+}: UseFormPersistenceOptions<T>): UseFormPersistenceReturn => {
+ // Track if we've already restored to avoid duplicate restores
+ const hasRestored = useRef(false);
+
+ /**
+ * Persist the current form values to encrypted storage.
+ */
+ const persistFormValues = useCallback(async (): Promise<void> => {
+ if (isLoading) {
+ // Do not persist values if the form is still loading
+ return;
+ }
+
+ const persistedData: PersistedDataWrapper<T> = {
+ formId,
+ data: formData,
+ };
+
+ await sendMessage('PERSIST_FORM_VALUES', JSON.stringify(persistedData), 'background');
+ }, [formId, formData, isLoading]);
+
+ /**
+ * Load persisted form values from storage.
+ * Returns true if data was successfully restored, false otherwise.
+ */
+ const loadPersistedValues = useCallback(async (): Promise<boolean> => {
+ if (skipRestore) {
+ return false;
+ }
+
+ if (hasRestored.current) {
+ return false;
+ }
+
+ const persistedData = await sendMessage('GET_PERSISTED_FORM_VALUES', null, 'background') as string | null;
+
+ try {
+ if (!persistedData) {
+ return false;
+ }
+
+ let wrapper: PersistedDataWrapper<T> | null = null;
+ try {
+ wrapper = JSON.parse(persistedData) as PersistedDataWrapper<T>;
+ } catch (error) {
+ console.error('Error parsing persisted form data:', error);
+ return false;
+ }
+
+ // Verify this is data for the current form
+ const isCurrentForm = wrapper.formId === formId;
+ if (!isCurrentForm) {
+ return false;
+ }
+
+ hasRestored.current = true;
+ onRestore(wrapper.data);
+ return true;
+ } catch (error) {
+ console.error('Error loading persisted form data:', error);
+ return false;
+ }
+ }, [formId, onRestore, skipRestore]);
+
+ /**
+ * Clear persisted form values from storage.
+ */
+ const clearPersistedValues = useCallback(async (): Promise<void> => {
+ await sendMessage('CLEAR_PERSISTED_FORM_VALUES', null, 'background');
+ }, []);
+
+ /**
+ * Auto-persist when form data changes (after initial load).
+ */
+ useEffect(() => {
+ if (!isLoading) {
+ void persistFormValues();
+ }
+ }, [isLoading, persistFormValues]);
+
+ /**
+ * Clear persisted values when component unmounts.
+ */
+ useEffect(() => {
+ return (): void => {
+ void clearPersistedValues();
+ };
+ }, [clearPersistedValues]);
+
+ return {
+ loadPersistedValues,
+ clearPersistedValues,
+ persistFormValues,
+ };
+};
+
+export default useFormPersistence;
+export type { UseFormPersistenceOptions, UseFormPersistenceReturn, PersistedDataWrapper };
diff --git a/apps/browser-extension/src/entrypoints/popup/hooks/useServiceDetection.ts b/apps/browser-extension/src/entrypoints/popup/hooks/useServiceDetection.ts
new file mode 100644
index 000000000..806f76410
--- /dev/null
+++ b/apps/browser-extension/src/entrypoints/popup/hooks/useServiceDetection.ts
@@ -0,0 +1,115 @@
+import { useCallback } from 'react';
+import { useSearchParams } from 'react-router-dom';
+
+import { ServiceDetectionUtility, type ServiceInfo } from '@/utils/serviceDetection/ServiceDetectionUtility';
+
+import { browser } from '#imports';
+
+/**
+ * Result of service detection containing name and URL.
+ */
+type ServiceDetectionResult = {
+ /** Detected service name (e.g., "GitHub", "Google") */
+ serviceName: string;
+ /** Detected service URL (origin + pathname) */
+ serviceUrl: string;
+};
+
+/**
+ * Hook for detecting service information from URL parameters or the active browser tab.
+ *
+ * Service detection sources (in priority order):
+ * 1. URL parameters (serviceName, serviceUrl, currentUrl) - e.g., from content script popout
+ * 2. Active browser tab - for dashboard/popup opened directly
+ *
+ * @example
+ * ```tsx
+ * const { detectService } = useServiceDetection();
+ *
+ * useEffect(() => {
+ * const init = async () => {
+ * const { serviceName, serviceUrl } = await detectService(itemNameParam);
+ * setItem({ ...item, Name: serviceName });
+ * setFieldValues(prev => ({ ...prev, 'login.url': serviceUrl }));
+ * };
+ * init();
+ * }, []);
+ * ```
+ */
+const useServiceDetection = (): {
+ detectService: (fallbackName?: string | null) => Promise<ServiceDetectionResult>;
+} => {
+ const [searchParams] = useSearchParams();
+
+ /**
+ * Detect service information from URL parameters or active tab.
+ *
+ * @param fallbackName - Optional fallback name if detection fails (e.g., from URL param)
+ * @returns Promise resolving to detected service name and URL
+ */
+ const detectService = useCallback(async (fallbackName?: string | null): Promise<ServiceDetectionResult> => {
+ let detectedName = fallbackName || '';
+ let detectedUrl = '';
+
+ try {
+ // Get URL parameters (e.g., from content script popout)
+ const serviceNameFromUrl = searchParams.get('serviceName');
+ const serviceUrlFromUrl = searchParams.get('serviceUrl');
+ const currentUrl = searchParams.get('currentUrl');
+
+ // If URL parameters are present, use them
+ if (serviceNameFromUrl || serviceUrlFromUrl || currentUrl) {
+ if (serviceNameFromUrl) {
+ detectedName = decodeURIComponent(serviceNameFromUrl);
+ }
+ if (serviceUrlFromUrl) {
+ detectedUrl = decodeURIComponent(serviceUrlFromUrl);
+ }
+
+ // If we have currentUrl but missing serviceName or serviceUrl, derive them
+ if (currentUrl && (!serviceNameFromUrl || !serviceUrlFromUrl)) {
+ const decodedCurrentUrl = decodeURIComponent(currentUrl);
+ const serviceInfo: ServiceInfo = ServiceDetectionUtility.getServiceInfoFromTab(decodedCurrentUrl);
+
+ if (!serviceNameFromUrl && serviceInfo.suggestedNames.length > 0) {
+ detectedName = serviceInfo.suggestedNames[0];
+ }
+ if (!serviceUrlFromUrl && serviceInfo.serviceUrl) {
+ detectedUrl = serviceInfo.serviceUrl;
+ }
+ }
+ } else {
+ // No URL parameters - detect from current active tab (dashboard case)
+ const [activeTab] = await browser.tabs.query({ active: true, currentWindow: true });
+
+ if (activeTab?.url) {
+ const serviceInfo: ServiceInfo = ServiceDetectionUtility.getServiceInfoFromTab(
+ activeTab.url,
+ activeTab.title
+ );
+
+ if (serviceInfo.suggestedNames.length > 0 && !detectedName) {
+ detectedName = serviceInfo.suggestedNames[0];
+ }
+ if (serviceInfo.serviceUrl) {
+ detectedUrl = serviceInfo.serviceUrl;
+ }
+ }
+ }
+ } catch (error) {
+ console.error('Error detecting service information:', error);
+ }
+
+ return {
+ serviceName: detectedName,
+ serviceUrl: detectedUrl,
+ };
+ }, [searchParams]);
+
+ return {
+ detectService,
+ };
+};
+
+export default useServiceDetection;
+export type { ServiceDetectionResult };
diff --git a/apps/browser-extension/src/entrypoints/popup/pages/credentials/ItemAddEdit.tsx b/apps/browser-extension/src/entrypoints/popup/pages/credentials/ItemAddEdit.tsx
index 3b700677b..06dc23c38 100644
--- a/apps/browser-extension/src/entrypoints/popup/pages/credentials/ItemAddEdit.tsx
+++ b/apps/browser-extension/src/entrypoints/popup/pages/credentials/ItemAddEdit.tsx
@@ -1,7 +1,6 @@
import React, { useState, useEffect, useCallback, useMemo, useRef } from 'react';
import { useTranslation } from 'react-i18next';
import { useNavigate, useParams, useSearchParams } from 'react-router-dom';
-import { sendMessage } from 'webext-bridge/popup';
import AttachmentUploader from '@/entrypoints/popup/components/Credentials/Details/AttachmentUploader';
import PasskeyEditor from '@/entrypoints/popup/components/Credentials/Details/PasskeyEditor';
@@ -25,13 +24,14 @@ import { useHeaderButtons } from '@/entrypoints/popup/context/HeaderButtonsConte
import { useLoading } from '@/entrypoints/popup/context/LoadingContext';
import { useWebApi } from '@/entrypoints/popup/context/WebApiContext';
import useAliasGenerator from '@/entrypoints/popup/hooks/useAliasGenerator';
+import useFormPersistence from '@/entrypoints/popup/hooks/useFormPersistence';
+import useServiceDetection from '@/entrypoints/popup/hooks/useServiceDetection';
import { useVaultMutate } from '@/entrypoints/popup/hooks/useVaultMutate';
import { SKIP_FORM_RESTORE_KEY } from '@/utils/Constants';
import type { Item, ItemField, ItemType, FieldType, Attachment, TotpCode } from '@/utils/dist/core/models/vault';
import { FieldCategories, FieldTypes, ItemTypes, getSystemFieldsForItemType, isFieldShownByDefault } from '@/utils/dist/core/models/vault';
import { FaviconService } from '@/utils/FaviconService';
-import { ServiceDetectionUtility } from '@/utils/serviceDetection/ServiceDetectionUtility';
import { browser } from '#imports';
@@ -54,9 +54,9 @@ type CustomFieldDefinition = {
/**
* Persisted form data type used for JSON serialization.
+ * This is the data portion stored via useFormPersistence hook.
*/
type PersistedFormData = {
- itemId: string | null;
item: Item | null;
fieldValues: Record<string, string | string[]>;
customFields: CustomFieldDefinition[];
@@ -71,6 +71,11 @@ type PersistedFormData = {
show2FA: boolean;
showAttachments: boolean;
manuallyAddedFields: string[];
+ /**
+ * Whether the login.email field is in "email" (free text) mode vs "alias" (domain chooser) mode.
+ * Only applicable for Login item type where defaultToFreeText is true.
+ */
+ isLoginEmailInEmailMode?: boolean;
};
/**
@@ -93,6 +98,7 @@ const ItemAddEdit: React.FC = () => {
const { setHeaderButtons } = useHeaderButtons();
const { setIsInitialLoading } = useLoading();
const { generateAlias, lastGeneratedValues } = useAliasGenerator();
+ const { detectService } = useServiceDetection();
const webApi = useWebApi();
// Component state
@@ -148,6 +154,66 @@ const ItemAddEdit: React.FC = () => {
// Passkeys state (only IDs marked for deletion - passkeys cannot be created/edited manually)
const [passkeyIdsMarkedForDeletion, setPasskeyIdsMarkedForDeletion] = useState<string[]>([]);
+ // Track email field mode for Login type (true = free text "Email", false = domain chooser "Alias")
+ const [isLoginEmailInEmailMode, setIsLoginEmailInEmailMode] = useState(true);
+
+ // Track whether to skip form restoration (set during initialization)
+ const [skipFormRestore] = useState(false);
+
+ /**
+ * Form persistence hook - handles saving/restoring form state to encrypted storage.
+ * The hook auto-persists on state changes and clears on unmount.
+ */
+ const { loadPersistedValues, clearPersistedValues } = useFormPersistence<PersistedFormData>({
+ formId: id || null,
+ isLoading: localLoading,
+ formData: {
+ item,
+ fieldValues,
+ customFields,
+ totpEditorState,
+ showNotes,
+ show2FA,
+ showAttachments,
+ manuallyAddedFields: Array.from(manuallyAddedFields),
+ isLoginEmailInEmailMode,
+ },
+ /**
+ * Restore form state from persisted data.
+ * @param data - The persisted form data to restore
+ */
+ onRestore: (data) => {
+ if (data.item) {
+ setItem(data.item);
+ }
+ if (data.fieldValues) {
+ setFieldValues(data.fieldValues);
+ }
+ if (data.customFields) {
+ setCustomFields(data.customFields);
+ }
+ if (data.totpEditorState) {
+ setTotpEditorState(data.totpEditorState);
+ }
+ if (data.showNotes !== undefined) {
+ setShowNotes(data.showNotes);
+ }
+ if (data.show2FA !== undefined) {
+ setShow2FA(data.show2FA);
+ }
+ if (data.showAttachments !== undefined) {
+ setShowAttachments(data.showAttachments);
+ }
+ if (data.manuallyAddedFields) {
+ setManuallyAddedFields(new Set(data.manuallyAddedFields));
+ }
+ if (data.isLoginEmailInEmailMode !== undefined) {
+ setIsLoginEmailInEmailMode(data.isLoginEmailInEmailMode);
+ }
+ },
+ skipRestore: skipFormRestore,
+ });
+
/**
* Get all applicable system fields for the current item type.
*/
@@ -221,115 +287,6 @@ const ItemAddEdit: React.FC = () => {
return groups;
}, [applicableSystemFields]);
- /**
- * Persists the current form values to storage.
- * @returns Promise that resolves when the form values are persisted
- */
- const persistFormValues = useCallback(async (): Promise<void> => {
- if (localLoading) {
- // Do not persist values if the page is still loading.
- return;
- }
-
- const persistedData: PersistedFormData = {
- itemId: id || null,
- item,
- fieldValues,
- customFields,
- totpEditorState,
- showNotes,
- show2FA,
- showAttachments,
- manuallyAddedFields: Array.from(manuallyAddedFields)
- };
- await sendMessage('PERSIST_FORM_VALUES', JSON.stringify(persistedData), 'background');
- }, [id, item, fieldValues, customFields, totpEditorState, showNotes, show2FA, showAttachments, manuallyAddedFields, localLoading]);
-
- /**
- * Loads persisted form values from storage.
- * @returns Promise that resolves when the form values are loaded
- */
- const loadPersistedValues = useCallback(async (): Promise<void> => {
- const persistedData = await sendMessage('GET_PERSISTED_FORM_VALUES', null, 'background') as string | null;
-
- try {
- let persistedDataObject: PersistedFormData | null = null;
- try {
- if (persistedData) {
- persistedDataObject = JSON.parse(persistedData) as PersistedFormData;
- }
- } catch (error) {
- console.error('Error parsing persisted data:', error);
- }
-
- if (!persistedDataObject) {
- return;
- }
-
- const isCurrentPage = persistedDataObject.itemId === (id || null);
- if (persistedDataObject && isCurrentPage) {
- // Restore item state
- if (persistedDataObject.item) {
- setItem(persistedDataObject.item);
- }
- // Restore field values
- if (persistedDataObject.fieldValues) {
- setFieldValues(persistedDataObject.fieldValues);
- }
- // Restore custom fields
- if (persistedDataObject.customFields) {
- setCustomFields(persistedDataObject.customFields);
- }
- // Restore TOTP editor state
- if (persistedDataObject.totpEditorState) {
- setTotpEditorState(persistedDataObject.totpEditorState);
- }
- // Restore visibility states
- if (persistedDataObject.showNotes !== undefined) {
- setShowNotes(persistedDataObject.showNotes);
- }
- if (persistedDataObject.show2FA !== undefined) {
- setShow2FA(persistedDataObject.show2FA);
- }
- if (persistedDataObject.showAttachments !== undefined) {
- setShowAttachments(persistedDataObject.showAttachments);
- }
- // Restore manually added fields
- if (persistedDataObject.manuallyAddedFields) {
- setManuallyAddedFields(new Set(persistedDataObject.manuallyAddedFields));
- }
- }
- } catch (error) {
- console.error('Error loading persisted data:', error);
- }
- }, [id]);
-
- /**
- * Clears persisted form values from storage.
- * @returns Promise that resolves when the form values are cleared
- */
- const clearPersistedValues = useCallback(async (): Promise<void> => {
- await sendMessage('CLEAR_PERSISTED_FORM_VALUES', null, 'background');
- }, []);
-
- /**
- * Watch for form changes and persist them.
- */
- useEffect(() => {
- if (!localLoading) {
- void persistFormValues();
- }
- }, [item, fieldValues, customFields, totpEditorState, showNotes, show2FA, showAttachments, manuallyAddedFields, persistFormValues, localLoading]);
-
- /**
- * Clear persisted values when the page is unmounted.
- */
- useEffect(() => {
- return (): void => {
- void clearPersistedValues();
- };
- }, [clearPersistedValues]);
-
/**
* Load item data if in edit mode, or initialize for create mode with service detection.
*/
@@ -340,69 +297,17 @@ const ItemAddEdit: React.FC = () => {
? itemTypeParam
: DEFAULT_ITEM_TYPE;
- /*
- * Get URL parameters for service detection (e.g., from content script popout)
- * Use searchParams from react-router which handles hash-based routing correctly
- */
- const serviceNameFromUrl = searchParams.get('serviceName');
- const serviceUrlFromUrl = searchParams.get('serviceUrl');
- const currentUrl = searchParams.get('currentUrl');
-
/**
- * Initialize service detection from URL parameters or current tab.
+ * Initialize create mode with service detection from URL params or active tab.
*/
- const initializeWithServiceDetection = async (): Promise<void> => {
- let detectedName = itemNameParam || '';
- let detectedUrl = '';
-
- try {
- // If URL parameters are present (e.g., from content script popout), use them
- if (serviceNameFromUrl || serviceUrlFromUrl || currentUrl) {
- if (serviceNameFromUrl) {
- detectedName = decodeURIComponent(serviceNameFromUrl);
- }
- if (serviceUrlFromUrl) {
- detectedUrl = decodeURIComponent(serviceUrlFromUrl);
- }
-
- // If we have currentUrl but missing serviceName or serviceUrl, derive them
- if (currentUrl && (!serviceNameFromUrl || !serviceUrlFromUrl)) {
- const decodedCurrentUrl = decodeURIComponent(currentUrl);
- const serviceInfo = ServiceDetectionUtility.getServiceInfoFromTab(decodedCurrentUrl);
-
- if (!serviceNameFromUrl && serviceInfo.suggestedNames.length > 0) {
- detectedName = serviceInfo.suggestedNames[0];
- }
- if (!serviceUrlFromUrl && serviceInfo.serviceUrl) {
- detectedUrl = serviceInfo.serviceUrl;
- }
- }
- } else {
- // Otherwise, detect from current active tab (for dashboard case)
- const [activeTab] = await browser.tabs.query({ active: true, currentWindow: true });
-
- if (activeTab?.url) {
- const serviceInfo = ServiceDetectionUtility.getServiceInfoFromTab(
- activeTab.url,
- activeTab.title
- );
-
- if (serviceInfo.suggestedNames.length > 0 && !detectedName) {
- detectedName = serviceInfo.suggestedNames[0];
- }
- if (serviceInfo.serviceUrl) {
- detectedUrl = serviceInfo.serviceUrl;
- }
- }
- }
- } catch (error) {
- console.error('Error detecting service information:', error);
- }
+ const initializeCreateMode = async (): Promise<void> => {
+ // Use the service detection hook to get name and URL
+ const { serviceName, serviceUrl } = await detectService(itemNameParam);
// Create the new item with detected values
const newItem: Item = {
Id: crypto.randomUUID().toUpperCase(),
- Name: detectedName,
+ Name: serviceName,
ItemType: effectiveType,
FolderId: null,
Fields: [],
@@ -413,10 +318,10 @@ const ItemAddEdit: React.FC = () => {
setItem(newItem);
// Set the detected URL in field values if we have one
- if (detectedUrl) {
+ if (serviceUrl) {
setFieldValues(prev => ({
...prev,
- 'login.url': detectedUrl
+ 'login.url': serviceUrl
}));
}
@@ -438,7 +343,6 @@ const ItemAddEdit: React.FC = () => {
if (result[SKIP_FORM_RESTORE_KEY]) {
// Clear the flag after using it
await browser.storage.local.remove([SKIP_FORM_RESTORE_KEY]);
- // Don't load persisted values
} else {
// Load persisted form values normally
await loadPersistedValues();
@@ -448,7 +352,7 @@ const ItemAddEdit: React.FC = () => {
setIsInitialLoading(false);
};
- void initializeWithServiceDetection();
+ void initializeCreateMode();
return;
}
@@ -514,8 +418,7 @@ const ItemAddEdit: React.FC = () => {
setLocalLoading(false);
setIsInitialLoading(false);
}
- // eslint-disable-next-line react-hooks/exhaustive-deps
- }, [dbContext?.sqliteClient, id, isEditMode, itemTypeParam, itemNameParam, navigate, setIsInitialLoading, searchParams]);
+ }, [dbContext?.sqliteClient, id, isEditMode, itemTypeParam, itemNameParam, navigate, setIsInitialLoading, detectService, loadPersistedValues]);
/**
* Handle generating alias and populating fields.
@@ -1074,6 +977,7 @@ const ItemAddEdit: React.FC = () => {
* Use EmailDomainField for email fields to provide domain chooser functionality.
* For login.email (Login type), default to free text mode instead of domain chooser.
* EmailDomainField handles its own remove button in the label, so don't wrap it.
+ * For login.email, use controlled mode to persist the email/alias toggle state.
*/
return (
<EmailDomainField
@@ -1084,6 +988,8 @@ const ItemAddEdit: React.FC = () => {
defaultToFreeText={fieldKey === 'login.email'}
onRemove={onRemove}
onGenerateAlias={fieldKey === 'login.email' ? handleGenerateAliasEmail : undefined}
+ isEmailMode={fieldKey === 'login.email' ? isLoginEmailInEmailMode : undefined}
+ onEmailModeChange={fieldKey === 'login.email' ? setIsLoginEmailInEmailMode : undefined}
/>
);
@@ -1116,7 +1022,7 @@ const ItemAddEdit: React.FC = () => {
);
}
- }, [fieldValues, handleFieldChange, showPassword, t, handleGenerateAliasEmail, aliasFieldsShownByDefault, generateRandomUsername]);
+ }, [fieldValues, handleFieldChange, showPassword, t, handleGenerateAliasEmail, aliasFieldsShownByDefault, generateRandomUsername, isLoginEmailInEmailMode]);
/**
* Handle form submission via Enter key.
diff --git a/apps/browser-extension/src/utils/SqliteClient.ts b/apps/browser-extension/src/utils/SqliteClient.ts
index 86564bf35..7e5bc3b4c 100644
--- a/apps/browser-extension/src/utils/SqliteClient.ts
+++ b/apps/browser-extension/src/utils/SqliteClient.ts
@@ -13,6 +13,7 @@ import {
SettingsRepository,
LogoRepository
} from './db';
+
import type { IDatabaseClient, SqliteBindValue } from './db/BaseRepository';
/**