'pending_materialization', so a
+// pending_materialization mapping reads as sync_state 'local', never pending_materialization.
+const PENDING_SYNC_STATES = new Set(['pending_push']);
+
+export function contactCarddavState(contact) {
+ if (!isCardDavContact(contact)) {
+ return { labelKey: null, canEdit: true, canDelete: true, conflictId: null };
+ }
+
+ const conflictId = contact.conflict_id || null;
+ if (contact.sync_state === 'conflict' || conflictId) {
+ return {
+ labelKey: 'contacts.carddavConflict',
+ canEdit: false,
+ canDelete: false,
+ conflictId,
+ };
+ }
+
+ const canEdit = contact.remote_update_capability !== 'denied';
+ const canDelete = contact.remote_delete_capability !== 'denied';
+ if (PENDING_SYNC_STATES.has(contact.sync_state)) {
+ // A distinct pending marker: the contact stays editable (a re-edit is fenced by the
+ // backend's pending-intent handling), it just is not fully synced yet.
+ return { labelKey: 'contacts.carddavPending', canEdit, canDelete, conflictId: null };
+ }
+ return {
+ labelKey: canEdit || canDelete ? 'contacts.carddavSynced' : 'contacts.carddavReadOnly',
+ canEdit,
+ canDelete,
+ conflictId: null,
+ };
+}
+
+// The detail view's avatar uploads a photo through the same update as the edit form, so it
+// is offered on exactly the contacts that update is allowed on.
+export function canUploadContactPhoto(contact) {
+ return Boolean(contact) && contactCarddavState(contact).canEdit;
+}
+
+export function cloneFields(fields) {
+ return (fields || []).map(field => ({
+ id: field?.id,
+ kind: field?.kind,
+ label: field?.label,
+ value: field?.value && typeof field.value === 'object'
+ ? { ...field.value }
+ : field?.value,
+ }));
+}
+
+export function contactToForm(contact = {}) {
+ return {
+ displayName: contact.display_name || '',
+ firstName: contact.first_name || '',
+ lastName: contact.last_name || '',
+ emails: contact.emails?.length
+ ? contact.emails.map(email => ({ ...email }))
+ : [{ value: '', type: 'other', primary: true }],
+ phones: (contact.phones || []).map(phone => ({ ...phone })),
+ organization: contact.organization || '',
+ notes: contact.notes || '',
+ photoData: contact.photo_data || null,
+ hasPhoto: Boolean(contact.has_photo || contact.photo_data),
+ additionalFields: cloneFields(contact.additional_fields),
+ carddav: {
+ syncState: contact.sync_state || 'local',
+ capabilities: {
+ create: contact.remote_create_capability || null,
+ update: contact.remote_update_capability || null,
+ delete: contact.remote_delete_capability || null,
+ },
+ conflictId: contact.conflict_id || null,
+ },
+ };
+}
+
+export function formToContactDraft(form) {
+ const displayName = form.displayName.trim()
+ || [form.firstName.trim(), form.lastName.trim()].filter(Boolean).join(' ')
+ || null;
+ return {
+ displayName,
+ firstName: form.firstName || null,
+ lastName: form.lastName || null,
+ emails: form.emails.filter(email => email.value.trim()),
+ phones: form.phones.filter(phone => phone.value.trim()),
+ organization: form.organization || null,
+ notes: form.notes || null,
+ photoData: form.photoData,
+ additionalFields: cloneFields(form.additionalFields),
+ };
+}
+
+function emptyAdditionalValue(kind) {
+ if (kind === 'postal-address') {
+ return {
+ poBox: '',
+ extendedAddress: '',
+ street: '',
+ locality: '',
+ region: '',
+ postalCode: '',
+ country: '',
+ };
+ }
+ if (kind === 'im') return { protocol: '', handle: '' };
+ if (kind === 'geo') return { latitude: '', longitude: '' };
+ return '';
+}
+
+export function newAdditionalField(kind, makeId = () => crypto.randomUUID()) {
+ return {
+ id: makeId(),
+ kind,
+ label: '',
+ value: emptyAdditionalValue(kind),
+ };
+}
+
+export function removeContactPhoto(form) {
+ return { ...form, photoData: null, hasPhoto: false };
+}
+
+export function validateContactPhoto(file) {
+ if (!PHOTO_TYPES.has(file?.type)) return 'contacts.photo.invalidType';
+ if (file.size > MAX_PHOTO_BYTES) return 'contacts.photo.tooLarge';
+ return null;
+}
+
+export function initialPhotoReadState() {
+ return { generation: 0, pending: false };
+}
+
+export function beginPhotoRead(state) {
+ return { generation: state.generation + 1, pending: true };
+}
+
+export function invalidatePhotoRead(state) {
+ return { generation: state.generation + 1, pending: false };
+}
+
+export function completePhotoRead(state, generation) {
+ if (!state.pending || state.generation !== generation) {
+ return { state, accepted: false };
+ }
+ return {
+ state: { generation: state.generation, pending: false },
+ accepted: true,
+ };
+}
+
+export function shouldRefreshContactAfterResolution(contact, conflict) {
+ const uid = contact?.uid;
+ return Boolean(uid && [
+ conflict?.local?.contact?.uid,
+ conflict?.remote?.contact?.uid,
+ ].includes(uid));
+}
+
+// A post-write 409 whose body carries an ambiguous-write / pending-intent code: the
+// remote effect may have landed and MailFlow recovered read-only, so the client must
+// refresh state (re-GET) rather than blindly re-issue the mutation.
+const REFRESH_WRITE_CODES = new Set([
+ 'ERR_CARDDAV_AMBIGUOUS_WRITE',
+ 'ERR_CARDDAV_PENDING_INTENT',
+]);
+
+export function isRefreshableWriteError(error) {
+ return error?.status === 409 && REFRESH_WRITE_CODES.has(error?.data?.code);
+}
+
+export function saveFailureState(error, form) {
+ if (error?.status === 409 && error.conflictId) {
+ return {
+ view: 'conflict',
+ conflictId: error.conflictId,
+ form,
+ error: null,
+ };
+ }
+ if (isRefreshableWriteError(error)) {
+ // Keep the draft, signal the caller to re-GET the contact, and show honest copy —
+ // the write may have applied and reconciles on the next sync; don't re-issue it.
+ return {
+ view: 'refresh',
+ conflictId: null,
+ form,
+ error: null,
+ messageKey: 'contacts.carddavWriteUnconfirmed',
+ };
+ }
+ return {
+ view: 'form',
+ conflictId: null,
+ form,
+ error: error?.message || 'Request failed',
+ };
+}
diff --git a/frontend/src/contactCarddavState.test.js b/frontend/src/contactCarddavState.test.js
new file mode 100644
index 00000000..3c4c0797
--- /dev/null
+++ b/frontend/src/contactCarddavState.test.js
@@ -0,0 +1,345 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import {
+ ADDITIONAL_FIELD_KINDS,
+ beginPhotoRead,
+ canUploadContactPhoto,
+ completePhotoRead,
+ contactCarddavState,
+ contactToForm,
+ formToContactDraft,
+ initialPhotoReadState,
+ invalidatePhotoRead,
+ isRefreshableWriteError,
+ newAdditionalField,
+ removeContactPhoto,
+ saveFailureState,
+ shouldRefreshContactAfterResolution,
+ validateContactPhoto,
+} from './contactCarddavState.js';
+import * as contactCarddavHelpers from './contactCarddavState.js';
+import { api } from './utils/api.js';
+
+const testDir = dirname(fileURLToPath(import.meta.url));
+
+describe('CardDAV contact state', () => {
+ it('labels writable, operation-read-only, and conflicted contacts from backend capabilities', () => {
+ assert.deepEqual(contactCarddavState({
+ sync_state: 'synced',
+ remote_update_capability: 'allowed',
+ remote_delete_capability: 'denied',
+ }), {
+ labelKey: 'contacts.carddavSynced',
+ canEdit: true,
+ canDelete: false,
+ conflictId: null,
+ });
+ assert.deepEqual(contactCarddavState({
+ sync_state: 'synced',
+ remote_update_capability: 'denied',
+ remote_delete_capability: 'denied',
+ }), {
+ labelKey: 'contacts.carddavReadOnly',
+ canEdit: false,
+ canDelete: false,
+ conflictId: null,
+ });
+ assert.deepEqual(contactCarddavState({
+ sync_state: 'conflict',
+ conflict_id: 'conflict-1',
+ remote_update_capability: 'allowed',
+ remote_delete_capability: 'allowed',
+ }), {
+ labelKey: 'contacts.carddavConflict',
+ canEdit: false,
+ canDelete: false,
+ conflictId: 'conflict-1',
+ });
+ });
+
+ it('marks a write-unconfirmed contact as pending, not fully synced, and keeps it editable', () => {
+ // pending_push is the only pending sync_state the contacts API can surface.
+ assert.deepEqual(contactCarddavState({
+ sync_state: 'pending_push',
+ remote_update_capability: 'allowed',
+ remote_delete_capability: 'allowed',
+ }), {
+ labelKey: 'contacts.carddavPending',
+ canEdit: true,
+ canDelete: true,
+ conflictId: null,
+ });
+ // A conflict still wins over pending, and a denied capability still gates the action.
+ assert.equal(contactCarddavState({ sync_state: 'pending_push', conflict_id: 'c1' }).labelKey,
+ 'contacts.carddavConflict');
+ assert.equal(contactCarddavState({
+ sync_state: 'pending_push',
+ remote_update_capability: 'denied',
+ remote_delete_capability: 'denied',
+ }).canEdit, false);
+ // A genuinely synced contact is unchanged.
+ assert.equal(contactCarddavState({ sync_state: 'synced', remote_update_capability: 'allowed' }).labelKey,
+ 'contacts.carddavSynced');
+ });
+
+ it('initializes an editable form without dropping photos or typed Additional fields', () => {
+ const contact = {
+ display_name: 'Ada Lovelace',
+ first_name: 'Ada',
+ last_name: 'Lovelace',
+ emails: [{ value: 'ada@example.test', type: 'work', primary: true }],
+ phones: [{ value: '+1 555 0100', type: 'mobile' }],
+ organization: 'Analytical Engines',
+ notes: 'First programmer',
+ photo_data: 'data:image/png;base64,AQID',
+ has_photo: true,
+ sync_state: 'synced',
+ remote_create_capability: 'allowed',
+ remote_update_capability: 'unknown',
+ remote_delete_capability: 'denied',
+ conflict_id: 'conflict-1',
+ additional_fields: [{
+ id: 'stable-site',
+ kind: 'url',
+ label: 'Portfolio',
+ value: 'https://example.test/ada',
+ vcard: {
+ group: 'item1',
+ name: 'URL',
+ parameters: { TYPE: ['work'] },
+ },
+ }],
+ };
+ const editableAdditionalFields = [{
+ id: 'stable-site',
+ kind: 'url',
+ label: 'Portfolio',
+ value: 'https://example.test/ada',
+ }];
+
+ const form = contactToForm(contact);
+ assert.equal(form.photoData, contact.photo_data);
+ assert.equal(form.hasPhoto, true);
+ assert.deepEqual(form.carddav, {
+ syncState: 'synced',
+ capabilities: { create: 'allowed', update: 'unknown', delete: 'denied' },
+ conflictId: 'conflict-1',
+ });
+ assert.deepEqual(form.additionalFields, editableAdditionalFields);
+ assert.notEqual(form.additionalFields, contact.additional_fields);
+ assert.equal(JSON.stringify(form.additionalFields).includes('vcard'), false);
+ assert.deepEqual(formToContactDraft(form), {
+ displayName: 'Ada Lovelace',
+ firstName: 'Ada',
+ lastName: 'Lovelace',
+ emails: contact.emails,
+ phones: contact.phones,
+ organization: 'Analytical Engines',
+ notes: 'First programmer',
+ photoData: contact.photo_data,
+ additionalFields: editableAdditionalFields,
+ });
+ assert.equal(JSON.stringify(formToContactDraft(form)).includes('parameters'), false);
+ });
+
+ it('supports every projected Additional-field kind and gives new fields stable IDs', () => {
+ assert.deepEqual(ADDITIONAL_FIELD_KINDS, [
+ 'postal-address', 'url', 'im', 'birthday', 'anniversary', 'date',
+ 'role', 'title', 'nickname', 'geo', 'custom-text',
+ ]);
+
+ const field = newAdditionalField('im', () => 'stable-generated-id');
+ assert.deepEqual(field, {
+ id: 'stable-generated-id',
+ kind: 'im',
+ label: '',
+ value: { protocol: '', handle: '' },
+ });
+ });
+
+ it('round-trips valid vCard date shapes through lossless text controls', () => {
+ const additionalFields = [
+ { id: 'basic', kind: 'birthday', label: 'Basic', value: '19960415' },
+ { id: 'partial', kind: 'anniversary', label: 'Partial', value: '--0415' },
+ { id: 'date-time', kind: 'date', label: 'Date-time', value: '19960415T143000Z' },
+ { id: 'text', kind: 'birthday', label: 'Text', value: 'circa 1996' },
+ ];
+
+ const form = contactToForm({ additional_fields: additionalFields });
+
+ assert.deepEqual(form.additionalFields.map(field => field.value), [
+ '19960415', '--0415', '19960415T143000Z', 'circa 1996',
+ ]);
+ assert.equal(typeof contactCarddavHelpers.additionalFieldInputType, 'function');
+ assert.deepEqual(form.additionalFields.map(field => ({
+ type: contactCarddavHelpers.additionalFieldInputType(field.kind),
+ value: field.value,
+ })), additionalFields.map(field => ({ type: 'text', value: field.value })));
+ assert.deepEqual(formToContactDraft(form).additionalFields, additionalFields);
+
+ const contactsPage = readFileSync(join(testDir, 'components', 'ContactsPage.jsx'), 'utf8');
+ assert.match(contactsPage, /type=\{additionalFieldInputType\(field\.kind\)\}/);
+ });
+
+ it('keeps contact status and actions in a wrapping in-flow header', () => {
+ const contactsPage = readFileSync(join(testDir, 'components', 'ContactsPage.jsx'), 'utf8');
+ const detail = contactsPage.slice(
+ contactsPage.indexOf('function ContactDetail'),
+ contactsPage.indexOf('function ContactForm'),
+ );
+
+ assert.match(detail, /flexWrap: 'wrap'/);
+ assert.doesNotMatch(detail, /paddingRight: 128/);
+ });
+
+ it('marks photo removal explicitly and rejects oversized or non-image uploads', () => {
+ assert.deepEqual(removeContactPhoto({
+ photoData: 'data:image/jpeg;base64,AQID',
+ hasPhoto: true,
+ displayName: 'Ada',
+ }), {
+ photoData: null,
+ hasPhoto: false,
+ displayName: 'Ada',
+ });
+ assert.equal(validateContactPhoto({ type: 'image/png', size: 512 * 1024 }), null);
+ assert.equal(validateContactPhoto({ type: 'image/svg+xml', size: 100 }), 'contacts.photo.invalidType');
+ assert.equal(validateContactPhoto({ type: 'image/jpeg', size: 512 * 1024 + 1 }), 'contacts.photo.tooLarge');
+ });
+
+ it('offers the detail-view photo upload only where the remote accepts an update', () => {
+ assert.equal(canUploadContactPhoto({ id: 1 }), true);
+ assert.equal(canUploadContactPhoto({
+ sync_state: 'synced',
+ remote_update_capability: 'allowed',
+ remote_delete_capability: 'denied',
+ }), true);
+ assert.equal(canUploadContactPhoto({
+ sync_state: 'pending_push',
+ remote_update_capability: 'allowed',
+ }), true);
+ assert.equal(canUploadContactPhoto({
+ sync_state: 'synced',
+ remote_update_capability: 'denied',
+ }), false);
+ assert.equal(canUploadContactPhoto({ sync_state: 'conflict', conflict_id: 'conflict-1' }), false);
+ assert.equal(canUploadContactPhoto(null), false);
+ });
+
+ it('uploads the detail-view photo from a focusable control through the edit save path', () => {
+ const contactsPage = readFileSync(join(testDir, 'components', 'ContactsPage.jsx'), 'utf8');
+ const detail = contactsPage.slice(
+ contactsPage.indexOf('function ContactDetail'),
+ contactsPage.indexOf('function ContactForm'),
+ );
+
+ assert.match(detail, /canUploadContactPhoto\(c\)/);
+ assert.match(detail, /
]*onClick/);
+ assert.match(contactsPage, /const uploadDetailPhoto = file =>/);
+ assert.match(contactsPage, /readPhotoFile\(file, photoData => submitContact\(/);
+ });
+
+ it('keeps photo reading pending and ignores a callback after the form changes', () => {
+ const reading = beginPhotoRead(initialPhotoReadState());
+ assert.equal(reading.pending, true);
+
+ const changedForm = invalidatePhotoRead(reading);
+ assert.equal(changedForm.pending, false);
+ assert.equal(changedForm.generation, reading.generation + 1);
+ assert.deepEqual(completePhotoRead(changedForm, reading.generation), {
+ state: changedForm,
+ accepted: false,
+ });
+ });
+
+ it('accepts only the newest photo read callback', () => {
+ const first = beginPhotoRead(initialPhotoReadState());
+ const second = beginPhotoRead(first);
+
+ assert.deepEqual(completePhotoRead(second, first.generation), {
+ state: second,
+ accepted: false,
+ });
+ assert.deepEqual(completePhotoRead(second, second.generation), {
+ state: { generation: second.generation, pending: false },
+ accepted: true,
+ });
+ });
+
+ it('navigates a 409 to its conflict while retaining the exact draft object', () => {
+ const form = { displayName: 'Unsaved edit' };
+ const error = Object.assign(new Error('Request failed'), {
+ status: 409,
+ conflictId: 'conflict-1',
+ });
+
+ assert.deepEqual(saveFailureState(error, form), {
+ view: 'conflict',
+ conflictId: 'conflict-1',
+ form,
+ error: null,
+ });
+ assert.equal(saveFailureState(error, form).form, form);
+ });
+
+ it('routes a 409 ambiguous/pending write to a refresh view that keeps the draft', () => {
+ const form = { displayName: 'Unsaved edit' };
+ for (const code of ['ERR_CARDDAV_AMBIGUOUS_WRITE', 'ERR_CARDDAV_PENDING_INTENT']) {
+ const error = Object.assign(new Error('unconfirmed'), {
+ status: 409,
+ data: { error: 'unconfirmed', code, refresh: true },
+ });
+ assert.equal(isRefreshableWriteError(error), true);
+ assert.deepEqual(saveFailureState(error, form), {
+ view: 'refresh',
+ conflictId: null,
+ form,
+ error: null,
+ messageKey: 'contacts.carddavWriteUnconfirmed',
+ });
+ assert.equal(saveFailureState(error, form).form, form);
+ }
+ // A conflictId 409 still routes to conflict; other errors stay a form error.
+ const conflict = Object.assign(new Error('x'), { status: 409, conflictId: 'c1' });
+ assert.equal(isRefreshableWriteError(conflict), false);
+ assert.equal(saveFailureState(conflict, form).view, 'conflict');
+ assert.equal(saveFailureState(Object.assign(new Error('boom'), { status: 500 }), form).view, 'form');
+ });
+
+ it('refreshes only the selected contact represented by the resolved conflict', () => {
+ const conflict = {
+ local: { tombstone: true, contact: null },
+ remote: { tombstone: false, contact: { uid: 'contact-1' } },
+ };
+
+ assert.equal(shouldRefreshContactAfterResolution({ uid: 'contact-1' }, conflict), true);
+ assert.equal(shouldRefreshContactAfterResolution({ uid: 'contact-2' }, conflict), false);
+ assert.equal(shouldRefreshContactAfterResolution(null, conflict), false);
+ });
+
+ it('preserves HTTP 409 metadata needed for conflict navigation', async () => {
+ const originalFetch = globalThis.fetch;
+ globalThis.fetch = async () => ({
+ ok: false,
+ status: 409,
+ json: async () => ({ conflictId: 'conflict-1' }),
+ });
+
+ try {
+ await assert.rejects(api.updateContact('contact-1', { displayName: 'Draft' }), error => {
+ assert.equal(error.status, 409);
+ assert.equal(error.conflictId, 'conflict-1');
+ assert.deepEqual(error.data, { conflictId: 'conflict-1' });
+ return true;
+ });
+ } finally {
+ globalThis.fetch = originalFetch;
+ }
+ });
+});
diff --git a/frontend/src/contactLabels.js b/frontend/src/contactLabels.js
new file mode 100644
index 00000000..663fb359
--- /dev/null
+++ b/frontend/src/contactLabels.js
@@ -0,0 +1,57 @@
+// Apple Contacts encodes its well-known X-ABLABEL values in a sentinel wrapper
+// (`_$!!$_`), and a vCard property with no X-ABLABEL falls back to its raw TYPE
+// token (`WORK`, `HOME`). CardDAV servers hand both through verbatim, so they reach the
+// client as the label of an additional field and must be humanized for display only —
+// the stored label is what the retained vCard round-trips.
+const APPLE_LABEL = /^_\$!<(.*)>!\$_$/;
+
+// Well-known label tokens, lowercased so uppercase TYPE tokens resolve like Apple's
+// mixed-case labels, mapped onto localized copy the app already ships.
+const LOCALIZED_LABELS = new Map([
+ ['home', 'contacts.emailTypes.home'],
+ ['work', 'contacts.emailTypes.work'],
+ ['other', 'contacts.emailTypes.other'],
+ ['mobile', 'contacts.phoneTypes.mobile'],
+ ['cell', 'contacts.phoneTypes.mobile'],
+ ['iphone', 'contacts.phoneTypes.mobile'],
+ ['homepage', 'contacts.additional.types.url'],
+ ['url', 'contacts.additional.types.url'],
+ ['birthday', 'contacts.additional.types.birthday'],
+ ['anniversary', 'contacts.additional.types.anniversary'],
+ ['nickname', 'contacts.additional.types.nickname'],
+ ['role', 'contacts.additional.types.role'],
+ ['title', 'contacts.additional.types.title'],
+]);
+
+export const CONTACT_LABEL_KEYS = [...new Set(LOCALIZED_LABELS.values())];
+
+function titleCase(token) {
+ return token
+ .split(/\s+/)
+ .filter(Boolean)
+ .map(word => word[0].toUpperCase() + word.slice(1).toLowerCase())
+ .join(' ');
+}
+
+export function humanizeContactLabel(label, t) {
+ const raw = String(label ?? '').trim();
+ const inner = (APPLE_LABEL.exec(raw)?.[1] ?? raw).trim();
+ if (!inner) return '';
+ const key = LOCALIZED_LABELS.get(inner.toLowerCase());
+ return key ? t(key) : titleCase(inner);
+}
+
+export function formatContactValue(value, t) {
+ if (value === null || value === undefined || value === '') return '—';
+ if (Array.isArray(value)) return value.length ? value.map(item => formatContactValue(item, t)) : '—';
+ if (typeof value !== 'object') return String(value);
+ if (value.kind) {
+ const label = humanizeContactLabel(value.label || value.kind, t)
+ || t(`contacts.additional.types.${value.kind}`);
+ return `${label}: ${formatContactValue(value.value, t)}`;
+ }
+ return Object.values(value)
+ .filter(part => part !== null && part !== undefined && part !== '' && typeof part !== 'boolean')
+ .map(String)
+ .join(' · ') || '—';
+}
diff --git a/frontend/src/contactLabels.test.js b/frontend/src/contactLabels.test.js
new file mode 100644
index 00000000..0c2e98e4
--- /dev/null
+++ b/frontend/src/contactLabels.test.js
@@ -0,0 +1,107 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { CONTACT_LABEL_KEYS, formatContactValue, humanizeContactLabel } from './contactLabels.js';
+import { contactToForm, formToContactDraft } from './contactCarddavState.js';
+
+const testDir = dirname(fileURLToPath(import.meta.url));
+
+function valueAt(object, path) {
+ return path.split('.').reduce((value, key) => value?.[key], object);
+}
+
+function localeT(locale) {
+ const messages = JSON.parse(readFileSync(join(testDir, 'locales', `${locale}.json`), 'utf8'));
+ return key => {
+ const value = valueAt(messages, key);
+ assert.equal(typeof value, 'string', `${locale} is missing ${key}`);
+ return value;
+ };
+}
+
+const t = localeT('en');
+
+describe('contact label humanizer', () => {
+ it('humanizes the raw Apple/Nextcloud label artifacts seen in production', () => {
+ // Exactly what a Nextcloud collection of Apple-authored contacts hands the client.
+ assert.equal(humanizeContactLabel('_$!!$_', t), 'Web address');
+ assert.equal(humanizeContactLabel('WORK', t), 'Work');
+ assert.equal(humanizeContactLabel('HOME', t), 'Home');
+ });
+
+ it('resolves well-known labels case-insensitively, wrapped or bare', () => {
+ for (const label of ['work', 'Work', 'WORK', '_$!!$_', '_$!!$_']) {
+ assert.equal(humanizeContactLabel(label, t), 'Work');
+ }
+ assert.equal(humanizeContactLabel('_$!!$_', t), 'Other');
+ assert.equal(humanizeContactLabel('CELL', t), 'Mobile');
+ assert.equal(humanizeContactLabel('_$!!$_', t), 'Mobile');
+ assert.equal(humanizeContactLabel('_$!!$_', t), 'Anniversary');
+ });
+
+ it('reuses the localized copy the app already ships, in every locale', () => {
+ const de = localeT('de');
+ assert.equal(humanizeContactLabel('WORK', de), 'Arbeit');
+ assert.equal(humanizeContactLabel('_$!!$_', de), 'Webadresse');
+ const zhCN = localeT('zhCN');
+ assert.equal(humanizeContactLabel('HOME', zhCN), '家庭');
+
+ // Every mapped key must be an existing key — no parallel copy for labels.
+ const en = JSON.parse(readFileSync(join(testDir, 'locales', 'en.json'), 'utf8'));
+ const missing = CONTACT_LABEL_KEYS.filter(key => typeof valueAt(en, key) !== 'string');
+ assert.deepEqual(missing, []);
+ });
+
+ it('strips the wrapper and title-cases anything it does not know', () => {
+ assert.equal(humanizeContactLabel('_$!!$_', t), 'Fax');
+ assert.equal(humanizeContactLabel('PAGER', t), 'Pager');
+ assert.equal(humanizeContactLabel('MAIN', t), 'Main');
+ assert.equal(humanizeContactLabel('_$!!$_', t), 'Ski Cabin');
+ assert.equal(humanizeContactLabel('', t), '');
+ assert.equal(humanizeContactLabel(null, t), '');
+ assert.equal(humanizeContactLabel(undefined, t), '');
+ });
+
+ it('formats vCard values with humanized labels and omits boolean metadata', () => {
+ assert.equal(formatContactValue({
+ kind: 'url',
+ label: '_$!!$_',
+ value: 'https://example.test',
+ }, t), 'Web address: https://example.test');
+ assert.equal(formatContactValue({
+ value: 'ada@example.test',
+ type: 'work',
+ primary: true,
+ }, t), 'ada@example.test · work');
+ });
+
+ it('is presentation only: the stored label still round-trips byte-for-byte', () => {
+ const label = '_$!!$_';
+ const form = contactToForm({
+ additional_fields: [{ id: 'vcard-1', kind: 'url', label, value: 'https://example.test' }],
+ });
+
+ assert.equal(form.additionalFields[0].label, label);
+ assert.equal(formToContactDraft(form).additionalFields[0].label, label);
+ });
+
+ it('humanizes labels in both the detail and the edit rendering', () => {
+ const contactsPage = readFileSync(join(testDir, 'components', 'ContactsPage.jsx'), 'utf8');
+ const detail = contactsPage.slice(
+ contactsPage.indexOf('function ContactDetail'),
+ contactsPage.indexOf('function ContactForm'),
+ );
+ const form = contactsPage.slice(
+ contactsPage.indexOf('function ContactForm'),
+ contactsPage.indexOf('function AdditionalFieldInput'),
+ );
+
+ assert.match(detail, /humanizeContactLabel\(field\.label, t\)/);
+ assert.match(form, /humanizeContactLabel\(field\.label, t\)/);
+ // The edit control still writes the raw value the user typed, never the humanized one.
+ assert.match(form, /onSetAdditional\(field\.id, \{ label: event\.target\.value \}\)/);
+ });
+});
diff --git a/frontend/src/locales/de.json b/frontend/src/locales/de.json
index c8b7f574..54fd0a15 100644
--- a/frontend/src/locales/de.json
+++ b/frontend/src/locales/de.json
@@ -1192,8 +1192,7 @@
},
"carddav": {
"title": "CardDAV-Kontakte",
- "description": "Kontakte von einem CardDAV-Server wie Nextcloud synchronisieren.",
- "connected": "Verbunden",
+ "description": "Kontakte mit einem CardDAV-Server wie Nextcloud synchronisieren.",
"notConnected": "Nicht verbunden",
"serverLabel": "Server-URL",
"serverPh": "https://cloud.beispiel.de",
@@ -1201,10 +1200,6 @@
"userPh": "Ihr Nextcloud-Benutzername",
"passLabel": "App-Passwort",
"passPh": "App-Passwort (nicht Ihr Login-Passwort)",
- "dupLabel": "Wenn ein Kontakt bereits existiert",
- "dupSeparate": "Beide behalten (eigenes Adressbuch)",
- "dupMerge": "Zusammenführen – CardDAV gewinnt",
- "dupSkip": "CardDAV-Kontakt überspringen",
"intervalLabel": "Sync-Intervall (Minuten)",
"connect": "Verbinden",
"connecting": "Verbinde…",
@@ -1215,7 +1210,11 @@
"lastSync": "Letzte Sync: {{when}}",
"summary": "{{contacts}} Kontakte in {{books}} Adressbüchern",
"syncFailed": "Letzte Sync fehlgeschlagen: {{error}}",
- "help": "Verwenden Sie ein Nextcloud-App-Passwort, nicht Ihr Login-Passwort – SSO-Nutzer erstellen es unter Einstellungen → Sicherheit. Kontakte werden einseitig synchronisiert und sind in MailFlow schreibgeschützt."
+ "healthUnavailable": "Status nicht verfügbar",
+ "healthNeedsAttention": "Überprüfung nötig",
+ "healthHealthy": "Fehlerfrei",
+ "reviewConflicts": "Konflikte prüfen",
+ "help": "Verwenden Sie ein Nextcloud-App-Passwort, nicht Ihr Login-Passwort – SSO-Nutzer erstellen es unter Einstellungen → Sicherheit. Kontakte werden in beide Richtungen synchronisiert, wenn der Server Schreibzugriffe erlaubt."
}
},
"ssoLinked": {
@@ -1331,7 +1330,8 @@
"search": "Kontakte suchen…",
"empty": "Noch keine Kontakte",
"noResults": "Keine Kontakte gefunden",
- "count": "{{count}} Kontakte",
+ "count_one": "{{count}} Kontakt",
+ "count_other": "{{count}} Kontakte",
"auto": "auto",
"autoHint": "Aus empfangenen Mails erkannt",
"selectHint": "Kontakt auswählen",
@@ -1360,7 +1360,74 @@
"home": "Privat",
"other": "Sonstige"
},
- "carddavBadge": "Von CardDAV synchronisiert"
+ "carddavSynced": "Mit CardDAV synchronisiert",
+ "carddavReadOnly": "CardDAV nur lesbar",
+ "carddavConflict": "CardDAV-Konflikt",
+ "carddavPending": "Synchronisierung ausstehend",
+ "carddavWriteUnconfirmed": "Ihre Änderung wurde möglicherweise bereits übernommen – der Kontakt wurde aktualisiert. Prüfen Sie ihn und versuchen Sie es bei Bedarf erneut.",
+ "photo": {
+ "title": "Foto",
+ "contactAlt": "Kontaktfoto",
+ "previewAlt": "Vorschau des Kontaktfotos",
+ "present": "Foto vorhanden",
+ "none": "Kein Foto",
+ "choose": "Foto auswählen",
+ "remove": "Foto entfernen",
+ "invalidType": "Wählen Sie ein JPEG- oder PNG-Bild.",
+ "tooLarge": "Das Foto darf höchstens 512 KiB groß sein.",
+ "readFailed": "Das Foto konnte nicht gelesen werden."
+ },
+ "additional": {
+ "title": "Zusätzliche Felder",
+ "label": "Bezeichnung",
+ "value": "Wert",
+ "add": "Feld hinzufügen",
+ "street": "Straße",
+ "extendedAddress": "Adresszusatz",
+ "locality": "Ort",
+ "region": "Bundesland oder Region",
+ "postalCode": "Postleitzahl",
+ "country": "Land",
+ "poBox": "Postfach",
+ "protocol": "Nachrichtendienst",
+ "handle": "Benutzername oder Kennung",
+ "latitude": "Breitengrad",
+ "longitude": "Längengrad",
+ "types": {
+ "postal-address": "Postanschrift",
+ "url": "Webadresse",
+ "im": "Sofortnachricht",
+ "birthday": "Geburtstag",
+ "anniversary": "Jahrestag",
+ "date": "Datum",
+ "role": "Funktion",
+ "title": "Berufsbezeichnung",
+ "nickname": "Spitzname",
+ "geo": "Koordinaten",
+ "custom-text": "Eigener Text"
+ }
+ },
+ "conflicts": {
+ "title": "CardDAV-Konflikte",
+ "count_one": "{{count}} ungelöster Konflikt",
+ "count_other": "{{count}} ungelöste Konflikte",
+ "deleted": "Gelöscht",
+ "photoPresent": "Foto vorhanden",
+ "photoAbsent": "Kein Foto hinterlegt",
+ "loadFailed": "Die Konflikte konnten nicht geladen werden.",
+ "empty": "Keine ungelösten CardDAV-Konflikte.",
+ "item": "Konflikt {{number}}",
+ "mailflowSide": "MailFlow-Version",
+ "carddavSide": "CardDAV-Version",
+ "resolveFailed": "Der Konflikt konnte nicht gelöst werden. Prüfen Sie beide Versionen und versuchen Sie es erneut.",
+ "resolving": "Wird gelöst…",
+ "keepMailflow": "MailFlow-Version behalten",
+ "keepCarddav": "CardDAV-Version behalten",
+ "openCount_one": "{{count}} CardDAV-Konflikt prüfen",
+ "openCount_other": "{{count}} CardDAV-Konflikte prüfen",
+ "refreshFailed": "Der Kontakt konnte nach der Lösung nicht aktualisiert werden.",
+ "close": "Konflikte schließen"
+ }
},
"todoist": {
"betaLabel": "Beta",
diff --git a/frontend/src/locales/en.json b/frontend/src/locales/en.json
index e594dd23..1e532c33 100644
--- a/frontend/src/locales/en.json
+++ b/frontend/src/locales/en.json
@@ -1259,8 +1259,7 @@
},
"carddav": {
"title": "CardDAV Contacts",
- "description": "Sync contacts from a CardDAV server such as Nextcloud.",
- "connected": "Connected",
+ "description": "Sync contacts with a CardDAV server such as Nextcloud.",
"notConnected": "Not connected",
"serverLabel": "Server URL",
"serverPh": "https://cloud.example.com",
@@ -1268,10 +1267,6 @@
"userPh": "your Nextcloud username",
"passLabel": "App password",
"passPh": "app password (not your login password)",
- "dupLabel": "When a contact already exists",
- "dupSeparate": "Keep both (separate address book)",
- "dupMerge": "Merge — CardDAV wins",
- "dupSkip": "Skip the CardDAV contact",
"intervalLabel": "Sync interval (minutes)",
"connect": "Connect",
"connecting": "Connecting…",
@@ -1282,7 +1277,11 @@
"lastSync": "Last sync: {{when}}",
"summary": "{{contacts}} contacts in {{books}} address books",
"syncFailed": "Last sync failed: {{error}}",
- "help": "Use a Nextcloud app password, not your login password — SSO users must create one under Settings → Security. Contacts are synced one-way and are read-only in MailFlow."
+ "healthUnavailable": "Health unavailable",
+ "healthNeedsAttention": "Needs attention",
+ "healthHealthy": "Healthy",
+ "reviewConflicts": "Review conflicts",
+ "help": "Use a Nextcloud app password, not your login password — SSO users must create one under Settings → Security. Contacts sync in both directions when the server allows writes."
}
},
"ssoLinked": {
@@ -1331,7 +1330,8 @@
"search": "Search contacts…",
"empty": "No contacts yet",
"noResults": "No contacts found",
- "count": "{{count}} contacts",
+ "count_one": "{{count}} contact",
+ "count_other": "{{count}} contacts",
"auto": "auto",
"autoHint": "Discovered from received mail",
"selectHint": "Select a contact to view details",
@@ -1360,7 +1360,74 @@
"home": "Home",
"other": "Other"
},
- "carddavBadge": "Synced from CardDAV"
+ "carddavSynced": "Synced with CardDAV",
+ "carddavReadOnly": "Read-only CardDAV",
+ "carddavConflict": "CardDAV conflict",
+ "carddavPending": "Sync pending",
+ "carddavWriteUnconfirmed": "Your change may already have been applied — the contact was refreshed. Check it and try again if needed.",
+ "photo": {
+ "title": "Photo",
+ "contactAlt": "Contact photo",
+ "previewAlt": "Contact photo preview",
+ "present": "Photo available",
+ "none": "No photo",
+ "choose": "Choose photo",
+ "remove": "Remove photo",
+ "invalidType": "Choose a JPEG or PNG image.",
+ "tooLarge": "The photo must be 512 KiB or smaller.",
+ "readFailed": "The photo could not be read."
+ },
+ "additional": {
+ "title": "Additional fields",
+ "label": "Label",
+ "value": "Value",
+ "add": "Add field",
+ "street": "Street",
+ "extendedAddress": "Address details",
+ "locality": "City",
+ "region": "State or region",
+ "postalCode": "Postal code",
+ "country": "Country",
+ "poBox": "PO box",
+ "protocol": "Messaging service",
+ "handle": "Username or handle",
+ "latitude": "Latitude",
+ "longitude": "Longitude",
+ "types": {
+ "postal-address": "Postal address",
+ "url": "Web address",
+ "im": "Instant messaging",
+ "birthday": "Birthday",
+ "anniversary": "Anniversary",
+ "date": "Date",
+ "role": "Role",
+ "title": "Job title",
+ "nickname": "Nickname",
+ "geo": "Coordinates",
+ "custom-text": "Custom text"
+ }
+ },
+ "conflicts": {
+ "title": "CardDAV conflicts",
+ "count_one": "{{count}} unresolved conflict",
+ "count_other": "{{count}} unresolved conflicts",
+ "deleted": "Deleted",
+ "photoPresent": "Photo present",
+ "photoAbsent": "No photo",
+ "loadFailed": "Conflicts could not be loaded.",
+ "empty": "No unresolved CardDAV conflicts.",
+ "item": "Conflict {{number}}",
+ "mailflowSide": "MailFlow version",
+ "carddavSide": "CardDAV version",
+ "resolveFailed": "The conflict could not be resolved. Review both versions and try again.",
+ "resolving": "Resolving…",
+ "keepMailflow": "Keep MailFlow version",
+ "keepCarddav": "Keep CardDAV version",
+ "openCount_one": "Review {{count}} CardDAV conflict",
+ "openCount_other": "Review {{count}} CardDAV conflicts",
+ "refreshFailed": "The contact could not be refreshed after resolution.",
+ "close": "Close conflicts"
+ }
},
"todoist": {
"betaLabel": "Beta",
diff --git a/frontend/src/locales/es.json b/frontend/src/locales/es.json
index f05d5694..ec5a4660 100644
--- a/frontend/src/locales/es.json
+++ b/frontend/src/locales/es.json
@@ -1259,8 +1259,7 @@
},
"carddav": {
"title": "Contactos CardDAV",
- "description": "Sincroniza contactos desde un servidor CardDAV como Nextcloud.",
- "connected": "Conectado",
+ "description": "Sincroniza contactos con un servidor CardDAV como Nextcloud.",
"notConnected": "No conectado",
"serverLabel": "URL del servidor",
"serverPh": "https://cloud.ejemplo.com",
@@ -1268,10 +1267,6 @@
"userPh": "tu usuario de Nextcloud",
"passLabel": "Contraseña de aplicación",
"passPh": "contraseña de aplicación (no la de inicio de sesión)",
- "dupLabel": "Cuando un contacto ya existe",
- "dupSeparate": "Mantener ambos (libreta separada)",
- "dupMerge": "Combinar: gana CardDAV",
- "dupSkip": "Omitir el contacto CardDAV",
"intervalLabel": "Intervalo de sincronización (minutos)",
"connect": "Conectar",
"connecting": "Conectando…",
@@ -1282,7 +1277,11 @@
"lastSync": "Última sincronización: {{when}}",
"summary": "{{contacts}} contactos en {{books}} libretas",
"syncFailed": "La última sincronización falló: {{error}}",
- "help": "Usa una contraseña de aplicación de Nextcloud, no la de inicio de sesión: los usuarios de SSO deben crear una en Ajustes → Seguridad. Los contactos se sincronizan en un solo sentido y son de solo lectura en MailFlow."
+ "healthUnavailable": "Estado no disponible",
+ "healthNeedsAttention": "Requiere atención",
+ "healthHealthy": "Funcionamiento correcto",
+ "reviewConflicts": "Revisar conflictos",
+ "help": "Usa una contraseña de aplicación de Nextcloud, no la de inicio de sesión: los usuarios de SSO deben crear una en Ajustes → Seguridad. Los contactos se sincronizan en ambos sentidos cuando el servidor permite escribir."
}
},
"ssoLinked": {
@@ -1331,7 +1330,8 @@
"search": "Buscar contactos…",
"empty": "Sin contactos aún",
"noResults": "No se encontraron contactos",
- "count": "{{count}} contactos",
+ "count_one": "{{count}} contacto",
+ "count_other": "{{count}} contactos",
"auto": "auto",
"autoHint": "Descubierto del correo recibido",
"selectHint": "Selecciona un contacto",
@@ -1360,7 +1360,74 @@
"home": "Casa",
"other": "Otro"
},
- "carddavBadge": "Sincronizado desde CardDAV"
+ "carddavSynced": "Sincronizado con CardDAV",
+ "carddavReadOnly": "CardDAV de solo lectura",
+ "carddavConflict": "Conflicto de CardDAV",
+ "carddavPending": "Sincronización pendiente",
+ "carddavWriteUnconfirmed": "Es posible que tu cambio ya se haya aplicado: se actualizó el contacto. Revísalo y vuelve a intentarlo si es necesario.",
+ "photo": {
+ "title": "Fotografía",
+ "contactAlt": "Foto del contacto",
+ "previewAlt": "Vista previa de la foto del contacto",
+ "present": "Foto disponible",
+ "none": "Sin foto",
+ "choose": "Elegir foto",
+ "remove": "Quitar foto",
+ "invalidType": "Elige una imagen JPEG o PNG.",
+ "tooLarge": "La foto debe ocupar 512 KiB o menos.",
+ "readFailed": "No se pudo leer la foto."
+ },
+ "additional": {
+ "title": "Campos adicionales",
+ "label": "Etiqueta",
+ "value": "Valor",
+ "add": "Agregar campo",
+ "street": "Calle",
+ "extendedAddress": "Detalles de dirección",
+ "locality": "Ciudad",
+ "region": "Estado o región",
+ "postalCode": "Código postal",
+ "country": "País",
+ "poBox": "Apartado postal",
+ "protocol": "Servicio de mensajería",
+ "handle": "Usuario o identificador",
+ "latitude": "Latitud",
+ "longitude": "Longitud",
+ "types": {
+ "postal-address": "Dirección postal",
+ "url": "Dirección web",
+ "im": "Mensajería instantánea",
+ "birthday": "Cumpleaños",
+ "anniversary": "Aniversario",
+ "date": "Fecha",
+ "role": "Función",
+ "title": "Cargo profesional",
+ "nickname": "Apodo",
+ "geo": "Coordenadas",
+ "custom-text": "Texto personalizado"
+ }
+ },
+ "conflicts": {
+ "title": "Conflictos de CardDAV",
+ "count_one": "{{count}} conflicto sin resolver",
+ "count_other": "{{count}} conflictos sin resolver",
+ "deleted": "Eliminado",
+ "photoPresent": "Hay una foto",
+ "photoAbsent": "No hay foto",
+ "loadFailed": "No se pudieron cargar los conflictos.",
+ "empty": "No hay conflictos de CardDAV sin resolver.",
+ "item": "Conflicto {{number}}",
+ "mailflowSide": "Versión de MailFlow",
+ "carddavSide": "Versión de CardDAV",
+ "resolveFailed": "No se pudo resolver el conflicto. Revisa ambas versiones e inténtalo de nuevo.",
+ "resolving": "Resolviendo…",
+ "keepMailflow": "Conservar la versión de MailFlow",
+ "keepCarddav": "Conservar la versión de CardDAV",
+ "openCount_one": "Revisar {{count}} conflicto de CardDAV",
+ "openCount_other": "Revisar {{count}} conflictos de CardDAV",
+ "refreshFailed": "No se pudo actualizar el contacto después de resolver el conflicto.",
+ "close": "Cerrar conflictos"
+ }
},
"todoist": {
"betaLabel": "Beta",
diff --git a/frontend/src/locales/fr.json b/frontend/src/locales/fr.json
index 976bc5a6..807c7e06 100644
--- a/frontend/src/locales/fr.json
+++ b/frontend/src/locales/fr.json
@@ -1259,8 +1259,7 @@
},
"carddav": {
"title": "Contacts CardDAV",
- "description": "Synchronisez les contacts depuis un serveur CardDAV comme Nextcloud.",
- "connected": "Connecté",
+ "description": "Synchronisez les contacts avec un serveur CardDAV comme Nextcloud.",
"notConnected": "Non connecté",
"serverLabel": "URL du serveur",
"serverPh": "https://cloud.exemple.com",
@@ -1268,10 +1267,6 @@
"userPh": "votre nom d'utilisateur Nextcloud",
"passLabel": "Mot de passe d'application",
"passPh": "mot de passe d'application (pas votre mot de passe de connexion)",
- "dupLabel": "Lorsqu'un contact existe déjà",
- "dupSeparate": "Garder les deux (carnet séparé)",
- "dupMerge": "Fusionner — CardDAV l'emporte",
- "dupSkip": "Ignorer le contact CardDAV",
"intervalLabel": "Intervalle de synchronisation (minutes)",
"connect": "Connecter",
"connecting": "Connexion…",
@@ -1282,7 +1277,11 @@
"lastSync": "Dernière synchro : {{when}}",
"summary": "{{contacts}} contacts dans {{books}} carnets",
"syncFailed": "Échec de la dernière synchro : {{error}}",
- "help": "Utilisez un mot de passe d'application Nextcloud, pas votre mot de passe de connexion — les utilisateurs SSO doivent en créer un dans Paramètres → Sécurité. Les contacts sont synchronisés à sens unique et en lecture seule dans MailFlow."
+ "healthUnavailable": "État indisponible",
+ "healthNeedsAttention": "Intervention nécessaire",
+ "healthHealthy": "Bon fonctionnement",
+ "reviewConflicts": "Examiner les conflits",
+ "help": "Utilisez un mot de passe d’application Nextcloud, pas votre mot de passe de connexion — les utilisateurs SSO doivent en créer un dans Paramètres → Sécurité. Les contacts sont synchronisés dans les deux sens lorsque le serveur autorise l’écriture."
}
},
"ssoLinked": {
@@ -1331,7 +1330,8 @@
"search": "Rechercher des contacts…",
"empty": "Aucun contact pour l'instant",
"noResults": "Aucun contact trouvé",
- "count": "{{count}} contacts",
+ "count_one": "{{count}} contact",
+ "count_other": "{{count}} contacts",
"auto": "auto",
"autoHint": "Découvert depuis les e-mails reçus",
"selectHint": "Sélectionnez un contact",
@@ -1360,7 +1360,74 @@
"home": "Domicile",
"other": "Autre"
},
- "carddavBadge": "Synchronisé depuis CardDAV"
+ "carddavSynced": "Synchronisé avec CardDAV",
+ "carddavReadOnly": "CardDAV en lecture seule",
+ "carddavConflict": "Conflit CardDAV",
+ "carddavPending": "Synchronisation en attente",
+ "carddavWriteUnconfirmed": "Votre modification a peut-être déjà été appliquée : le contact a été actualisé. Vérifiez-le et réessayez si nécessaire.",
+ "photo": {
+ "title": "Photographie",
+ "contactAlt": "Photo du contact",
+ "previewAlt": "Aperçu de la photo du contact",
+ "present": "Photo disponible",
+ "none": "Aucune photo",
+ "choose": "Choisir une photo",
+ "remove": "Retirer la photo",
+ "invalidType": "Choisissez une image JPEG ou PNG.",
+ "tooLarge": "La photo doit faire 512 Kio au maximum.",
+ "readFailed": "La photo n’a pas pu être lue."
+ },
+ "additional": {
+ "title": "Champs supplémentaires",
+ "label": "Libellé",
+ "value": "Valeur",
+ "add": "Ajouter un champ",
+ "street": "Rue",
+ "extendedAddress": "Complément d’adresse",
+ "locality": "Ville",
+ "region": "État ou région",
+ "postalCode": "Code postal",
+ "country": "Pays",
+ "poBox": "Boîte postale",
+ "protocol": "Service de messagerie",
+ "handle": "Nom d’utilisateur ou identifiant",
+ "latitude": "Latitude géographique",
+ "longitude": "Longitude géographique",
+ "types": {
+ "postal-address": "Adresse postale",
+ "url": "Adresse web",
+ "im": "Messagerie instantanée",
+ "birthday": "Date de naissance",
+ "anniversary": "Date anniversaire",
+ "date": "Autre date",
+ "role": "Rôle",
+ "title": "Intitulé du poste",
+ "nickname": "Surnom",
+ "geo": "Coordonnées",
+ "custom-text": "Texte personnalisé"
+ }
+ },
+ "conflicts": {
+ "title": "Conflits CardDAV",
+ "count_one": "{{count}} conflit non résolu",
+ "count_other": "{{count}} conflits non résolus",
+ "deleted": "Supprimé",
+ "photoPresent": "Une photo est présente",
+ "photoAbsent": "Photo absente",
+ "loadFailed": "Impossible de charger les conflits.",
+ "empty": "Aucun conflit CardDAV non résolu.",
+ "item": "Conflit n° {{number}}",
+ "mailflowSide": "Version de MailFlow",
+ "carddavSide": "Version de CardDAV",
+ "resolveFailed": "Impossible de résoudre le conflit. Vérifiez les deux versions et réessayez.",
+ "resolving": "Résolution en cours…",
+ "keepMailflow": "Conserver la version MailFlow",
+ "keepCarddav": "Conserver la version CardDAV",
+ "openCount_one": "Examiner {{count}} conflit CardDAV",
+ "openCount_other": "Examiner {{count}} conflits CardDAV",
+ "refreshFailed": "Impossible d’actualiser le contact après la résolution.",
+ "close": "Fermer les conflits"
+ }
},
"todoist": {
"betaLabel": "Bêta",
diff --git a/frontend/src/locales/i18n.test.js b/frontend/src/locales/i18n.test.js
index e266dc18..d4ffbf1c 100644
--- a/frontend/src/locales/i18n.test.js
+++ b/frontend/src/locales/i18n.test.js
@@ -103,6 +103,7 @@ import assert from 'node:assert/strict';
import { readFileSync, readdirSync } from 'node:fs';
import { join, dirname, resolve } from 'node:path';
import { fileURLToPath } from 'node:url';
+import i18next from 'i18next';
const dir = dirname(fileURLToPath(import.meta.url));
@@ -258,7 +259,8 @@ const SAME_VALUE_ALLOWED = {
// "auto" — universal technical loanword, same in all locales
'contacts.auto': 'any',
// "contacts" — same word in English and French
- 'contacts.count': [['en', 'fr']],
+ 'contacts.count_one': [['en', 'fr']],
+ 'contacts.count_other': [['en', 'fr']],
'contacts.title': [['en', 'fr']],
// "Email" — international term used as-is in en, es, it, ru, zhCN
'contacts.fields.email': [['en', 'es', 'it', 'ru', 'zhCN']],
@@ -351,6 +353,12 @@ const DYNAMIC_KEYS = new Set([
// appear as literals; the other three do via the tab pills).
'gtd.state.watch',
'gtd.state.delegated',
+ // t(`contacts.additional.types.${kind}`) — remaining Additional-field kinds.
+ 'contacts.additional.types.custom-text',
+ 'contacts.additional.types.date',
+ 'contacts.additional.types.geo',
+ 'contacts.additional.types.im',
+ 'contacts.additional.types.postal-address',
]);
// JSX attribute names whose values must never be plain strings — always t().
@@ -520,14 +528,39 @@ describe('i18n locale files', () => {
describe('key coverage — every key must appear in every locale', () => {
for (const lang of langs) {
it(`${lang} has no missing keys`, () => {
- const present = new Set(Object.keys(locales[lang]));
- const missing = allKeys.filter(k => !present.has(k));
+ const present = new Set(Object.keys(locales[lang]).map(baseKey));
+ const missing = [...new Set(allKeys.map(baseKey))].filter(k => !present.has(k));
assert.equal(missing.length, 0,
`Missing keys:\n${missing.map(k => ` - ${k}`).join('\n')}`);
});
}
});
+ it('uses locale-appropriate CardDAV and contact count plurals', async () => {
+ const bases = ['contacts.count', 'contacts.conflicts.count', 'contacts.conflicts.openCount'];
+ const suffixes = {
+ en: ['one', 'other'], de: ['one', 'other'], es: ['one', 'other'],
+ fr: ['one', 'other'], it: ['one', 'other'], ru: ['one', 'few', 'many'],
+ zhCN: ['other'],
+ };
+ for (const [lang, expected] of Object.entries(suffixes)) {
+ for (const base of bases) {
+ assert.deepEqual(
+ expected.filter(suffix => locales[lang][`${base}_${suffix}`] === undefined),
+ [],
+ `${lang} is missing plural forms for ${base}`,
+ );
+ }
+ }
+
+ const i18n = i18next.createInstance();
+ await i18n.init({
+ lng: 'en',
+ resources: { en: { translation: JSON.parse(readFileSync(join(dir, 'en.json'), 'utf8')) } },
+ });
+ assert.equal(i18n.t('contacts.conflicts.count', { count: 1 }), '1 unresolved conflict');
+ });
+
describe('value uniqueness — no unlisted locale pair should share a value for the same key', () => {
for (const key of allKeys) {
it(key, () => {
@@ -568,3 +601,77 @@ describe('i18n locale files', () => {
});
});
+
+// Regression guard for the contacts type-label overflow — upstream fix b837b93 / PR #242.
+// Stale pre-normalization DB
+// rows can carry a non-canonical contact type (e.g. a raw compound TYPE param like
+// "cell,voice,pref"). A dynamic `t(`contacts.phoneTypes.${type}`)` lookup with no
+// defaultValue returns the raw i18n key, which — being a long, unbreakable token — overflows
+// the fixed-width DetailRow label. DYNAMIC_KEYS above treats these template-literal keys as
+// "referenced", so Suite 1 never validated their runtime resolution and the class slipped past.
+function dynamicTypeLabelOffenders() {
+ const srcDir = resolve(dir, '..'); // frontend/src (excludes node_modules / build output)
+ const offenders = [];
+ (function walk(d) {
+ for (const entry of readdirSync(d, { withFileTypes: true })) {
+ const full = join(d, entry.name);
+ if (entry.isDirectory()) {
+ if (full !== dir) walk(full); // skip locales/ (this test's own directory)
+ continue;
+ }
+ if (!entry.name.endsWith('.jsx') && !entry.name.endsWith('.js')) continue;
+ readFileSync(full, 'utf8').split('\n').forEach((line, i) => {
+ const text = line.trim();
+ if (/contacts\.(?:phone|email)Types\.\$\{/.test(text) && !text.includes('defaultValue')) {
+ offenders.push(`${full.replace(srcDir + '/', '')}:${i + 1} ${text}`);
+ }
+ });
+ }
+ })(srcDir);
+ return offenders;
+}
+
+describe('contacts type labels — humanized fallback, never a raw i18n key', () => {
+ const nested = JSON.parse(readFileSync(join(dir, 'en.json'), 'utf8'));
+
+ it('resolves a non-canonical stored type to the humanized "other" label, not the key', async () => {
+ const i18n = i18next.createInstance();
+ await i18n.init({
+ lng: 'en',
+ fallbackLng: 'en',
+ resources: { en: { translation: nested } },
+ interpolation: { escapeValue: false },
+ });
+
+ const phoneOther = i18n.t('contacts.phoneTypes.other');
+ const emailOther = i18n.t('contacts.emailTypes.other');
+ assert.equal(phoneOther, 'Other'); // the defaultValue target exists and is humanized
+ assert.equal(emailOther, 'Other');
+
+ // A stale compound TYPE value has no canonical key; the guard's defaultValue resolves it
+ // to the humanized fallback instead of "contacts.phoneTypes.cell,voice,pref".
+ for (const type of ['cell,voice,pref', 'internet,work', 'fax']) {
+ const phoneLabel = i18n.t(`contacts.phoneTypes.${type}`, { defaultValue: phoneOther });
+ const emailLabel = i18n.t(`contacts.emailTypes.${type}`, { defaultValue: emailOther });
+ assert.equal(phoneLabel, 'Other');
+ assert.equal(emailLabel, 'Other');
+ assert.doesNotMatch(phoneLabel, /contacts\.(?:phone|email)Types\./);
+ assert.doesNotMatch(emailLabel, /contacts\.(?:phone|email)Types\./);
+ }
+
+ // The cell/iphone→mobile alias lands on the real canonical label.
+ assert.equal(i18n.t('contacts.phoneTypes.mobile', { defaultValue: phoneOther }), 'Mobile');
+
+ // Characterization of the underlying bug: WITHOUT the defaultValue, i18next returns the key.
+ assert.equal(i18n.t('contacts.phoneTypes.cell,voice,pref'),
+ 'contacts.phoneTypes.cell,voice,pref');
+ });
+
+ it('never lets a dynamic contacts type-label lookup omit its defaultValue guard', () => {
+ const offenders = dynamicTypeLabelOffenders();
+ assert.deepEqual(offenders, [],
+ 'A dynamic contacts type-label lookup with no { defaultValue } renders the raw i18n key '
+ + 'for a non-canonical stored type (see b837b93 / PR #242):\n'
+ + offenders.map(line => ` ${line}`).join('\n'));
+ });
+});
diff --git a/frontend/src/locales/it.json b/frontend/src/locales/it.json
index 1368084b..10daf2e1 100644
--- a/frontend/src/locales/it.json
+++ b/frontend/src/locales/it.json
@@ -1259,8 +1259,7 @@
},
"carddav": {
"title": "Contatti CardDAV",
- "description": "Sincronizza i contatti da un server CardDAV come Nextcloud.",
- "connected": "Connesso",
+ "description": "Sincronizza i contatti con un server CardDAV come Nextcloud.",
"notConnected": "Non connesso",
"serverLabel": "URL del server",
"serverPh": "https://cloud.esempio.com",
@@ -1268,10 +1267,6 @@
"userPh": "il tuo nome utente Nextcloud",
"passLabel": "Password dell'app",
"passPh": "password app (non quella di accesso)",
- "dupLabel": "Quando un contatto esiste già",
- "dupSeparate": "Mantieni entrambi (rubrica separata)",
- "dupMerge": "Unisci — vince CardDAV",
- "dupSkip": "Salta il contatto CardDAV",
"intervalLabel": "Intervallo di sincronizzazione (minuti)",
"connect": "Connetti",
"connecting": "Connessione…",
@@ -1282,7 +1277,11 @@
"lastSync": "Ultima sincronizzazione: {{when}}",
"summary": "{{contacts}} contatti in {{books}} rubriche",
"syncFailed": "Ultima sincronizzazione non riuscita: {{error}}",
- "help": "Usa una password app di Nextcloud, non quella di accesso: gli utenti SSO devono crearne una in Impostazioni → Sicurezza. I contatti sono sincronizzati a senso unico e di sola lettura in MailFlow."
+ "healthUnavailable": "Stato non disponibile",
+ "healthNeedsAttention": "Richiede attenzione",
+ "healthHealthy": "Servizio regolare",
+ "reviewConflicts": "Esamina i conflitti",
+ "help": "Usa una password app di Nextcloud, non quella di accesso: gli utenti SSO devono crearne una in Impostazioni → Sicurezza. I contatti vengono sincronizzati in entrambe le direzioni quando il server consente la scrittura."
}
},
"ssoLinked": {
@@ -1331,7 +1330,8 @@
"search": "Cerca contatti…",
"empty": "Nessun contatto ancora",
"noResults": "Nessun contatto trovato",
- "count": "{{count}} contatti",
+ "count_one": "{{count}} contatto",
+ "count_other": "{{count}} contatti",
"auto": "auto",
"autoHint": "Rilevato da email ricevute",
"selectHint": "Seleziona un contatto",
@@ -1360,7 +1360,74 @@
"home": "Casa",
"other": "Altro"
},
- "carddavBadge": "Sincronizzato da CardDAV"
+ "carddavSynced": "Sincronizzato con CardDAV",
+ "carddavReadOnly": "CardDAV in sola lettura",
+ "carddavConflict": "Conflitto CardDAV",
+ "carddavPending": "Sincronizzazione in sospeso",
+ "carddavWriteUnconfirmed": "La tua modifica potrebbe essere già stata applicata: il contatto è stato aggiornato. Verifica e riprova se necessario.",
+ "photo": {
+ "title": "Immagine",
+ "contactAlt": "Foto del contatto",
+ "previewAlt": "Anteprima della foto del contatto",
+ "present": "Foto disponibile",
+ "none": "Nessuna foto",
+ "choose": "Scegli foto",
+ "remove": "Rimuovi foto",
+ "invalidType": "Scegli un’immagine JPEG o PNG.",
+ "tooLarge": "La foto deve essere di 512 KiB o meno.",
+ "readFailed": "Non è stato possibile leggere la foto."
+ },
+ "additional": {
+ "title": "Campi aggiuntivi",
+ "label": "Etichetta",
+ "value": "Contenuto",
+ "add": "Aggiungi campo",
+ "street": "Via",
+ "extendedAddress": "Dettagli indirizzo",
+ "locality": "Città",
+ "region": "Provincia o regione",
+ "postalCode": "Codice postale",
+ "country": "Paese",
+ "poBox": "Casella postale",
+ "protocol": "Servizio di messaggistica",
+ "handle": "Utente o identificativo",
+ "latitude": "Latitudine nord-sud",
+ "longitude": "Longitudine est-ovest",
+ "types": {
+ "postal-address": "Indirizzo postale",
+ "url": "Indirizzo web",
+ "im": "Messaggistica istantanea",
+ "birthday": "Compleanno",
+ "anniversary": "Ricorrenza",
+ "date": "Data personale",
+ "role": "Ruolo",
+ "title": "Titolo professionale",
+ "nickname": "Soprannome",
+ "geo": "Coordinate",
+ "custom-text": "Testo personalizzato"
+ }
+ },
+ "conflicts": {
+ "title": "Conflitti CardDAV",
+ "count_one": "{{count}} conflitto non risolto",
+ "count_other": "{{count}} conflitti non risolti",
+ "deleted": "Cancellato",
+ "photoPresent": "Foto presente",
+ "photoAbsent": "Foto non presente",
+ "loadFailed": "Impossibile caricare i conflitti.",
+ "empty": "Non ci sono conflitti CardDAV irrisolti.",
+ "item": "Conflitto numero {{number}}",
+ "mailflowSide": "Versione MailFlow",
+ "carddavSide": "Versione CardDAV",
+ "resolveFailed": "Impossibile risolvere il conflitto. Controlla entrambe le versioni e riprova.",
+ "resolving": "Risoluzione…",
+ "keepMailflow": "Mantieni la versione MailFlow",
+ "keepCarddav": "Mantieni la versione CardDAV",
+ "openCount_one": "Esamina {{count}} conflitto CardDAV",
+ "openCount_other": "Esamina {{count}} conflitti CardDAV",
+ "refreshFailed": "Impossibile aggiornare il contatto dopo la risoluzione.",
+ "close": "Chiudi i conflitti"
+ }
},
"todoist": {
"betaLabel": "Beta",
diff --git a/frontend/src/locales/ru.json b/frontend/src/locales/ru.json
index 3fba0b04..8b49e37d 100644
--- a/frontend/src/locales/ru.json
+++ b/frontend/src/locales/ru.json
@@ -1259,8 +1259,7 @@
},
"carddav": {
"title": "Контакты CardDAV",
- "description": "Синхронизация контактов с сервера CardDAV, например Nextcloud.",
- "connected": "Подключено",
+ "description": "Синхронизация контактов с сервером CardDAV, например Nextcloud.",
"notConnected": "Не подключено",
"serverLabel": "URL сервера",
"serverPh": "https://cloud.example.ru",
@@ -1268,10 +1267,6 @@
"userPh": "ваше имя пользователя Nextcloud",
"passLabel": "Пароль приложения",
"passPh": "пароль приложения (не пароль для входа)",
- "dupLabel": "Когда контакт уже существует",
- "dupSeparate": "Оставить оба (отдельная книга)",
- "dupMerge": "Объединить — приоритет CardDAV",
- "dupSkip": "Пропустить контакт CardDAV",
"intervalLabel": "Интервал синхронизации (минуты)",
"connect": "Подключить",
"connecting": "Подключение…",
@@ -1282,7 +1277,11 @@
"lastSync": "Последняя синхронизация: {{when}}",
"summary": "{{contacts}} контактов в {{books}} книгах",
"syncFailed": "Последняя синхронизация не удалась: {{error}}",
- "help": "Используйте пароль приложения Nextcloud, а не пароль для входа — пользователям SSO нужно создать его в Настройки → Безопасность. Контакты синхронизируются в одну сторону и доступны только для чтения в MailFlow."
+ "healthUnavailable": "Состояние недоступно",
+ "healthNeedsAttention": "Требует внимания",
+ "healthHealthy": "Работает исправно",
+ "reviewConflicts": "Проверить конфликты",
+ "help": "Используйте пароль приложения Nextcloud, а не пароль для входа — пользователям SSO нужно создать его в Настройки → Безопасность. Контакты синхронизируются в обоих направлениях, если сервер разрешает запись."
}
},
"ssoLinked": {
@@ -1331,7 +1330,9 @@
"search": "Поиск контактов…",
"empty": "Нет контактов",
"noResults": "Контакты не найдены",
- "count": "{{count}} контактов",
+ "count_one": "{{count}} контакт",
+ "count_few": "{{count}} контакта",
+ "count_many": "{{count}} контактов",
"auto": "auto",
"autoHint": "Обнаружен из входящей почты",
"selectHint": "Выберите контакт",
@@ -1360,7 +1361,76 @@
"home": "Дом",
"other": "Другой"
},
- "carddavBadge": "Синхронизировано из CardDAV"
+ "carddavSynced": "Синхронизировано с CardDAV",
+ "carddavReadOnly": "CardDAV только для чтения",
+ "carddavConflict": "Конфликт CardDAV",
+ "carddavPending": "Ожидает синхронизации",
+ "carddavWriteUnconfirmed": "Возможно, изменение уже применено — контакт обновлён. Проверьте его и при необходимости повторите.",
+ "photo": {
+ "title": "Фотография",
+ "contactAlt": "Фотография контакта",
+ "previewAlt": "Предпросмотр фотографии контакта",
+ "present": "Фотография доступна",
+ "none": "Фотографии нет",
+ "choose": "Выбрать фотографию",
+ "remove": "Удалить фотографию",
+ "invalidType": "Выберите изображение JPEG или PNG.",
+ "tooLarge": "Размер фотографии не должен превышать 512 КиБ.",
+ "readFailed": "Не удалось прочитать фотографию."
+ },
+ "additional": {
+ "title": "Дополнительные поля",
+ "label": "Подпись",
+ "value": "Значение",
+ "add": "Добавить поле",
+ "street": "Улица",
+ "extendedAddress": "Дополнение к адресу",
+ "locality": "Город",
+ "region": "Область или регион",
+ "postalCode": "Почтовый индекс",
+ "country": "Страна",
+ "poBox": "Абонентский ящик",
+ "protocol": "Служба сообщений",
+ "handle": "Имя пользователя или идентификатор",
+ "latitude": "Географическая широта",
+ "longitude": "Географическая долгота",
+ "types": {
+ "postal-address": "Почтовый адрес",
+ "url": "Веб-адрес",
+ "im": "Мгновенные сообщения",
+ "birthday": "День рождения",
+ "anniversary": "Годовщина",
+ "date": "Особая дата",
+ "role": "Роль",
+ "title": "Должность",
+ "nickname": "Псевдоним",
+ "geo": "Координаты",
+ "custom-text": "Произвольный текст"
+ }
+ },
+ "conflicts": {
+ "title": "Конфликты CardDAV",
+ "count_one": "{{count}} неразрешённый конфликт",
+ "count_few": "{{count}} неразрешённых конфликта",
+ "count_many": "{{count}} неразрешённых конфликтов",
+ "deleted": "Удалено",
+ "photoPresent": "Фотография присутствует",
+ "photoAbsent": "Фотография отсутствует",
+ "loadFailed": "Не удалось загрузить конфликты.",
+ "empty": "Неразрешённых конфликтов CardDAV нет.",
+ "item": "Конфликт № {{number}}",
+ "mailflowSide": "Версия MailFlow",
+ "carddavSide": "Версия CardDAV",
+ "resolveFailed": "Не удалось разрешить конфликт. Проверьте обе версии и повторите попытку.",
+ "resolving": "Разрешение…",
+ "keepMailflow": "Оставить версию MailFlow",
+ "keepCarddav": "Оставить версию CardDAV",
+ "openCount_one": "Проверить {{count}} конфликт CardDAV",
+ "openCount_few": "Проверить {{count}} конфликта CardDAV",
+ "openCount_many": "Проверить {{count}} конфликтов CardDAV",
+ "refreshFailed": "Не удалось обновить контакт после разрешения конфликта.",
+ "close": "Закрыть конфликты"
+ }
},
"todoist": {
"betaLabel": "Бета",
diff --git a/frontend/src/locales/zhCN.json b/frontend/src/locales/zhCN.json
index 09edcc98..3dec5a5c 100644
--- a/frontend/src/locales/zhCN.json
+++ b/frontend/src/locales/zhCN.json
@@ -1259,8 +1259,7 @@
},
"carddav": {
"title": "CardDAV 联系人",
- "description": "从 Nextcloud 等 CardDAV 服务器同步联系人。",
- "connected": "已连接",
+ "description": "与 Nextcloud 等 CardDAV 服务器同步联系人。",
"notConnected": "未连接",
"serverLabel": "服务器地址",
"serverPh": "https://nextcloud.example.com",
@@ -1268,10 +1267,6 @@
"userPh": "你的 Nextcloud 用户名",
"passLabel": "应用专用密码",
"passPh": "应用专用密码（非登录密码）",
- "dupLabel": "当联系人已存在时",
- "dupSeparate": "保留两者（单独的通讯簿）",
- "dupMerge": "合并 — 以 CardDAV 为准",
- "dupSkip": "跳过该 CardDAV 联系人",
"intervalLabel": "同步间隔（分钟）",
"connect": "连接",
"connecting": "正在连接…",
@@ -1282,7 +1277,11 @@
"lastSync": "上次同步：{{when}}",
"summary": "{{books}} 个通讯簿中的 {{contacts}} 个联系人",
"syncFailed": "上次同步失败：{{error}}",
- "help": "请使用 Nextcloud 应用专用密码，而非登录密码——SSO 用户需在“设置 → 安全”中创建。联系人为单向同步，在 MailFlow 中为只读。"
+ "healthUnavailable": "无法获取运行状态",
+ "healthNeedsAttention": "需要处理",
+ "healthHealthy": "运行正常",
+ "reviewConflicts": "查看冲突",
+ "help": "请使用 Nextcloud 应用专用密码，而非登录密码——SSO 用户需在“设置 → 安全”中创建。当服务器允许写入时，联系人会双向同步。"
}
},
"ssoLinked": {
@@ -1331,7 +1330,7 @@
"search": "搜索联系人…",
"empty": "暂无联系人",
"noResults": "未找到联系人",
- "count": "{{count}} 个联系人",
+ "count_other": "{{count}} 个联系人",
"auto": "auto",
"autoHint": "从收件中自动发现",
"selectHint": "选择联系人",
@@ -1360,7 +1359,72 @@
"home": "家庭",
"other": "其他"
},
- "carddavBadge": "从 CardDAV 同步"
+ "carddavSynced": "已与 CardDAV 同步",
+ "carddavReadOnly": "CardDAV 只读联系人",
+ "carddavConflict": "CardDAV 数据冲突",
+ "carddavPending": "同步待处理",
+ "carddavWriteUnconfirmed": "您的更改可能已经生效——联系人已刷新。请检查后按需重试。",
+ "photo": {
+ "title": "头像",
+ "contactAlt": "联系人头像",
+ "previewAlt": "联系人头像预览",
+ "present": "已有头像",
+ "none": "暂无头像",
+ "choose": "选择头像",
+ "remove": "移除头像",
+ "invalidType": "请选择 JPEG 或 PNG 图片。",
+ "tooLarge": "头像大小不得超过 512 KiB。",
+ "readFailed": "无法读取所选头像。"
+ },
+ "additional": {
+ "title": "其他信息",
+ "label": "字段名称",
+ "value": "字段内容",
+ "add": "添加字段",
+ "street": "街道",
+ "extendedAddress": "详细地址",
+ "locality": "城市",
+ "region": "省份或地区",
+ "postalCode": "邮政编码",
+ "country": "国家或地区",
+ "poBox": "邮政信箱",
+ "protocol": "通讯服务",
+ "handle": "用户名或账号",
+ "latitude": "纬度",
+ "longitude": "经度",
+ "types": {
+ "postal-address": "邮寄地址",
+ "url": "网址",
+ "im": "即时通讯",
+ "birthday": "生日",
+ "anniversary": "纪念日",
+ "date": "其他日期",
+ "role": "职务",
+ "title": "职位名称",
+ "nickname": "昵称",
+ "geo": "地理坐标",
+ "custom-text": "自定义文本"
+ }
+ },
+ "conflicts": {
+ "title": "CardDAV 冲突",
+ "count_other": "{{count}} 个未解决的冲突",
+ "deleted": "已删除",
+ "photoPresent": "包含头像",
+ "photoAbsent": "不含头像",
+ "loadFailed": "无法加载冲突列表。",
+ "empty": "没有未解决的 CardDAV 冲突。",
+ "item": "第 {{number}} 个冲突",
+ "mailflowSide": "MailFlow 中的版本",
+ "carddavSide": "CardDAV 中的版本",
+ "resolveFailed": "无法解决此冲突。请检查两个版本后重试。",
+ "resolving": "正在解决…",
+ "keepMailflow": "保留 MailFlow 版本",
+ "keepCarddav": "保留 CardDAV 版本",
+ "openCount_other": "查看 {{count}} 个 CardDAV 冲突",
+ "refreshFailed": "解决冲突后无法刷新联系人。",
+ "close": "关闭冲突列表"
+ }
},
"todoist": {
"betaLabel": "测试版",
diff --git a/frontend/src/utils/api.js b/frontend/src/utils/api.js
index 64e1346d..3697d359 100644
--- a/frontend/src/utils/api.js
+++ b/frontend/src/utils/api.js
@@ -23,8 +23,12 @@ async function request(method, path, body, extraHeaders) {
if (res.status === 401 && !path.startsWith('/auth/')) {
window.dispatchEvent(new CustomEvent('mailflow:session_expired'));
}
- const err = await res.json().catch(() => ({ error: 'Request failed' }));
- throw new Error(err.error || 'Request failed');
+ const data = await res.json().catch(() => ({ error: 'Request failed' }));
+ const error = new Error(data.error || 'Request failed');
+ error.status = res.status;
+ error.data = data;
+ if (typeof data.conflictId === 'string') error.conflictId = data.conflictId;
+ throw error;
}
return res.json();
}
@@ -211,6 +215,12 @@ export const api = {
update: (data) => request('PATCH', '/carddav', data),
sync: () => request('POST', '/carddav/sync'),
disconnect: () => request('DELETE', '/carddav'),
+ getConflicts: () => request('GET', '/carddav/conflicts'),
+ resolveConflict: (id, resolution) => request(
+ 'POST',
+ `/carddav/conflicts/${encodeURIComponent(id)}/resolve`,
+ { resolution },
+ ),
},
// Image whitelist
+ ) : (
+