Include waitUntil for activate/install

README.md

@@ -203,7 +203,7 @@ dispatchEvent({
 Use this to have the event be dispatched immediately
 
 ```javascript
-await dispatchEvent({
+dispatchEvent({
     type: "bingpop",
     schedule: {
         immediate: true
@@ -216,7 +216,7 @@ await dispatchEvent({
 Use this to have the event be dispatched after a period of time
 
 ```javascript
-await dispatchEvent({
+dispatchEvent({
     type: "bingpop",
     schedule: {
         delay: 1000
@@ -225,7 +225,7 @@ await dispatchEvent({
 ```
 
 ```javascript
-await dispatchEvent({
+dispatchEvent({
     type: "bingpop",
     schedule: {
         delay: "1h"
@@ -238,7 +238,7 @@ await dispatchEvent({
 Use this to have the event be dispatched according to a [cron schedule](https://crontab.guru/)
 
 ```javascript
-await dispatchEvent({
+dispatchEvent({
     type: "bingpop",
     schedule: {
         // Triggers at 5am each day

package.json

@@ -198,7 +198,7 @@
     "@virtualstate/impack": "^1.0.0-alpha.8",
     "@virtualstate/kdl": "^1.0.1-alpha.29",
     "@virtualstate/memo": "^1.8.0",
-    "@virtualstate/navigation": "^1.0.1-alpha.196",
+    "@virtualstate/navigation": "^1.0.1-alpha.199",
     "@virtualstate/x": "^2.46.0",
     "c8": "^7.10.0",
     "chance": "^1.1.11",

src/fetch/dispatch.ts

@@ -31,6 +31,10 @@ export interface WaitUntil {
     waitUntil(promise: Promise<void | unknown>): void
 }
 
+export interface ExtendableEvent extends WaitUntil, DurableEventData {
+
+}
+
 interface InternalWaitUntil extends WaitUntil {
     wait(): Promise<void>;
 }

src/periodic-sync/dispatch.ts

@@ -2,12 +2,17 @@ import {dispatcher} from "../events/schedule/schedule";
 import {isLike, ok} from "../is";
 import {dispatchSyncEvent, SyncDurableEventData} from "../sync/dispatch";
 import {getPeriodicSyncTagRegistrationState, setPeriodicSyncTagRegistrationState} from "./manager";
+import {WaitUntil} from "../fetch";
 
 export interface PeriodicSyncDurableEventData extends SyncDurableEventData {
     tag: string;
     lastChance?: boolean;
 }
 
+export interface PeriodicSyncEvent extends PeriodicSyncDurableEventData, WaitUntil {
+    signal: AbortSignal
+}
+
 export function isPeriodicSyncDurableEventData(event: unknown): event is PeriodicSyncDurableEventData {
     return !!(
         isLike<Partial<PeriodicSyncDurableEventData>>(event) &&

src/periodic-sync/virtual.ts

@@ -4,9 +4,10 @@ import {DurableEventData, DurableEventSchedule, getDurableEvent, setDurableEvent
 import {isMatchingObjects} from "../is";
 import {getPeriodicSyncSchedule} from "./schedule";
 import {isScheduleRepeating} from "../events/schedule/update";
+import {DurablePeriodicSyncManager} from "./manager";
 
-async function * generatePeriodicSyncVirtualEvents() {
-    const schedules = await getPeriodicSyncSchedule();
+async function * generatePeriodicSyncVirtualEvents(manager?: DurablePeriodicSyncManager) {
+    const schedules = await getPeriodicSyncSchedule(manager);
     const type = "periodicsync"
     const existingTags = await listDurableEventIds({
         type

src/sync/dispatch.ts

@@ -1,6 +1,6 @@
 import {dispatcher, DispatchEventFn} from "../events/schedule/schedule";
 import {isLike, isSignalled, ok} from "../is";
-import {createWaitUntil} from "../fetch";
+import {createWaitUntil, WaitUntil} from "../fetch";
 import {DurableEventData} from "../data";
 import {
     deregisterSyncTag,
@@ -14,6 +14,10 @@ export interface SyncDurableEventData extends DurableEventData {
     lastChance?: boolean;
 }
 
+export interface SyncEvent extends SyncDurableEventData, WaitUntil {
+    signal: AbortSignal
+}
+
 export function isSyncDurableEventData(event: unknown): event is SyncDurableEventData {
     return !!(
         isLike<Partial<SyncDurableEventData>>(event) &&

src/sync/manager.ts

@@ -51,6 +51,7 @@ export async function deregisterSyncTag(tag: string) {
 }
 
 export class DurableSyncManager {
+
     async register(tag: string) {
         const store = getSyncTagStore();
         const existing = await store.get(tag);

src/sync/virtual.ts

@@ -1,11 +1,11 @@
 import {SyncDurableEventData} from "./dispatch";
 import {virtual} from "../events/virtual/virtual";
-import {getSyncTagStore} from "./manager";
+import {DurableSyncManager, getSyncTagStore} from "./manager";
 
 
-export async function * generateVirtualSyncEvents(): AsyncIterable<SyncDurableEventData> {
+export async function * generateVirtualSyncEvents(manager?: DurableSyncManager): AsyncIterable<SyncDurableEventData> {
     const store = getSyncTagStore();
-    for await (const { tag, lastChance } of store) {
+    for await (const { tag, lastChance } of manager) {
         yield {
             // Utilise a durableEventId so that a lock is created per tag
             durableEventId: `${store.name}:${tag}`,

src/tests/worker/service-worker/worker.ts

@@ -5,6 +5,14 @@ declare var self: DurableServiceWorkerScope;
 
 console.log("in test service worker");
 
+self.addEventListener("install", event => {
+    event.waitUntil(Promise.resolve())
+});
+
+self.addEventListener("activate", event => {
+    event.waitUntil(Promise.resolve())
+})
+
 self.addEventListener("fetch", event => {
     event.respondWith(onFetchEvent(event));
 });

src/worker/service-worker/container.ts

@@ -3,9 +3,10 @@ import {virtual} from "../../events/virtual/virtual";
 import {isLike, ok} from "../../is";
 import {createHash} from "node:crypto";
 import {index} from "../../content-index";
-import {sync} from "../../sync";
+import {DurableSyncManager, sync} from "../../sync";
 import {addEventListener} from "../../events/schedule/schedule";
 import {dispatchEvent} from "../../events";
+import {DurablePeriodicSyncManager} from "../../periodic-sync";
 
 export type DurableServiceWorkerRegistrationState = "pending" | "installing" | "installed" | "activating" | "activated";
 
@@ -138,19 +139,26 @@ export class DurableServiceWorkerRegistration {
     waiting?: DurableServiceWorker;
 
     index = index;
-    sync = sync;
+    sync: DurableSyncManager;
+    periodicSync: DurablePeriodicSyncManager;
 
     public durable: DurableServiceWorkerRegistrationData;
     public readonly isCurrentGlobalScope: boolean;
 
     private unregisterListener;
 
-    constructor(data: DurableServiceWorkerRegistrationData,{ isCurrentGlobalScope }: DurableServiceWorkerRegistrationOptions = {}) {
+    constructor(data: DurableServiceWorkerRegistrationData, { isCurrentGlobalScope }: DurableServiceWorkerRegistrationOptions = {}) {
         this.isCurrentGlobalScope = !!isCurrentGlobalScope;
         this.#onDurableData(data);
         if (this.isCurrentGlobalScope) {
             this.unregisterListener = addEventListener(DURABLE_SERVICE_WORKER_REGISTRATION_UPDATE, this.#onDurableDataEvent);
         }
+        this.sync = new DurableSyncManager({
+            serviceWorkerId: data.serviceWorkerId
+        });
+        this.periodicSync = new DurablePeriodicSyncManager({
+            serviceWorkerId: data.serviceWorkerId
+        });
     }
 
     #onDurableDataEvent = (event: DurableEvent) => {

src/worker/service-worker/default-worker.ts

@@ -1,12 +1,9 @@
-import { DurableServiceWorkerScope } from "./types";
+import "./dispatchers";
 import { Push } from "@virtualstate/promise";
 import {WORKER_BREAK, WORKER_INITIATED, WORKER_TERMINATE} from "./constants";
 import {parentPort, workerData} from "node:worker_threads";
 import {onServiceWorkerWorkerData, ServiceWorkerWorkerData} from "./worker";
 import { ok } from "../../is";
-import {dispatchEvent} from "../../events";
-import {DurableEventData} from "../../data";
-import {createRespondWith, DurableFetchEventData, isDurableFetchEventData} from "../../fetch";
 import {dispatchWorkerEvent} from "./dispatch";
 
 console.log("Default worker!");

src/worker/service-worker/dispatchers/activate.ts

@@ -0,0 +1,18 @@
+import {dispatcher} from "../../../events/schedule/schedule";
+import {createWaitUntil, ExtendableEvent} from "../../../fetch";
+
+export interface ActivateEvent extends ExtendableEvent {
+
+}
+
+export const removeActivateDispatcher = dispatcher("activate", async (event, dispatch) => {
+    const {
+        wait,
+        waitUntil
+    } = createWaitUntil(event);
+    await dispatch({
+        ...event,
+        waitUntil
+    });
+    await wait();
+});

src/worker/service-worker/dispatchers/index.ts

@@ -0,0 +1,2 @@
+export * from "./activate";
+export * from "./install";

src/worker/service-worker/dispatchers/install.ts

@@ -0,0 +1,21 @@
+import {dispatcher} from "../../../events/schedule/schedule";
+import {createWaitUntil, ExtendableEvent} from "../../../fetch";
+
+export interface InstallEvent extends ExtendableEvent {
+    skipWaiting(): void;
+}
+
+export const removeInstallDispatcher = dispatcher("install", async (event, dispatch) => {
+    const {
+        wait,
+        waitUntil
+    } = createWaitUntil(event);
+    await dispatch({
+        ...event,
+        waitUntil,
+        skipWaiting() {
+            // TODO noop
+        }
+    })
+    await wait();
+});

src/worker/service-worker/types.ts

@@ -1,20 +1,29 @@
 import {DurableServiceWorkerRegistration} from "./container";
-import {DurableCacheStorage, FetchEvent} from "../../fetch";
+import {DurableCacheStorage, ExtendableEvent, FetchEvent} from "../../fetch";
 import {DurableContentIndex} from "../../content-index";
-import {DurableSyncManager} from "../../sync";
+import {SyncEvent} from "../../sync";
 import {DurableEventData} from "../../data";
+import {PeriodicSyncEvent} from "../../periodic-sync";
+import {ActivateEvent, InstallEvent} from "./dispatchers";
+
+
+
+
 
 export interface DurableServiceWorkerScope {
     registration: DurableServiceWorkerRegistration,
     caches: DurableCacheStorage,
     index: DurableContentIndex,
-    sync: DurableSyncManager,
     serviceWorker: ServiceWorkerContainer
     self: DurableServiceWorkerScope,
     isSecureContext: boolean
     origin: string
     addEventListener(type: "fetch", fn: (event: FetchEvent) => void): void;
+    addEventListener(type: "install", fn: (event: InstallEvent) => void): void;
+    addEventListener(type: "activate", fn: (event: ActivateEvent) => void): void;
     addEventListener(type: "message", fn: (message: MessageEvent) => void): void;
+    addEventListener(type: "sync", fn: (message: SyncEvent) => void): void;
+    addEventListener(type: "periodicsync", fn: (message: PeriodicSyncEvent) => void): void;
     addEventListener(type: string, fn: (event: DurableEventData) => void): void;
     removeEventListener: typeof removeEventListener
 }

yarn.lock

@@ -4029,10 +4029,10 @@
     uuid "^8.3.2"
     whatwg-url "^9.1.0"
 
-"@virtualstate/navigation@^1.0.1-alpha.196":
-  version "1.0.1-alpha.196"
-  resolved "https://registry.yarnpkg.com/@virtualstate/navigation/-/navigation-1.0.1-alpha.196.tgz#c767538bae4a01f665ab047b7972baa08fbf84fa"
-  integrity sha512-ovHT29Ec7QaJsgWHKRU2DQ5fX7RHVvPOvKMZOqtjw4uwny4U3K7hfbyjBFUMfGCIxjoYQMmfCUPR/Hn2GY6T9g==
+"@virtualstate/navigation@^1.0.1-alpha.199":
+  version "1.0.1-alpha.199"
+  resolved "https://registry.yarnpkg.com/@virtualstate/navigation/-/navigation-1.0.1-alpha.199.tgz#68359773ae890cff2cc3125615e4316061256f44"
+  integrity sha512-CFAtLsq9MgLR96hAMOiQaqaonGCFbOB9I1JM3mO0EpsyF1egD8AzjG+mJWSUBC0KzeBawwbzWDb00SWMGP7uog==
   dependencies:
     "@ungap/structured-clone" "^1.0.2"
     "@virtualstate/composite-key" "^1.0.0"