Add periodic bookmarks sync with configurable interval

- Implement syncSiblings() to reorder bookmarks to match file explorer order and remove orphaned entries

- Add configurable sync interval setting (0 = disabled, up to 3600s)

- Start/stop sync timer on setting change and plugin lifecycle

- Sync bookmarks immediately on new file/folder creation

Author: andreas13xxx

src/main.ts

@@ -103,6 +103,8 @@ export default class CustomSortPlugin
 
 	uninstallerOfFileExplorerPatch: MonkeyAroundUninstaller|undefined = undefined
 
+	bookmarksSyncTimerId: ReturnType<typeof setInterval> | undefined = undefined
+
 	showNotice(message: string, timeout?: number) {
 		if (this.settings.notificationsEnabled || (Platform.isMobile && this.settings.mobileNotificationsEnabled)) {
 			new Notice(message, timeout)
@@ -374,6 +376,8 @@ export default class CustomSortPlugin
 		this.registerPluginUnloadHandler()
 
 		this.initialize();
+
+		this.restartBookmarksSyncTimer();
 	}
 
 	registerEventHandlers() {
@@ -582,6 +586,16 @@ export default class CustomSortPlugin
 				bookmarksPlugin.saveDataAndUpdateBookmarkViews(true)
 			}
 		})
+
+		this.app.vault.on("create", (file: TAbstractFile) => {
+			if (plugin.settings.bookmarksSyncIntervalSeconds <= 0) return
+			const bookmarksPlugin = getBookmarksPlugin(plugin.app, plugin.settings.bookmarksGroupToConsumeAsOrderingReference)
+			if (bookmarksPlugin && file.parent) {
+				const orderedChildren: Array<TAbstractFile> = plugin.orderedFolderItemsForBookmarking(file.parent, bookmarksPlugin)
+				bookmarksPlugin.syncSiblings(orderedChildren)
+				bookmarksPlugin.saveDataAndUpdateBookmarkViews(true)
+			}
+		})
 	}
 
 	uninstallFileExplorerPatchIfInstalled() {
@@ -697,9 +711,9 @@ export default class CustomSortPlugin
 	}
 
 	syncBookmarksRecursive(folder: TFolder, bookmarksPlugin: BookmarksPluginInterface): void {
-		// Sync the current folder: bookmark all children that are not yet bookmarked (appended at end)
+		// Sync the current folder: reorder bookmarks to match file explorer order and remove orphans
 		const orderedChildren: Array<TAbstractFile> = this.orderedFolderItemsForBookmarking(folder, bookmarksPlugin)
-		bookmarksPlugin.bookmarkSiblings(orderedChildren)
+		bookmarksPlugin.syncSiblings(orderedChildren)
 
 		// Recurse into subfolders
 		for (const child of folder.children) {
@@ -709,7 +723,36 @@ export default class CustomSortPlugin
 		}
 	}
 
+	runBookmarksSyncForVault(): void {
+		if (this.settings.suspended) return
+		const bookmarksPlugin = getBookmarksPlugin(this.app, this.settings.bookmarksGroupToConsumeAsOrderingReference)
+		if (!bookmarksPlugin) return
+		const rootFolder: TFolder = this.app.vault.getRoot()
+		this.syncBookmarksRecursive(rootFolder, bookmarksPlugin)
+		bookmarksPlugin.saveDataAndUpdateBookmarkViews(true)
+	}
+
+	restartBookmarksSyncTimer(): void {
+		// Clear existing timer
+		if (this.bookmarksSyncTimerId !== undefined) {
+			clearInterval(this.bookmarksSyncTimerId)
+			this.bookmarksSyncTimerId = undefined
+		}
+
+		// Start new timer if interval > 0
+		const intervalSeconds = this.settings.bookmarksSyncIntervalSeconds
+		if (intervalSeconds > 0) {
+			this.bookmarksSyncTimerId = setInterval(() => {
+				this.runBookmarksSyncForVault()
+			}, intervalSeconds * 1000)
+		}
+	}
+
 	onunload() {
+		if (this.bookmarksSyncTimerId !== undefined) {
+			clearInterval(this.bookmarksSyncTimerId)
+			this.bookmarksSyncTimerId = undefined
+		}
 	}
 
 	onUserEnable() {

src/settings.ts

@@ -14,6 +14,7 @@ export interface CustomSortPluginSettings {
     bookmarksContextMenus: boolean
     bookmarksGroupToConsumeAsOrderingReference: string
     delayForInitialApplication: number // miliseconds
+    bookmarksSyncIntervalSeconds: number // 0 = disabled
 }
 
 const MILIS = 1000
@@ -22,6 +23,10 @@ const DELAY_MIN_SECONDS = 0
 const DELAY_MAX_SECONDS = 30
 const DEFAULT_DELAY = DEFAULT_DELAY_SECONDS * MILIS
 
+const SYNC_INTERVAL_MIN_SECONDS = 0
+const SYNC_INTERVAL_MAX_SECONDS = 3600
+const DEFAULT_SYNC_INTERVAL_SECONDS = 0
+
 export const DEFAULT_SETTINGS: CustomSortPluginSettings = {
     additionalSortspecFile: '',
     indexNoteNameForFolderNotes: '',
@@ -33,7 +38,8 @@ export const DEFAULT_SETTINGS: CustomSortPluginSettings = {
     automaticBookmarksIntegration: false,
     bookmarksContextMenus: false,
     bookmarksGroupToConsumeAsOrderingReference: 'sortspec',
-    delayForInitialApplication: DEFAULT_DELAY
+    delayForInitialApplication: DEFAULT_DELAY,
+    bookmarksSyncIntervalSeconds: DEFAULT_SYNC_INTERVAL_SECONDS
 }
 
 // On API 1.2.x+ enable the bookmarks integration by default
@@ -246,5 +252,29 @@ export class CustomSortSettingTab extends PluginSettingTab {
                     }
                     await this.plugin.saveSettings();
                 }))
+
+        const bookmarksSyncIntervalDescr: DocumentFragment = sanitizeHTMLToDom(
+            'Interval in seconds for automatic synchronization of bookmarks with the file explorer order.'
+            + '<br>'
+            + 'Set to <b>0</b> to disable automatic sync (manual sync via context menu is still available).'
+            + '<br>'
+            + 'When enabled, the plugin will periodically ensure that bookmarks reflect the current file/folder structure and sorting order.'
+            + '<br>'
+            + `Min: ${SYNC_INTERVAL_MIN_SECONDS} sec., max: ${SYNC_INTERVAL_MAX_SECONDS} sec.`
+        )
+
+        new Setting(containerEl)
+            .setName('Automatic bookmarks sync interval')
+            .setDesc(bookmarksSyncIntervalDescr)
+            .addText(text => text
+                .setPlaceholder('0')
+                .setValue(`${this.plugin.settings.bookmarksSyncIntervalSeconds}`)
+                .onChange(async (value) => {
+                    let interval = parseInt(value)
+                    interval = (Number.isNaN(interval) || !Number.isFinite(interval)) ? DEFAULT_SYNC_INTERVAL_SECONDS : (interval < SYNC_INTERVAL_MIN_SECONDS ? SYNC_INTERVAL_MIN_SECONDS : (interval > SYNC_INTERVAL_MAX_SECONDS ? SYNC_INTERVAL_MAX_SECONDS : interval))
+                    this.plugin.settings.bookmarksSyncIntervalSeconds = interval
+                    await this.plugin.saveSettings()
+                    this.plugin.restartBookmarksSyncTimer()
+                }))
     }
 }

src/utils/BookmarksCorePluginSignature.ts

@@ -82,6 +82,7 @@ export interface BookmarksPluginInterface {
     saveDataAndUpdateBookmarkViews(updateBookmarkViews: boolean): void
     bookmarkSiblings(siblings: Array<TAbstractFile>, inTheTop?: boolean): void
     unbookmarkSiblings(siblings: Array<TAbstractFile>): void
+    syncSiblings(orderedSiblings: Array<TAbstractFile>): void
     updateSortingBookmarksAfterItemRenamed(renamedItem: TAbstractFile, oldPath: string): void
     updateSortingBookmarksAfterItemDeleted(deletedItem: TAbstractFile): void
     isBookmarkedForSorting(item: TAbstractFile): boolean
@@ -230,6 +231,58 @@ class BookmarksPluginWrapper implements BookmarksPluginInterface {
         }
     }
 
+    // Sync bookmarks to match the given ordered siblings exactly:
+    // - Reorder existing bookmark entries to match the order of orderedSiblings
+    // - Add missing items at their correct position
+    // - Remove orphaned entries (items in bookmarks that are not in orderedSiblings)
+    syncSiblings = (orderedSiblings: Array<TAbstractFile>) => {
+        if (orderedSiblings.length === 0) return
+
+        const bookmarksContainer: BookmarkedParentFolder|undefined = findGroupForItemPathInBookmarks(
+            orderedSiblings[0].path,
+            CreateIfMissing,
+            this.plugin!,
+            this.groupNameForSorting
+        )
+
+        if (!bookmarksContainer) return
+
+        const reordered: Array<BookmarkedItem> = []
+        const matchedItems: Set<BookmarkedItem> = new Set()
+
+        for (const aSibling of orderedSiblings) {
+            const siblingName = lastPathComponent(aSibling.path)
+
+            // Find existing bookmark entry for this sibling
+            const existing = bookmarksContainer.items.find((it) =>
+                ((it.type === 'folder' || it.type === 'file') && it.path === aSibling.path) ||
+                (it.type === 'group' && groupNameForPath(it.title||'') === siblingName)
+            )
+
+            if (existing) {
+                // If it was a group transparent for sorting, make it visible again
+                if (existing.type === 'group' && isGroupTransparentForSorting(existing.title)) {
+                    existing.title = groupNameForPath(existing.title||'')
+                }
+                reordered.push(existing)
+                matchedItems.add(existing)
+            } else {
+                // Create new entry at the correct position
+                const newEntry: BookmarkedItem = (aSibling instanceof TFolder)
+                    ? createBookmarkGroupEntry(siblingName)
+                    : createBookmarkFileEntry(aSibling.path)
+                reordered.push(newEntry)
+            }
+        }
+
+        // Remove orphaned entries: items in bookmarks that have no corresponding file/folder
+        // (they are simply not included in reordered)
+
+        // Replace the container items with the reordered list
+        bookmarksContainer.items.length = 0
+        bookmarksContainer.items.push(...reordered)
+    }
+
     updateSortingBookmarksAfterItemRenamed = (renamedItem: TAbstractFile, oldPath: string): void => {
         updateSortingBookmarksAfterItemRenamed(this.plugin!, renamedItem, oldPath, this.groupNameForSorting)
     }