emberwick 0.4.0 → 0.4.2

package/CHANGELOG.md

@@ -0,0 +1,79 @@
+# Changelog
+
+All notable changes to Emberwick are documented here.
+This project follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.4.2] — 2026-09-19
+
+Metadata only. The code is identical to 0.4.1; nothing needs re-testing.
+
+### Added
+
+- `repository`, `homepage`, `bugs` and `author` in the published manifest, so
+  the npm package page links back to the source, the demo and the issue
+  tracker, and carries a publisher byline. These
+  belong in `package.lib.json` — the root `package.json` is private and never
+  reaches the registry — and 0.4.1 shipped without them. npm versions are
+  immutable, hence a new patch rather than a corrected republish.
+
+## [0.4.1] — 2026-09-19
+
+Bug-fix release. Three feed-lifecycle races could put wrong prices on screen,
+so this supersedes 0.4.0 for anyone attaching a `DataFeed`.
+
+### Fixed
+
+- **A slow `setFeed()` no longer overwrites a newer one.** `setFeed()` awaited
+  `getBars()` without recording which call was current, so switching symbols
+  faster than the network could resolve let the *earlier* request win: it
+  replaced the new symbol's bars, overwrote `_unsub` — leaving the newer
+  subscription permanently unreachable — and, because both feeds wrote to the
+  bar slot keyed on the last bar's time, made the forming candle alternate
+  between two instruments with no error raised. Every async feed read is now
+  stamped with a generation that `setFeed()`, `detachFeed()` and `destroy()`
+  invalidate.
+- **Lazy history pages are bound to the feed that requested them.** A page in
+  flight during a symbol switch could prepend one instrument's bars onto
+  another's, and a stale empty page could latch `_exhausted` on the *new*
+  symbol, permanently disabling paging for an instrument with history left.
+  The page boundary is also re-read after the await, so a late page can no
+  longer splice into the middle of the array and break the ascending-by-time
+  invariant that marker resolution's binary search depends on.
+- **Prepending history shifts the viewport exactly once.** `Smoothed.jump()`
+  writes both `value` and `target`, so the follow-up `set(target + n)` added
+  the page size a second time. The view eased past the newest bar, and because
+  that pushed the visible range beyond the 80-bar trigger, lazy paging stopped
+  firing for the rest of the session — one page load could permanently disable
+  the feature.
+- **`destroy()` is idempotent.** A second call threw from `Layers.destroy()`,
+  which React 18 StrictMode's double-unmount could reach.
+
+### Added
+
+- **`'error'` event.** `subscribe('error', fn)` receives the thrown value from
+  a failed `getBars()`, in both `setFeed()` and history paging. Previously
+  `setFeed()` had no error path at all: a rejection escaped as an unhandled
+  rejection and left a permanently blank chart that a consumer could not even
+  detect. With no subscriber the error is logged rather than swallowed.
+- **First test suite.** `npm test` runs `test/chart-feed-race.test.mjs` on
+  plain Node — no jsdom, no browser. Eight of its nine cases fail against
+  0.4.0. `npm run release` now runs it before building.
+
+### Docs
+
+- Documented the `'error'` event and feed-failure handling.
+- Removed a duplicated header row in the events table.
+
+## [0.4.0] — 2026-09-16
+
+### Added
+
+- Bar-by-bar `Replay` with transport, scrubbing, speed control and looping.
+- Annotations: nine marker shapes, price lines and shaded zones, with
+  collision-aware stacking and hover/click hit-testing.
+- `'visibleRange'` state event and `chart.visibleRange()`.
+
+## [0.1.0] — 2026-09-16
+
+First public release: canvas candlestick core, `DataFeed` seam, `RandomFeed`,
+React adapter, web component, UMD build.

package/README.md

@@ -244,8 +244,6 @@ const off = chart.subscribe('crosshair', (payload) => {
 off()  // unsubscribe
 ```
 
-| Event | Payload |
-|---|---|
 | Event | Payload |
 |---|---|
 | `'crosshair'` | `{ index, bar, price }`, or `null` when the pointer leaves the plot |
@@ -253,10 +251,32 @@ off()  // unsubscribe
 | `'markerClick'` | The clicked marker. Only fires on a hit, never with `null` |
 | `'visibleRange'` | `{ from, to, fromTime, toTime, barCount, spacing, settled }` |
 | `'replay'` | `{ active, playing, index, length, progress, speed, time, bar, atEnd }` |
+| `'error'` | The thrown value from a failed feed read. See below |
 
 A drag that happens to end on top of a marker does not fire `'markerClick'` —
 panning and clicking stay distinct.
 
+### Feed errors
+
+`getBars()` is your code, so it can reject — a 502, an expired token, an
+aborted request. Both paths that call it (`setFeed()` and the lazy history
+paging) route a rejection to `'error'` rather than letting it escape as an
+unhandled rejection:
+
+```js
+chart.subscribe('error', (err) => {
+  toast('Could not load market data')
+  console.error(err)
+})
+```
+
+With no `'error'` subscriber the failure is logged to the console instead of
+vanishing. `setFeed()` itself never rejects, so `await chart.setFeed(feed)`
+is safe to leave unguarded; subscribe to `'error'` to react to the failure.
+
+A failed history page sets the same "stop asking" latch an empty page does, so
+the chart will not retry that boundary on every pan.
+
 ### Tracking the visible range
 
 `'visibleRange'` is a **state** event rather than a notification, which makes it

package/index.d.ts

@@ -432,6 +432,11 @@ export declare class Chart {
   subscribe(event: 'markerHover', fn: (marker: ResolvedMarker | null) => void): () => void
   subscribe(event: 'visibleRange', fn: (range: VisibleRangePayload) => void): () => void
   subscribe(event: 'replay', fn: (state: ReplayState) => void): () => void
+  /**
+   * Feed failures: a rejected `getBars()` from either `setFeed()` or lazy
+   * history paging. With no subscriber the error is logged instead.
+   */
+  subscribe(event: 'error', fn: (error: unknown) => void): () => void
 
   /** Removes listeners, canvases and the render loop. */
   destroy(): void

package/index.js

@@ -1292,12 +1292,15 @@ class Chart {
     this._loadingHistory = false;
     this._exhausted = false;
     this._replay = null;
+    this._feedGen = 0;
+    this._destroyed = false;
     this._listeners = {
       crosshair: /* @__PURE__ */ new Set(),
       visibleRange: /* @__PURE__ */ new Set(),
       markerClick: /* @__PURE__ */ new Set(),
       markerHover: /* @__PURE__ */ new Set(),
-      replay: /* @__PURE__ */ new Set()
+      replay: /* @__PURE__ */ new Set(),
+      error: /* @__PURE__ */ new Set()
     };
     this._markers = normalizeMarkers(options.markers);
     this.priceLines = Array.isArray(options.priceLines) ? options.priceLines.slice() : [];
@@ -1392,23 +1395,35 @@ class Chart {
     this.detachFeed();
     this.feed = feed;
     if (!feed) return;
+    const gen = ++this._feedGen;
     this.ts.timeframeMs = feed.timeframe || this.ts.timeframeMs;
-    const bars = await feed.getBars({
-      symbol: feed.symbol,
-      timeframe: feed.timeframe,
-      to: null,
-      limit: this.options.initialBars || 1500
-    });
+    let bars;
+    try {
+      bars = await feed.getBars({
+        symbol: feed.symbol,
+        timeframe: feed.timeframe,
+        to: null,
+        limit: this.options.initialBars || 1500
+      });
+    } catch (err) {
+      if (gen !== this._feedGen || this._destroyed) return;
+      this._emitError(err, "setFeed");
+      return;
+    }
+    if (gen !== this._feedGen || this._destroyed) return;
     this.setData(bars);
-    if (typeof feed.prime === "function") feed.prime(bars[bars.length - 1]);
+    if (typeof feed.prime === "function") feed.prime(this.bars[this.bars.length - 1]);
     this._unsub = feed.subscribe((msg) => {
       if (!msg || !msg.bar) return;
+      if (gen !== this._feedGen || this._destroyed) return;
       if (this._replay) return;
       if (msg.type === "append") this.append(msg.bar);
       else this.update(msg.bar);
     });
   }
   detachFeed() {
+    this._feedGen++;
+    this._loadingHistory = false;
     if (this._unsub) this._unsub();
     this._unsub = null;
     this.feed = null;
@@ -1419,36 +1434,50 @@ class Chart {
     const { from } = this.ts.visibleRange();
     if (from > 80 || !this.bars.length) return;
     this._loadingHistory = true;
+    const gen = this._feedGen;
+    const feed = this.feed;
     try {
-      const oldest = this.bars[0].time;
-      const older = await this.feed.getBars({
-        symbol: this.feed.symbol,
-        timeframe: this.feed.timeframe,
-        to: oldest,
+      const older = await feed.getBars({
+        symbol: feed.symbol,
+        timeframe: feed.timeframe,
+        to: this.bars[0].time,
         limit: 1e3
       });
+      if (gen !== this._feedGen || this._destroyed) return;
+      if (!this.bars.length) return;
       if (!older || !older.length) {
         this._exhausted = true;
-      } else {
-        const added = older.filter((b) => b.time < oldest);
-        if (!added.length) {
-          this._exhausted = true;
-        } else {
-          this.bars = added.concat(this.bars);
-          const wasFollowing = this.ts.follow;
-          this.ts.barCount = this.bars.length;
-          this.ts._right.jump(this.ts._right.value + added.length);
-          this.ts._right.set(this.ts._right.target + added.length);
-          this.ts.follow = wasFollowing;
-          this.loop.invalidate("all");
-        }
+        return;
       }
-    } catch (e) {
-      console.error("[Emberwick] history load failed", e);
+      const boundary = this.bars[0].time;
+      const added = older.filter((b) => b.time < boundary);
+      if (!added.length) {
+        this._exhausted = true;
+        return;
+      }
+      this.bars = added.concat(this.bars);
+      this.ts.barCount = this.bars.length;
+      this.ts._right.jump(this.ts._right.value + added.length);
+      this.loop.invalidate("all");
+    } catch (err) {
+      if (gen !== this._feedGen || this._destroyed) return;
       this._exhausted = true;
+      this._emitError(err, "loadHistory");
     } finally {
-      this._loadingHistory = false;
+      if (gen === this._feedGen) this._loadingHistory = false;
+    }
+  }
+  /**
+   * Feed failures are delivered as an 'error' event so an adapter can react.
+   * With no subscriber they still reach the console rather than vanishing.
+   */
+  _emitError(err, phase) {
+    const set = this._listeners.error;
+    if (!set.size) {
+      console.error(`[Emberwick] ${phase} failed`, err);
+      return;
     }
+    for (const fn of set) fn(err);
   }
   // ---------------------------------------------------------------- events --
   _bindEvents() {
@@ -1872,6 +1901,8 @@ class Chart {
     return this.layers.composite().toDataURL("image/png");
   }
   destroy() {
+    if (this._destroyed) return;
+    this._destroyed = true;
     const el = this.container;
     el.removeEventListener("pointerdown", this._onDown);
     el.removeEventListener("pointermove", this._onMove);
@@ -2069,7 +2100,7 @@ class RandomFeed extends DataFeed {
 function createChart(container, options) {
   return new Chart(container, options);
 }
-const version = "0.4.0";
+const version = "0.4.2";
 export {
   Chart,
   DataFeed,