Event: implement timeStamp instead of always returning 0

src/jsc/bindings/ZigGlobalObject.cpp

@@ -3378,9 +3378,10 @@
 {
     if (!m_performance) {
         auto* context = this->scriptExecutionContext();
-        double nanoTimeOrigin = Bun__readOriginTimerStart(this->bunVM());
-        auto timeOrigin = MonotonicTime::fromRawSeconds(nanoTimeOrigin / 1000.0);
+        // WTF MonotonicTime value at the instant bunVM()->origin_timer was captured.
+        auto elapsed = Seconds { static_cast<double>(Bun__readOriginTimer(this->bunVM())) / 1000000000.0 };
+        auto timeOrigin = MonotonicTime::now() - elapsed;
         m_performance = Performance::create(context, timeOrigin);
     }
 
     return m_performance;

src/jsc/bindings/webcore/Event.cpp

@@ -29,9 +29,10 @@
 #include "EventPath.h"
 #include "EventTarget.h"
 // #include "InspectorInstrumentation.h"
-// #include "Performance.h"
+#include "Performance.h"
 // #include "UserGestureIndicator.h"
 // #include "WorkerGlobalScope.h"
+#include "ZigGlobalObject.h"
 #include <wtf/HexNumber.h>
 #include <wtf/TZoneMallocInlines.h>
 #include <wtf/text/StringBuilder.h>
@@ -162,18 +163,8 @@ void Event::setUnderlyingEvent(Event* underlyingEvent)
 
 DOMHighResTimeStamp Event::timeStampForBindings(ScriptExecutionContext& context) const
 {
-    // TODO:
-    return 0.0;
-    // Performance* performance = nullptr;
-    // if (is<WorkerGlobalScope>(context))
-    //     performance = &downcast<WorkerGlobalScope>(context).performance();
-    // else if (auto* window = downcast<Document>(context).domWindow())
-    //     performance = &window->performance();
-
-    // if (!performance)
-    //     return 0;
-
-    // return std::max(performance->relativeTimeFromTimeOriginInReducedResolution(m_createTime), 0.);
+    auto performance = defaultGlobalObject(context.jsGlobalObject())->performance();
+    return std::max((m_createTime - performance->monotonicTimeOrigin()).milliseconds(), 0.0);
 }
 
 void Event::resetBeforeDispatch()

src/jsc/bindings/webcore/Performance.cpp

@@ -85,8 +85,7 @@ DOMHighResTimeStamp Performance::now() const
 
 DOMHighResTimeStamp Performance::timeOrigin() const
 {
-    // return reduceTimeResolution(m_timeOrigin.approximateWallTime().secondsSinceEpoch()).milliseconds();
-    return m_timeOrigin.secondsSinceEpoch().milliseconds();
+    return Bun__readOriginTimerStart(bunVM(scriptExecutionContext()->vm()));
 }
 
 // ReducedResolutionSeconds Performance::nowInReducedResolutionSeconds() const

src/jsc/bindings/webcore/Performance.h

@@ -123,6 +123,7 @@ class Performance final : public RefCounted<Performance>, public ContextDestruct
 
     DOMHighResTimeStamp relativeTimeFromTimeOriginInReducedResolution(MonotonicTime) const;
     MonotonicTime monotonicTimeFromRelativeTime(DOMHighResTimeStamp) const;
+    MonotonicTime monotonicTimeOrigin() const { return m_timeOrigin; }
 
     ScriptExecutionContext* scriptExecutionContext() const final { return ContextDestructionObserver::scriptExecutionContext(); }
 

test/js/bun/util/inspect.test.js

@@ -692,7 +692,7 @@ it("CloseEvent", () => {
     code: 1000,
     reason: "Normal",
   });
-  expect(Bun.inspect(closeEvent)).toMatchInlineSnapshot(`
+  expect(Bun.inspect(closeEvent).replace(/timeStamp: [\d.]+,/, "timeStamp: 0,")).toMatchInlineSnapshot(`
     "CloseEvent {
       isTrusted: false,
       wasClean: false,
@@ -771,7 +771,7 @@ it("CustomEvent", () => {
     bubbles: true,
     cancelable: true,
   });
-  expect(Bun.inspect(customEvent)).toMatchInlineSnapshot(`
+  expect(Bun.inspect(customEvent).replace(/timeStamp: [\d.]+,/, "timeStamp: 0,")).toMatchInlineSnapshot(`
     "CustomEvent {
       isTrusted: false,
       detail: {

test/js/web/web-globals.test.js

@@ -112,6 +112,49 @@ test("MessageEvent", () => {
   expect(called).toBe(true);
 });
 
+test("Event.prototype.timeStamp", async () => {
+  await using proc = spawn({
+    cmd: [
+      bunExe(),
+      "-e",
+      `
+        while (performance.now() < 10) {}
+        const before = performance.now();
+        const samples = [];
+        samples.push(new Event("x").timeStamp);
+        samples.push(new CustomEvent("x").timeStamp);
+        samples.push(new MessageEvent("x").timeStamp);
+        samples.push(new ErrorEvent("x").timeStamp);
+        const target = new EventTarget();
+        target.addEventListener("go", e => samples.push(e.timeStamp));
+        target.dispatchEvent(new Event("go"));
+        const ac = new AbortController();
+        ac.signal.addEventListener("abort", e => samples.push(e.timeStamp));
+        ac.abort();
+        const after = performance.now();
+        const ev = new Event("stable");
+        const first = ev.timeStamp;
+        while (performance.now() < after + 5) {}
+        console.log(JSON.stringify({ before, after, samples, first, second: ev.timeStamp }));
+      `,
+    ],
+    env: bunEnv,
+    stderr: "pipe",
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+  const { before, after, samples, first, second } = JSON.parse(stdout);
+  expect(samples.length).toBe(6);
+  // timeStamp is relative to performance.timeOrigin. 1ms of slack covers the
+  // one-time gap between the two clock samples that derive m_timeOrigin.
+  for (const ts of samples) {
+    expect(ts).toBeGreaterThan(before - 1);
+    expect(ts).toBeLessThan(after + 1);
+  }
+  expect(first).toBeGreaterThanOrEqual(samples[samples.length - 1]);
+  expect(second).toBe(first);
+  expect({ stderr, exitCode }).toEqual({ stderr: expect.any(String), exitCode: 0 });
+});
+
 it("crypto.getRandomValues", () => {
   var foo = new Uint8Array(32);