@clockworkdog/timesync 2.11.0

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './timesync';
+export * from './setDate';

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from './timesync';
+export * from './setDate';

package/dist/setDate.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Patch `Date.now()` and `new Date()` given the current time is @param now
+ */
+export declare function setDate(now: number): void;

package/dist/setDate.js

@@ -0,0 +1,23 @@
+// Adapted from https://stackoverflow.com/a/58325977/244640
+const OriginalDateConstructor = globalThis.Date;
+/**
+ * Patch `Date.now()` and `new Date()` given the current time is @param now
+ */
+export function setDate(now) {
+    const nowDelta = now - OriginalDateConstructor.now();
+    function Date(...args) {
+        if (args.length === 0) {
+            return new OriginalDateConstructor(Date.now()); // Date.now() is implemented below
+        }
+        // Specific date constructor
+        return new OriginalDateConstructor(...args);
+    }
+    // copy all properties from the original date, this includes the prototype
+    const propertyDescriptors = Object.getOwnPropertyDescriptors(OriginalDateConstructor);
+    Object.defineProperties(Date, propertyDescriptors);
+    // override Date.now to return the adjusted time
+    Date.now = function () {
+        return OriginalDateConstructor.now() + nowDelta;
+    };
+    globalThis.Date = Date;
+}

package/dist/timesync.d.ts

@@ -0,0 +1,28 @@
+export interface TimeSyncRequestData {
+    timesync: {
+        id: number;
+    };
+}
+export interface TimeSyncResponseData {
+    timesync: {
+        id: number;
+        now: number;
+    };
+}
+export interface TimeSyncClient {
+    receive(data: TimeSyncResponseData): void;
+    destroy(): void;
+}
+export interface TimeSyncServer {
+    receive(data: TimeSyncRequestData): void;
+}
+export declare function createTimeSyncClient({ interval, send, onChange, syncSampleSize, syncRequestTimeout, }: {
+    interval: number;
+    send: (data: TimeSyncRequestData) => void | Promise<void>;
+    onChange?: (now: number) => void;
+    syncSampleSize?: number;
+    syncRequestTimeout?: number;
+}): TimeSyncClient;
+export declare function createTimeSyncServer({ send }: {
+    send: (data: TimeSyncResponseData) => void | Promise<void>;
+}): TimeSyncServer;

package/dist/timesync.js

@@ -0,0 +1,63 @@
+import { setDate } from './setDate';
+let id = 0;
+function getId() {
+    return ++id;
+}
+const SYNC_SAMPLE_SIZE = 5;
+const SYNC_REQUEST_TIMEOUT = 10000;
+export function createTimeSyncClient({ interval, send, onChange = setDate, syncSampleSize = SYNC_SAMPLE_SIZE, syncRequestTimeout = SYNC_REQUEST_TIMEOUT, }) {
+    const requests = {};
+    async function synchronize() {
+        const promises = [];
+        // Send a series of requests
+        for (let i = 0; i < syncSampleSize; i++) {
+            const promise = new Promise((resolve) => {
+                const id = getId();
+                const sentAt = performance.now();
+                send({ timesync: { id } });
+                const complete = (receivedAt, serverNow) => resolve({ sentAt, receivedAt, serverNow, clientNow: Date.now() });
+                requests[id] = { complete };
+                setTimeout(() => resolve(null), syncRequestTimeout);
+            });
+            promises.push(promise);
+            await promise;
+        }
+        // Perform calculation with results
+        const results = await Promise.all(promises);
+        const deltas = results
+            .filter((result) => result !== null)
+            .map((result) => {
+            const { sentAt, receivedAt, serverNow, clientNow } = result;
+            const halfLatency = (receivedAt - sentAt) / 2;
+            return clientNow - serverNow + halfLatency;
+        });
+        const averageDelta = deltas.reduce((d1, d2) => d1 + d2, 0) / deltas.length;
+        if (!isNaN(averageDelta)) {
+            onChange(Date.now() + averageDelta);
+        }
+    }
+    const receive = (data) => {
+        const receivedAt = performance.now();
+        const req = requests[data.timesync.id];
+        if (!req)
+            return;
+        req.complete(receivedAt, data.timesync.now);
+    };
+    synchronize();
+    const loop = setInterval(synchronize, interval);
+    const destroy = () => {
+        clearInterval(loop);
+    };
+    return {
+        receive,
+        destroy,
+    };
+}
+export function createTimeSyncServer({ send }) {
+    return {
+        receive(data) {
+            const { id } = data.timesync;
+            send({ timesync: { id, now: Date.now() } });
+        },
+    };
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@clockworkdog/timesync",
+  "description": "A library to synchronize a client's clock to a server's",
+  "author": "Clockwork Dog <info@clockwork.dog>",
+  "homepage": "https://github.com/clockwork-dog/cogs-sdk/tree/main/packages/timesync",
+  "version": "2.11.0",
+  "keywords": [],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/clockwork-dog/cogs-sdk.git"
+  },
+  "bugs": {
+    "url": "https://github.com/clockwork-dog/cogs-sdk/issues"
+  },
+  "files": [
+    "dist/**/*"
+  ],
+  "main": "dist/index.js",
+  "scripts": {
+    "test": "yarn lint && vitest",
+    "lint": "eslint .",
+    "build": "tsc",
+    "release": "yarn npm publish --access public"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.17.0",
+    "eslint": "^9.17.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-prettier": "^5.2.1",
+    "prettier": "^3.4.2",
+    "typescript": "~5.7.2",
+    "typescript-eslint": "^8.18.1",
+    "vitest": "^4.0.6"
+  }
+}