ntp: batched api

Author: shakyShane

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

@@ -62,7 +62,35 @@ Notes:
 - {@link "NewTab Messages".ActivityGetConfigRequest}
 - Used to fetch the initial config data (eg: expanded vs collapsed)
 - returns {@link "NewTab Messages".ActivityConfig}
-- 
+
+### `activity_getUrls`
+- {@link "NewTab Messages".ActivityGetUrlsRequest}
+- Used to fetch the initial config data (eg: expanded vs collapsed)
+- returns {@link "NewTab Messages".UrlInfo}
+
+```json
+{
+  "urls": ["..."],
+  "totalTrackersBlocked": 123
+}
+```
+
+### `activity_getDataForUrls`
+- {@link "NewTab Messages".ActivityGetDataForUrlsRequest}
+- Used to confirm the burn action - native side may or may not show a modal
+- sends {@link "NewTab Messages".DataForUrlsParams}
+- returns {@link "NewTab Messages".ActivityData}
+- Note: This response is the same format as `activity_getData`, where DomainActivity items are delivered under `.activity`
+
+```json
+{
+  "activity": [
+    {"...":  "..."}
+  ]
+}
+```
+
+
 ### `activity_confirmBurn`
 - {@link "NewTab Messages".ActivityConfirmBurnRequest}
 - Used to confirm the burn action - native side may or may not show a modal
@@ -93,6 +121,27 @@ by sending the notification `activity_burnAnimationComplete`
 - The activity data used in the feed.
 - returns {@link "NewTab Messages".ActivityData}
 
+### `activity_onDataPatch`
+- {@link "NewTab Messages".ActivityOnDataPatchSubscription}
+- The activity data used in the feed.
+- returns {@link "NewTab Messages".UrlInfo} + optional {@link "NewTab Messages".PatchData}
+
+```json
+{
+  "urls": ["..."],
+  "totalTrackersBlocked": 123
+}
+```
+```json
+{
+  "urls": ["..."],
+  "totalTrackersBlocked": 123,
+  "patch": {
+    "...": "..."
+  }
+}
+```
+
 ### `activity_onConfigUpdate` 
 - {@link "NewTab Messages".ActivityOnDataUpdateSubscription }
 - The widget config

special-pages/pages/new-tab/app/activity/activity.md

@@ -1,20 +1,61 @@
 /**
  * @typedef {import("../../types/new-tab.js").ActivityData} ActivityData
  * @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
+ * @typedef {import('../service.js').InvocationSource} InvocationSource
  */
 import { Service } from '../service.js';
 
-export class ActivityService {
+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: () => {
+                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: () => ntp.messaging.request('activity_getData'),
+            initial: (params) => {
+                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, source) => {
+            if (source === 'manual') {
+                return next;
+            }
+            if (this.batched) {
+                return { activity: old.activity.concat(next.activity) };
+            }
+            return next;
         });
 
         /** @type {Service<ActivityConfig>} */
@@ -29,21 +70,31 @@ export class ActivityService {
         this.burnUnsub = this.ntp.messaging.subscribe('activity_onBurnComplete', () => {
             this.burns?.dispatchEvent(new CustomEvent('activity_onBurnComplete'));
         });
+        this.patchesSub = this.onPatchData();
     }
 
     name() {
-        return 'ActivityService';
+        return 'BatchedActivity';
     }
 
     /**
-     * @returns {Promise<{data: ActivityData; config: ActivityConfig}>}
+     * @returns {Promise<{data: ActivityData; config: ActivityConfig }>}
      * @internal
      */
     async getInitial() {
-        const p1 = this.configService.fetchInitial();
-        const p2 = this.dataService.fetchInitial();
-        const [config, data] = await Promise.all([p1, p2]);
-        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 };
+        }
     }
 
     /**
@@ -53,23 +104,62 @@ export class ActivityService {
         this.configService.destroy();
         this.dataService.destroy();
         this.burnUnsub();
+        this.patchesSub();
         this.burns = null;
     }
 
     /**
-     * @param {(evt: {data: ActivityData, source: 'manual' | 'subscription'}) => void} cb
+     * @param {string[]} urls
+     */
+    next(urls) {
+        if (!this.urlService.data) throw new Error('unreachable');
+        if (urls.length === 0) return;
+        this.isFetchingNext = true;
+        this.dataService.triggerFetch({ urls });
+    }
+
+    /**
+     * @param {(evt: {data: UrlInfo & PatchData, source: InvocationSource}) => void} cb
+     * @internal
+     */
+    onUrlData(cb) {
+        return this.urlService.onData((params) => {
+            if ('patch' in params.data && params.data.patch !== null) return console.log('ignoring patch');
+            cb(params);
+        });
+    }
+
+    /**
+     * @internal
+     */
+    onPatchData() {
+        return this.urlService.onData((params) => {
+            if (!('patch' in params.data && params.data.patch !== null)) return console.log('ignoring none-patch');
+            this.dataService.publish({ activity: [/** @type {DomainActivity} */ (params.data.patch)] });
+        });
+    }
+
+    /**
+     * @param {(evt: {data: ActivityData, source: InvocationSource}) => 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();
+        }
     }
 
     /**
-     * @param {(evt: {data: ActivityConfig, source: 'manual' | 'subscription'}) => void} cb
+     * @param {(evt: {data: ActivityConfig, source: InvocationSource}) => void} cb
      * @internal
      */
     onConfig(cb) {
@@ -138,6 +228,12 @@ export class ActivityService {
                 }),
             };
         });
+        this.urlService.update((old) => {
+            return {
+                ...old,
+                urls: old.urls.filter((x) => x !== url),
+            };
+        });
         this.ntp.messaging.notify('activity_removeItem', { url });
     }
     /**