resolve merge conflicts

Author: callumalpass

src/modals/TaskEditModal.ts

@@ -548,9 +548,12 @@ export class TaskEditModal extends TaskModal {
             // If task has recurrence, update scheduled date to next uncompleted occurrence
             if (this.task.recurrence) {
                 const tempTask: TaskInfo = { ...this.task, ...changes };
-                const nextScheduledDate = updateToNextScheduledOccurrence(tempTask);
-                if (nextScheduledDate) {
-                    changes.scheduled = nextScheduledDate;
+                const nextDates = updateToNextScheduledOccurrence(tempTask, this.plugin.settings.maintainDueDateOffsetInRecurring);
+                if (nextDates.scheduled) {
+                    changes.scheduled = nextDates.scheduled;
+                }
+                if (nextDates.due) {
+                    changes.due = nextDates.due;
                 }
             }
         }

src/services/TaskService.ts

@@ -949,9 +949,12 @@ export class TaskService {
             if (updates.recurrence !== undefined && updates.recurrence !== originalTask.recurrence) {
                 // Recurrence rule changed, calculate new scheduled date
                 const tempTask: TaskInfo = { ...originalTask, ...updates };
-                const nextScheduledDate = updateToNextScheduledOccurrence(tempTask);
-                if (nextScheduledDate) {
-                    recurrenceUpdates.scheduled = nextScheduledDate;
+                const nextDates = updateToNextScheduledOccurrence(tempTask, this.plugin.settings.maintainDueDateOffsetInRecurring);
+                if (nextDates.scheduled) {
+                    recurrenceUpdates.scheduled = nextDates.scheduled;
+                }
+                if (nextDates.due) {
+                    recurrenceUpdates.due = nextDates.due;
                 }
 
                 // Add DTSTART to recurrence rule if it's missing (scenario 1: editing recurrence rule)
@@ -1230,16 +1233,20 @@ export class TaskService {
         }
 
         // Update scheduled date to next uncompleted occurrence
-        const nextScheduledDate = updateToNextScheduledOccurrence(updatedTask);
-        if (nextScheduledDate) {
-            updatedTask.scheduled = nextScheduledDate;
+        const nextDates = updateToNextScheduledOccurrence(updatedTask, this.plugin.settings.maintainDueDateOffsetInRecurring);
+        if (nextDates.scheduled) {
+            updatedTask.scheduled = nextDates.scheduled;
+        }
+        if (nextDates.due) {
+            updatedTask.due = nextDates.due;
         }
 
         // Step 2: Persist to file
         await this.plugin.app.fileManager.processFrontMatter(file, (frontmatter) => {
             const completeInstancesField = this.plugin.fieldMapper.toUserField('completeInstances');
             const dateModifiedField = this.plugin.fieldMapper.toUserField('dateModified');
             const scheduledField = this.plugin.fieldMapper.toUserField('scheduled');
+            const dueField = this.plugin.fieldMapper.toUserField('due');
             const recurrenceField = this.plugin.fieldMapper.toUserField('recurrence');
 
             // Ensure complete_instances array exists
@@ -1268,6 +1275,12 @@ export class TaskService {
             if (updatedTask.scheduled) {
                 frontmatter[scheduledField] = updatedTask.scheduled;
             }
+
+            // Update due date if it changed
+            if (updatedTask.due) {
+                frontmatter[dueField] = updatedTask.due;
+            }
+
 
             frontmatter[dateModifiedField] = updatedTask.dateModified;
         });
@@ -1282,6 +1295,9 @@ export class TaskService {
                 if (updatedTask.scheduled !== freshTask.scheduled) {
                     expectedChanges.scheduled = updatedTask.scheduled;
                 }
+                if (updatedTask.due !== freshTask.due) {
+                    expectedChanges.due = updatedTask.due;
+                }
                 await this.plugin.cacheManager.waitForFreshTaskData(file, expectedChanges);
             }
             await this.plugin.cacheManager.updateTaskInfoInCache(freshTask.path, updatedTask);

src/settings/defaults.ts

@@ -241,5 +241,7 @@ export const DEFAULT_SETTINGS: TaskNotesSettings = {
 		'projects',    // Projects
 		'contexts',    // Contexts
 		'tags'         // Tags
-	]
+	],
+	// Recurring task behavior defaults
+	maintainDueDateOffsetInRecurring: false
 };

src/settings/settings.ts

@@ -1876,6 +1876,20 @@ export class TaskNotesSettingTab extends PluginSettingTab {
 						await this.plugin.saveSettings();
 					});
 			});
+
+		// Recurring task due date behavior
+		new Setting(container)
+			.setName('Maintain due date offset in recurring tasks')
+			.setDesc('When completing a recurring task, move the due date by the same offset as the scheduled date to preserve the time separation between them')
+			.addToggle(toggle => {
+				toggle.toggleEl.setAttribute('aria-label', 'Maintain due date offset in recurring tasks');
+				return toggle
+					.setValue(this.plugin.settings.maintainDueDateOffsetInRecurring)
+					.onChange(async (value) => {
+						this.plugin.settings.maintainDueDateOffsetInRecurring = value;
+						await this.plugin.saveSettings();
+					});
+			});
 	}
 
 	private renderFieldMappingTab(): void {

src/types/settings.ts

@@ -103,6 +103,8 @@ export interface TaskNotesSettings {
 	userField?: UserFieldMapping;
 	// Default visible properties for task cards (when no saved view is active)
 	defaultVisibleProperties?: string[];
+	// Recurring task behavior
+	maintainDueDateOffsetInRecurring: boolean;
 }
 
 export interface DefaultReminder {

src/utils/helpers.ts

@@ -669,20 +669,56 @@ export function getNextUncompletedOccurrence(task: TaskInfo): Date | null {
 /**
  * Updates the scheduled date of a recurring task to its next uncompleted occurrence
  * Returns the updated scheduled date or null if no next occurrence
+ * @param task Task info object
+ * @param maintainDueOffset Whether to maintain the due date offset (from settings)
  */
-export function updateToNextScheduledOccurrence(task: TaskInfo): string | null {
+export function updateToNextScheduledOccurrence(task: TaskInfo, maintainDueOffset: boolean = true): { scheduled: string | null; due: string | null } {
 	const nextOccurrence = getNextUncompletedOccurrence(task);
-	if (!nextOccurrence) {
-		return null;
-	}
+	let nextScheduleStr: string | null = null;
+	let nextDueStr: string | null = null;
+	let nextDueDate: Date | null = null;
+
+	if (nextOccurrence) {
+		
+		// Calculate the offset between original scheduled and due dates (only if setting is enabled)
+		if (maintainDueOffset) {
+			try {
+				const originalScheduled = task.scheduled ? parseDateToUTC(task.scheduled) : null;
+				const originalDue = task.due ? parseDateToUTC(task.due): null;
+
+				if (originalScheduled && originalDue) {
+					// Calculate the time difference
+					const offsetMs = originalDue.getTime() - originalScheduled.getTime();
+					if(nextOccurrence) {
+						// Apply the same offset to get the new due date
+						nextDueDate = new Date(nextOccurrence.getTime() + offsetMs);
+					}
+				}
+			} catch (error) {
+				console.error('Error calculating next due date with offset:', error);
+			}
+		}
 
-	// Preserve time component if original scheduled date had time
-	if (task.scheduled && task.scheduled.includes('T')) {
-		const timePart = task.scheduled.split('T')[1];
-		return `${formatDateForStorage(nextOccurrence)}T${timePart}`;
-	} else {
-		return formatDateForStorage(nextOccurrence);
+		// Preserve time component if original scheduled date had time
+		if (task.scheduled && task.scheduled.includes('T')) {
+			const timePart = task.scheduled.split('T')[1];
+			nextScheduleStr = `${formatDateForStorage(nextOccurrence)}T${timePart}`;
+		} else {
+			nextScheduleStr = formatDateForStorage(nextOccurrence);
+		}
+		if (nextDueDate && task.due && task.due.includes('T')) {
+			const timePart = task.due.split('T')[1];
+			nextDueStr = `${formatDateForStorage(nextDueDate)}T${timePart}`;
+		} else if (nextDueDate) {
+			nextDueStr = formatDateForStorage(nextDueDate);
+		}
 	}
+
+	return {
+		scheduled: nextScheduleStr,
+		due: nextDueStr
+	}
+
 }
 
 /**