## 0.24.16

### Improved

#### Peer-to-Peer

- Now peer-to-peer synchronisation checks the settings are compatible with each other.
- Peer-to-peer synchronisation now handles the platform and detects pseudo-clients.

#### General

- New migration method has been implemented, that called `Doctor`.

- The minimum interval for replication to be caused when an event occurs can now be configurable.
- Some detail note has been added and change nuance about the `Report` in the setting dialogue, which had less informative.

### Behaviour and default changed

- `Compute revisions for chunks` are backed into enabled again. it is necessary for garbage collection of chunks.

### Refactored

- Platform specific codes are more separated. No longer `node` modules were used in the browser and Obsidian.

src/common/events.ts

@@ -18,6 +18,8 @@ export const EVENT_REQUEST_OPEN_PLUGIN_SYNC_DIALOG = "request-open-plugin-sync-d
 export const EVENT_REQUEST_OPEN_P2P = "request-open-p2p";
 export const EVENT_REQUEST_CLOSE_P2P = "request-close-p2p";
 
+export const EVENT_REQUEST_RUN_DOCTOR = "request-run-doctor";
+
 // export const EVENT_FILE_CHANGED = "file-changed";
 
 declare global {
@@ -33,6 +35,7 @@ declare global {
         [EVENT_REQUEST_OPEN_P2P]: undefined;
         [EVENT_REQUEST_OPEN_SETUP_URI]: undefined;
         [EVENT_REQUEST_COPY_SETUP_URI]: undefined;
+        [EVENT_REQUEST_RUN_DOCTOR]: string;
     }
 }
 

src/common/utils.ts

@@ -30,6 +30,7 @@ import { sameChangePairs } from "./stores.ts";
 import type { KeyValueDatabase } from "./KeyValueDB.ts";
 import { scheduleTask } from "octagonal-wheels/concurrency/task";
 import { EVENT_PLUGIN_UNLOADED, eventHub } from "./events.ts";
+import { promiseWithResolver, type PromiseWithResolvers } from "octagonal-wheels/promises";
 
 export { scheduleTask, cancelTask, cancelAllTasks } from "../lib/src/concurrency/task.ts";
 
@@ -493,3 +494,47 @@ export function onlyInNTimes(n: number, proc: (progress: number) => any) {
         }
     };
 }
+
+const waitingTasks = {} as Record<string, { task?: PromiseWithResolvers<any>; previous: number; leastNext: number }>;
+
+export function rateLimitedSharedExecution<T>(key: string, interval: number, proc: () => Promise<T>): Promise<T> {
+    if (!(key in waitingTasks)) {
+        waitingTasks[key] = { task: undefined, previous: 0, leastNext: 0 };
+    }
+    if (waitingTasks[key].task) {
+        // Extend the previous execution time.
+        waitingTasks[key].leastNext = Date.now() + interval;
+        return waitingTasks[key].task.promise;
+    }
+
+    const previous = waitingTasks[key].previous;
+
+    const delay = previous == 0 ? 0 : Math.max(interval - (Date.now() - previous), 0);
+
+    const task = promiseWithResolver<T>();
+    void task.promise.finally(() => {
+        if (waitingTasks[key].task === task) {
+            waitingTasks[key].task = undefined;
+            waitingTasks[key].previous = Math.max(Date.now(), waitingTasks[key].leastNext);
+        }
+    });
+    waitingTasks[key] = {
+        task,
+        previous: Date.now(),
+        leastNext: Date.now() + interval,
+    };
+    void scheduleTask("thin-out-" + key, delay, async () => {
+        try {
+            task.resolve(await proc());
+        } catch (ex) {
+            task.reject(ex);
+        }
+    });
+    return task.promise;
+}
+export function updatePreviousExecutionTime(key: string, timeDelta: number = 0) {
+    if (!(key in waitingTasks)) {
+        waitingTasks[key] = { task: undefined, previous: 0, leastNext: 0 };
+    }
+    waitingTasks[key].leastNext = Math.max(Date.now() + timeDelta, waitingTasks[key].leastNext);
+}