batching

Author: shakyShane

special-pages/pages/new-tab/app/activity/ActivityProvider.js

@@ -3,31 +3,55 @@
  * @typedef {import("../../types/new-tab.js").ActivityConfig} ActivityConfig
  * @typedef {import("../../types/new-tab.js").UrlInfo} UrlInfo
  * @typedef {import("../../types/new-tab.js").PatchData} PatchData
+ * @typedef {import('../../types/new-tab.js').DomainActivity} DomainActivity
  */
 import { Service } from '../service.js';
 
-export class BatchedActivity {
-    SIZE = 5;
+export class BatchedActivityService {
+    INITIAL = 5;
+    CHUNK_SIZE = 10;
+    isFetchingNext = false;
     /**
      * @param {import("../../src/index.js").NewTabPage} ntp - The internal data feed, expected to have a `subscribe` method.
+     * @param {boolean} batched
      * @internal
      */
-    constructor(ntp) {
+    constructor(ntp, batched = false) {
         this.ntp = ntp;
+        this.batched = batched;
 
         /** @type {Service<import('../../types/new-tab.js').UrlInfo>} */
         this.urlService = new Service({
-            initial: () => this.ntp.messaging.request('activity_getUrls'),
+            initial: () => {
+                if (this.batched) {
+                    return this.ntp.messaging.request('activity_getUrls');
+                } else {
+                    /** @type {UrlInfo} */
+                    const next = {
+                        urls: [],
+                        totalTrackersBlocked: 0,
+                    };
+                    return Promise.resolve(next);
+                }
+            },
             subscribe: (cb) => ntp.messaging.subscribe('activity_onDataPatch', cb),
         });
 
         /** @type {Service<ActivityData>} */
         this.dataService = new Service({
             initial: (params) => {
-                if (!this.urlService.data) throw new Error('unreachable');
-                return this.ntp.messaging.request('activity_getDataForUrls', { urls: params.urls });
+                if (this.batched) {
+                    return this.ntp.messaging.request('activity_getDataForUrls', { urls: params.urls });
+                } else {
+                    return this.ntp.messaging.request('activity_getData');
+                }
             },
             subscribe: (cb) => ntp.messaging.subscribe('activity_onDataUpdate', cb),
+        }).withUpdater((old, next) => {
+            if (this.batched) {
+                return { activity: old.activity.concat(next.activity) };
+            }
+            return next;
         });
 
         /** @type {Service<ActivityConfig>} */
@@ -42,6 +66,7 @@ export class BatchedActivity {
         this.burnUnsub = this.ntp.messaging.subscribe('activity_onBurnComplete', () => {
             this.burns?.dispatchEvent(new CustomEvent('activity_onBurnComplete'));
         });
+        this.patchesSub = this.onPatchData();
     }
 
     name() {
@@ -53,11 +78,19 @@ export class BatchedActivity {
      * @internal
      */
     async getInitial() {
-        const configPromise = this.configService.fetchInitial();
-        const urlsPromise = this.urlService.fetchInitial();
-        const [config, urlData] = await Promise.all([configPromise, urlsPromise]);
-        const data = await this.dataService.fetchInitial({ urls: urlData.urls.slice(0, this.SIZE) });
-        return { config, data };
+        if (this.batched) {
+            const configPromise = this.configService.fetchInitial();
+            const urlsPromise = this.urlService.fetchInitial();
+            const [config, urlData] = await Promise.all([configPromise, urlsPromise]);
+            const data = await this.dataService.fetchInitial({ urls: urlData.urls.slice(0, this.INITIAL) });
+            return { config, data };
+        } else {
+            const configPromise = this.configService.fetchInitial();
+            const dataPromise = this.dataService.fetchInitial();
+            const urlInfoPromise = this.urlService.fetchInitial();
+            const [config, data] = await Promise.all([configPromise, dataPromise, urlInfoPromise]);
+            return { config, data };
+        }
     }
 
     /**
@@ -67,6 +100,7 @@ export class BatchedActivity {
         this.configService.destroy();
         this.dataService.destroy();
         this.burnUnsub();
+        this.patchesSub();
         this.burns = null;
     }
 
@@ -75,10 +109,8 @@ export class BatchedActivity {
      */
     next(urls) {
         if (!this.urlService.data) throw new Error('unreachable');
-        this.dataService.triggerFetch({ urls });
-    }
-
-    triggerFetchChunk(urls) {
+        if (urls.length === 0) return;
+        this.isFetchingNext = true;
         this.dataService.triggerFetch({ urls });
     }
 
@@ -87,19 +119,39 @@ export class BatchedActivity {
      * @internal
      */
     onUrlData(cb) {
-        return this.urlService.onData(cb);
+        return this.urlService.onData((params) => {
+            if ('patch' in params.data) return console.log('ignoring patch');
+            cb(params);
+        });
+    }
+
+    /**
+     * @internal
+     */
+    onPatchData() {
+        return this.urlService.onData((params) => {
+            if (!('patch' in params.data)) return console.log('ignoring none-patch');
+            this.dataService.publish({ activity: [/** @type {DomainActivity} */ (params.data.patch)] });
+        });
     }
 
     /**
      * @param {(evt: {data: ActivityData, source: 'manual' | 'subscription'}) => void} cb
      * @internal
      */
     onData(cb) {
-        return this.dataService.onData(cb);
+        return this.dataService.onData((data) => {
+            this.isFetchingNext = false;
+            cb(data);
+        });
     }
 
     triggerDataFetch() {
-        return this.dataService.triggerFetch();
+        if (this.batched) {
+            this.urlService.triggerFetch();
+        } else {
+            this.dataService.triggerFetch();
+        }
     }
 
     /**
@@ -172,6 +224,18 @@ export class BatchedActivity {
                 }),
             };
         });
+        this.urlService.update((old) => {
+            return {
+                ...old,
+                urls: old.urls.filter((x) => x !== url),
+            };
+        });
+        this.ntp.messaging.notify('activity_removeItem', { url });
+    }
+    /**
+     * @param {string} url
+     */
+    removeOnly(url) {
         this.ntp.messaging.notify('activity_removeItem', { url });
     }
     /**