[MS] Watch entries with bindings

client/src/parsec/file.ts

@@ -165,7 +165,15 @@ export async function statFolderChildren(
   path: FsPath,
 ): Promise<Result<Array<EntryStat>, WorkspaceStatFolderChildrenError>> {
   if (!needsMocks()) {
-    const result = await libparsec.workspaceStatFolderChildren(workspaceHandle, path);
+    const watchResult = await libparsec.workspaceWatchEntryOneshot(workspaceHandle, path);
+
+    let result;
+    if (!watchResult.ok) {
+      result = await libparsec.workspaceStatFolderChildren(workspaceHandle, path);
+    } else {
+      result = await libparsec.workspaceStatFolderChildrenById(workspaceHandle, watchResult.value);
+    }
+
     if (!result.ok) {
       return result;
     }

client/src/parsec/login.ts

@@ -41,8 +41,6 @@ import { DateTime } from 'luxon';
 export interface LoggedInDeviceInfo {
   handle: ConnectionHandle;
   device: AvailableDevice;
-  // Used to simulate update events, remove when we have real events
-  intervalId: any;
 }
 
 const loggedInDevices: Array<LoggedInDeviceInfo> = [];
@@ -159,6 +157,9 @@ export async function login(
       case ClientEventTag.WorkspacesSelfAccessChanged:
         eventDistributor.dispatchEvent(Events.WorkspaceUpdated);
         break;
+      case ClientEventTag.WorkspaceWatchedEntryChanged:
+        eventDistributor.dispatchEvent(Events.EntryUpdated, undefined, 300);
+        break;
       default:
         window.electronAPI.log('debug', `Unhandled event ${event.tag}`);
         break;
@@ -177,19 +178,15 @@ export async function login(
     const clientConfig = getClientConfig();
     const result = await libparsec.clientStart(clientConfig, callback, accessStrategy);
     if (result.ok) {
-      // Simulate an update event every 10s to force a refresh
-      const intervalId = setInterval(() => {
-        eventDistributor.dispatchEvent(Events.EntryUpdated);
-      }, 10000);
-      loggedInDevices.push({ handle: result.value, device: device, intervalId: intervalId });
+      loggedInDevices.push({ handle: result.value, device: device });
     }
     return result;
   } else {
     if (
       accessStrategy.tag === DeviceAccessStrategyTag.Password &&
       ['P@ssw0rd.', 'AVeryL0ngP@ssw0rd'].includes((accessStrategy as DeviceAccessStrategyPassword).password)
     ) {
-      loggedInDevices.push({ handle: DEFAULT_HANDLE, device: device, intervalId: null });
+      loggedInDevices.push({ handle: DEFAULT_HANDLE, device: device });
       return { ok: true, value: DEFAULT_HANDLE };
     }
     return {
@@ -212,10 +209,7 @@ export async function logout(handle?: ConnectionHandle | undefined | null): Prom
     if (result.ok) {
       const index = loggedInDevices.findIndex((info) => info.handle === handle);
       if (index !== -1) {
-        const removed = loggedInDevices.splice(index, 1);
-        if (removed && removed.length > 0) {
-          clearInterval(removed[0].intervalId);
-        }
+        loggedInDevices.splice(index, 1);
       }
     }
     return result;

client/src/services/eventDistributor.ts

@@ -43,17 +43,47 @@ interface Callback {
 
 class EventDistributor {
   private callbacks: Array<Callback>;
+  private timeouts: Map<Events, number>;
 
   constructor() {
     this.callbacks = [];
+    this.timeouts = new Map<number, Events>();
   }
 
-  async dispatchEvent(event: Events, data?: EventData): Promise<void> {
-    for (const cb of this.callbacks) {
-      if (event & cb.events) {
-        await cb.funct(event, data);
+  async dispatchEvent(event: Events, data?: EventData, aggregateTime?: number): Promise<void> {
+    async function sendToAll(callbacks: Array<Callback>, event: Events, data?: EventData): Promise<void> {
+      for (const cb of callbacks) {
+        if (event & cb.events) {
+          await cb.funct(event, data);
+        }
       }
     }
+
+    // In some cases, events can occur very close to each other, leading to some heavy operations.
+    // We can aggregate those cases in order to distribute only one event if multiple occur in a short
+    // time lapse.
+    if (aggregateTime !== undefined) {
+      if (data) {
+        // Can't have data with an aggregateTime, we wouldn't know what data to use
+        console.warn('Cannot have an aggregate time with data, ignoring this event.');
+        return;
+      }
+      // Clear previous interval if any
+      if (this.timeouts.has(event)) {
+        const interval = this.timeouts.get(event);
+        this.timeouts.delete(event);
+        window.clearInterval(interval);
+      }
+      // Create a new timeout
+      const interval = window.setTimeout(async () => {
+        await sendToAll(this.callbacks, event, undefined);
+      }, aggregateTime);
+      // Add it to the list
+      this.timeouts.set(event, interval);
+    }
+    else {
+      await sendToAll(this.callbacks, event, data);
+    }
   }
 
   async registerCallback(events: number, funct: (event: Events, data?: EventData) => Promise<void>): Promise<string> {