@fluixi/devtools 0.2.0-alpha.2 → 0.2.0-alpha.4

package/dist/history.js

@@ -0,0 +1,85 @@
+// What happened, in order.
+//
+// A snapshot says what the graph is; by the time a panel polls, the propagation is over and
+// everything reads as settled. So the observer's callbacks are recorded as they arrive — the
+// runtime calls them from inside the write, so the order is real rather than reconstructed.
+//
+// Events group into commits: a write with nothing running came from a handler and opens one.
+// Deferred effects land in the commit that scheduled them.
+/** Records nothing and costs nothing, for `history: 0`. */
+const OFF = {
+    wrote() { },
+    ran() { },
+    created() { },
+    disposed() { },
+    take: () => [],
+    dropped: 0,
+    clear() { },
+};
+/** Keep the last `limit`. An app nobody is polling still runs effects. */
+export function createHistory(limit) {
+    if (limit <= 0)
+        return OFF;
+    let events = [];
+    let seq = 0;
+    let commit = 0;
+    let dropped = 0;
+    const push = (event) => {
+        events.push({ ...event, seq: seq++, t: Date.now(), commit });
+        if (events.length > limit) {
+            dropped += events.length - limit;
+            events = events.slice(-limit);
+        }
+    };
+    return {
+        wrote(id, by, detail) {
+            // Nothing running: it came from outside, which is where a reader wants the cut.
+            if (by === undefined)
+                commit++;
+            push({ kind: 'write', id, by, ...detail });
+        },
+        ran(id, by) {
+            push({ kind: 'ran', id, by });
+        },
+        created(id, by, label) {
+            push({ kind: 'created', id, by, label });
+        },
+        disposed(id, label) {
+            push({ kind: 'disposed', id, label });
+        },
+        take() {
+            const taken = events;
+            events = [];
+            return taken;
+        },
+        get dropped() {
+            return dropped;
+        },
+        clear() {
+            events = [];
+            dropped = 0;
+        },
+    };
+}
+/**
+ * Oldest first. A commit whose opening write has aged out still groups — its events carry the
+ * number, and a partial commit beats dropping the runs after it.
+ */
+export function toCommits(events) {
+    const byNumber = new Map();
+    for (const event of events) {
+        const bucket = byNumber.get(event.commit);
+        if (bucket)
+            bucket.push(event);
+        else
+            byNumber.set(event.commit, [event]);
+    }
+    return [...byNumber.entries()]
+        .sort((a, b) => a[0] - b[0])
+        .map(([commit, group]) => ({
+        commit,
+        t: group[0].t,
+        events: group,
+        cause: group.find((e) => e.kind === 'write' && e.by === undefined),
+    }));
+}

package/dist/history.mjs

@@ -0,0 +1,74 @@
+// src/history.ts
+var OFF = {
+  wrote() {
+  },
+  ran() {
+  },
+  created() {
+  },
+  disposed() {
+  },
+  take: () => [],
+  dropped: 0,
+  clear() {
+  }
+};
+function createHistory(limit) {
+  if (limit <= 0) return OFF;
+  let events = [];
+  let seq = 0;
+  let commit = 0;
+  let dropped = 0;
+  const push = (event) => {
+    events.push({ ...event, seq: seq++, t: Date.now(), commit });
+    if (events.length > limit) {
+      dropped += events.length - limit;
+      events = events.slice(-limit);
+    }
+  };
+  return {
+    wrote(id, by, detail) {
+      if (by === void 0) commit++;
+      push({ kind: "write", id, by, ...detail });
+    },
+    ran(id, by) {
+      push({ kind: "ran", id, by });
+    },
+    created(id, by, label) {
+      push({ kind: "created", id, by, label });
+    },
+    disposed(id, label) {
+      push({ kind: "disposed", id, label });
+    },
+    take() {
+      const taken = events;
+      events = [];
+      return taken;
+    },
+    get dropped() {
+      return dropped;
+    },
+    clear() {
+      events = [];
+      dropped = 0;
+    }
+  };
+}
+function toCommits(events) {
+  const byNumber = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    const bucket = byNumber.get(event.commit);
+    if (bucket) bucket.push(event);
+    else byNumber.set(event.commit, [event]);
+  }
+  return [...byNumber.entries()].sort((a, b) => a[0] - b[0]).map(([commit, group]) => ({
+    commit,
+    t: group[0].t,
+    events: group,
+    cause: group.find((e) => e.kind === "write" && e.by === void 0)
+  }));
+}
+export {
+  createHistory,
+  toCommits
+};