@synnaxlabs/pluto 0.21.8 → 0.21.9

package/dist/{LinePlot-BZDm4uxJ.cjs → LinePlot-Bnb8Ufob.cjs}

@@ -6,9 +6,9 @@ var __publicField = (obj, key, value2) => {
   return value2;
 };
 var _a, _b, _c, _d, _e;
-const aggregator = require("./aggregator-BpfMBUD1.cjs");
+const aggregator = require("./aggregator-Bh2Kyzkg.cjs");
 const zod = require("zod");
-const css = require("./css-Pf9qxhQ4.cjs");
+const css = require("./css-Ci8WUD5E.cjs");
 const React = require("react");
 require("react-dom");
 const a = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
@@ -355,7 +355,7 @@ class StatusSource extends Noop {
       key: "noop",
       variant: "disabled",
       message: "unknown",
-      time: aggregator.w.now()
+      time: aggregator.m.now()
     };
   }
 }
@@ -625,11 +625,11 @@ class ChannelData extends AbstractSource {
   async value() {
     const { timeRange, channel, useIndexOfChannel: indexOfChannel } = this.props;
     if (timeRange.isZero || channel === 0)
-      return [css.L.ZERO, []];
+      return [css.C.ZERO, []];
     const chan = await fetchChannelProperties(this.client, channel, indexOfChannel);
     if (!this.valid)
       await this.readFixed(chan.key);
-    let b = css.L.max(this.data.map((d2) => d2.bounds));
+    let b = css.C.max(this.data.map((d2) => d2.bounds));
     if (chan.dataType.equals(aggregator.g.TIMESTAMP))
       b = {
         upper: Math.min(b.upper, Number(this.props.timeRange.end.valueOf())),
@@ -649,8 +649,8 @@ __publicField(ChannelData, "TYPE", "series-source");
 const streamChannelDataPropsZ = zod.z.object({
   channel: zod.z.number().or(zod.z.string()),
   useIndexOfChannel: zod.z.boolean().optional().default(false),
-  timeSpan: aggregator.y.z,
-  keepFor: aggregator.y.z.optional()
+  timeSpan: aggregator.w.z,
+  keepFor: aggregator.w.z.optional()
 });
 class StreamChannelData extends AbstractSource {
   constructor(client, props) {
@@ -665,12 +665,12 @@ class StreamChannelData extends AbstractSource {
   async value() {
     const { channel, useIndexOfChannel, timeSpan } = this.props;
     if (channel === 0)
-      return [css.L.ZERO, []];
-    const now2 = aggregator.w.now();
+      return [css.C.ZERO, []];
+    const now2 = aggregator.m.now();
     const ch = await fetchChannelProperties(this.client, channel, useIndexOfChannel);
     if (!this.valid)
       await this.read(ch.key);
-    let b = css.L.max(
+    let b = css.C.max(
       this.data.filter((d2) => d2.timeRange.end.after(now2.sub(timeSpan))).map((d2) => d2.bounds)
     );
     if (ch.dataType.equals(aggregator.g.TIMESTAMP))
@@ -681,7 +681,7 @@ class StreamChannelData extends AbstractSource {
     return [b, this.data];
   }
   async read(key) {
-    const tr = aggregator.w.now().spanRange(-this.props.timeSpan);
+    const tr = aggregator.m.now().spanRange(-this.props.timeSpan);
     const res = await this.client.read(tr, [key]);
     const newData = res[key].data;
     newData.forEach((d2) => d2.acquire());
@@ -702,7 +702,7 @@ class StreamChannelData extends AbstractSource {
     this.stopStreaming = await this.client.stream(handler, [key]);
   }
   gcOutOfRangeData() {
-    const threshold = aggregator.w.now().sub(this.props.keepFor ?? this.props.timeSpan);
+    const threshold = aggregator.m.now().sub(this.props.keepFor ?? this.props.timeSpan);
     const toGC = this.data.findIndex((d2) => d2.timeRange.end.before(threshold));
     if (toGC === -1)
       return;
@@ -791,7 +791,7 @@ class FixedSeries extends AbstractSource {
     );
   }
   async value() {
-    const b = css.L.max(this.data.map((x) => x.bounds));
+    const b = css.C.max(this.data.map((x) => x.bounds));
     return [b, this.data];
   }
 }
@@ -832,7 +832,7 @@ class IterativeSeries extends AbstractSource {
       };
       return [b2, d2];
     }
-    const b = css.L.max(d2.map((x) => x.bounds));
+    const b = css.C.max(d2.map((x) => x.bounds));
     return [b, d2];
   }
   start(rate) {
@@ -940,7 +940,7 @@ const _SetPoint = class _SetPoint extends UnarySinkTransformer {
 __publicField(_SetPoint, "TYPE", "boolean-numeric-converter-sink");
 __publicField(_SetPoint, "propsZ", setpointProps);
 let SetPoint = _SetPoint;
-const withinBoundsProps = zod.z.object({ trueBound: css.L.bounds });
+const withinBoundsProps = zod.z.object({ trueBound: css.C.bounds });
 const withinBounds = (props) => ({
   props,
   type: WithinBounds.TYPE,
@@ -954,12 +954,12 @@ const _WithinBounds = class _WithinBounds extends UnarySourceTransformer {
     __publicField(this, "curr", null);
   }
   shouldNotify(value2) {
-    const shouldNotify = css.L.contains(this.props.trueBound, value2) !== this.curr;
-    this.curr = css.L.contains(this.props.trueBound, value2);
+    const shouldNotify = css.C.contains(this.props.trueBound, value2) !== this.curr;
+    this.curr = css.C.contains(this.props.trueBound, value2);
     return shouldNotify;
   }
   transform(value2) {
-    this.curr = css.L.contains(this.props.trueBound, value2);
+    this.curr = css.C.contains(this.props.trueBound, value2);
     return this.curr;
   }
 };
@@ -1212,7 +1212,7 @@ const zeroCacheGCMetrics = () => ({
 });
 const DEFAULT_STATIC_PROPS = {
   instrumentation: aggregator.g$1.NOOP,
-  staleEntryThreshold: aggregator.y.seconds(20)
+  staleEntryThreshold: aggregator.w.seconds(20)
 };
 class Static {
   constructor(props) {
@@ -1265,7 +1265,7 @@ class Static {
   gc() {
     const res = zeroCacheGCMetrics();
     const newData = this.data.filter((s) => {
-      const shouldKeep = s.data.refCount === 0 && aggregator.w.since(s.addedAt).lessThan(this.props.staleEntryThreshold);
+      const shouldKeep = s.data.refCount === 0 && aggregator.m.since(s.addedAt).lessThan(this.props.staleEntryThreshold);
       if (!shouldKeep)
         res.purgedBytes = res.purgedBytes.add(s.data.byteCapacity);
       return shouldKeep;
@@ -1286,7 +1286,7 @@ class Static {
     } = this.props;
     if (series.length === 0)
       return;
-    const insertionPlan = css.L.buildInsertionPlan(
+    const insertionPlan = css.C.buildInsertionPlan(
       this.data.map((s) => s.data.alignmentBounds),
       series.alignmentBounds
     );
@@ -1301,7 +1301,7 @@ class Static {
       return;
     this.data.splice(insertInto, deleteInBetween, {
       data: series,
-      addedAt: aggregator.w.now()
+      addedAt: aggregator.m.now()
     });
   }
   checkIntegrity(write) {
@@ -1313,7 +1313,7 @@ class Static {
       return allBounds.some((b2, j) => {
         if (i2 === j)
           return false;
-        const ok = css.L.overlapsWith(b, b2);
+        const ok = css.C.overlapsWith(b, b2);
         return ok;
       });
     });
@@ -1326,6 +1326,10 @@ class Static {
     }
   }
 }
+const MIN_SIZE = 100;
+const MAX_SIZE = 1e6;
+const DEF_SIZE = 1e4;
+const MAX_DEF_WRITES = 100;
 class Dynamic {
   /**
    * @constructor
@@ -1338,10 +1342,17 @@ class Dynamic {
     __publicField(this, "counter", 0);
     /** Current buffer */
     __publicField(this, "buffer");
+    __publicField(this, "avgRate", 0);
+    __publicField(this, "timeOfLastWrite");
+    __publicField(this, "totalWrites", 0);
+    __publicField(this, "now", () => aggregator.m.now());
     this.props = props;
     this.buffer = null;
+    if (props.testingNow != null)
+      this.now = props.testingNow;
+    this.timeOfLastWrite = this.now();
   }
-  /** @returns the number of samples currenly held in the cache. */
+  /** @returns the number of samples currently held in the cache. */
   get length() {
     var _a2;
     return ((_a2 = this.buffer) == null ? void 0 : _a2.length) ?? 0;
@@ -1371,7 +1382,7 @@ class Dynamic {
     return aggregator.N.alloc({
       capacity,
       dataType: aggregator.g.FLOAT32,
-      timeRange: start2.range(aggregator.w.MAX),
+      timeRange: start2.range(aggregator.m.MAX),
       sampleOffset: this.props.dataType.equals(aggregator.g.TIMESTAMP) ? BigInt(start2.valueOf()) : 0,
       glBufferUsage: "dynamic",
       alignment,
@@ -1379,15 +1390,15 @@ class Dynamic {
     });
   }
   _write(series) {
-    const { dynamicBufferSize: cap } = this.props;
+    const cap = this.nextBufferSize();
     const res = { flushed: [], allocated: [] };
     if (this.buffer == null) {
-      this.buffer = this.allocate(cap, series.alignment, aggregator.w.now());
+      this.buffer = this.allocate(cap, series.alignment, this.now());
       res.allocated.push(this.buffer);
     } else if (Math.abs(
       Number(this.buffer.alignment + BigInt(this.buffer.length) - series.alignment)
     ) > 1) {
-      const now22 = aggregator.w.now();
+      const now22 = this.now();
       this.buffer.timeRange.end = now22;
       res.flushed.push(this.buffer);
       this.buffer = this.allocate(cap, series.alignment, now22);
@@ -1395,9 +1406,11 @@ class Dynamic {
     }
     const converted = convertSeriesFloat32(series, this.buffer.sampleOffset);
     const amountWritten = this.buffer.write(converted);
-    if (amountWritten === series.length)
+    if (amountWritten === series.length) {
+      this.updateAvgRate(series);
       return res;
-    const now2 = aggregator.w.now();
+    }
+    const now2 = this.now();
     this.buffer.timeRange.end = now2;
     res.flushed.push(this.buffer);
     this.buffer = this.allocate(cap, series.alignment + BigInt(amountWritten), now2);
@@ -1407,6 +1420,24 @@ class Dynamic {
     res.allocated.push(...nextRes.allocated);
     return res;
   }
+  updateAvgRate(series) {
+    if (typeof this.props.dynamicBufferSize === "number")
+      return;
+    const newRate = series.length / this.now().span(this.timeOfLastWrite).seconds;
+    if (this.totalWrites > 0 && isFinite(newRate) && newRate > 0)
+      this.avgRate = (this.avgRate * (this.totalWrites - 1) + newRate) / this.totalWrites;
+    this.totalWrites++;
+    this.timeOfLastWrite = this.now();
+  }
+  nextBufferSize() {
+    const { dynamicBufferSize } = this.props;
+    if (typeof dynamicBufferSize === "number")
+      return dynamicBufferSize;
+    if (this.totalWrites < MAX_DEF_WRITES)
+      return DEF_SIZE;
+    const size = css.L.roundToNearestMagnitude(this.avgRate * dynamicBufferSize.seconds);
+    return Math.round(Math.max(Math.min(size, MAX_SIZE), MIN_SIZE));
+  }
   /**
    * Closes the cache and releases all resources associated with it. After close()
    * is called, the cache should not be used again.
@@ -1476,7 +1507,7 @@ class Unary {
     this.static.close();
   }
 }
-const CACHE_BUFFER_SIZE = 1e4;
+const CACHE_BUFFER_SIZE = aggregator.X.seconds(60);
 class Cache {
   constructor(props) {
     __publicField(this, "props");
@@ -1564,7 +1595,7 @@ class Reader {
     });
     this.props = {
       instrumentation: aggregator.g$1.NOOP,
-      batchDebounce: aggregator.y.milliseconds(50),
+      batchDebounce: aggregator.w.milliseconds(50),
       ...props
     };
     this.debouncedRead = aggregator.o$1(() => {
@@ -1601,7 +1632,7 @@ class Reader {
           tr: tr.toPrettyString(),
           channels,
           responses: responseDigests(Object.values(responses)),
-          time: aggregator.y.milliseconds(performance.now() - start2).toString()
+          time: aggregator.w.milliseconds(performance.now() - start2).toString()
         }));
         return responses;
       }
@@ -1635,7 +1666,7 @@ class Reader {
       tr: tr.toPrettyString(),
       channels,
       responses: responseDigests(Object.values(responses)),
-      time: aggregator.y.milliseconds(performance.now() - start2).toString()
+      time: aggregator.w.milliseconds(performance.now() - start2).toString()
     }));
     return responses;
   }
@@ -1652,7 +1683,7 @@ class Reader {
         requests.forEach((_, k) => {
           const [tr, keys] = k;
           const groupWith = compressedToFetch.find(
-            ([r]) => r.start.span(tr.start).lessThan(aggregator.y.milliseconds(5)) && r.end.span(tr.end).lessThan(aggregator.y.milliseconds(5))
+            ([r]) => r.start.span(tr.start).lessThan(aggregator.w.milliseconds(5)) && r.end.span(tr.end).lessThan(aggregator.w.milliseconds(5))
           );
           if (groupWith == null)
             compressedToFetch.push([tr, keys]);
@@ -2601,8 +2632,8 @@ class Loop {
         }
       }
       const end = performance.now();
-      const span = aggregator.y.milliseconds(end - start2);
-      if (span.greaterThan(aggregator.y.milliseconds(25))) {
+      const span = aggregator.w.milliseconds(end - start2);
+      if (span.greaterThan(aggregator.w.milliseconds(25))) {
         console.warn(
           `Render loop for ${this.requests.size} took longer than 16ms to execute: ${span.milliseconds}`
         );
@@ -2831,7 +2862,7 @@ const safelyGetDataValue = (series, index, data) => {
     return NaN;
   return Number(data[series].at(index));
 };
-const DEFAULT_OVERLAP_THRESHOLD = aggregator.y.milliseconds(2);
+const DEFAULT_OVERLAP_THRESHOLD = aggregator.w.milliseconds(2);
 ({
   key: "",
   position: css.q.NAN,
@@ -2983,7 +3014,7 @@ class Line extends aggregator.Leaf {
     result.value.x = safelyGetDataValue(series, index, xData);
     const [, yData] = await yTelem.value();
     const ySeries = yData.find(
-      (ys) => css.L.contains(ys.alignmentBounds, xSeries.alignment + BigInt(index))
+      (ys) => css.C.contains(ys.alignmentBounds, xSeries.alignment + BigInt(index))
     );
     if (ySeries == null)
       return result;
@@ -3093,7 +3124,7 @@ const findSeriesThatOverlapWith = (x, y, overlapThreshold) => y.filter((ys) => {
       `Encountered series without time range in buildDrawOperations. X series present: ${x._timeRange != null}, Y series present: ${ys._timeRange != null}`
     );
   const timeRangesOverlap = x.timeRange.overlapsWith(ys.timeRange, overlapThreshold);
-  const alignmentsOverlap = css.L.overlapsWith(
+  const alignmentsOverlap = css.C.overlapsWith(
     x.alignmentBounds,
     ys.alignmentBounds
   );
@@ -5342,8 +5373,8 @@ class TimeTickFactory {
   generate({ decimalToDataScale: scale, size }) {
     const range = [0, size];
     const domain = [
-      new aggregator.w(scale.pos(0)).date(),
-      new aggregator.w(scale.pos(1)).date()
+      new aggregator.m(scale.pos(0)).date(),
+      new aggregator.m(scale.pos(1)).date()
     ];
     const d3Scale = time().domain(domain).range(range);
     const ticks2 = d3Scale.ticks(calcTickCount(size, this.props.tickSpacing));
@@ -5353,7 +5384,7 @@ class TimeTickFactory {
     }));
   }
   tickLabel(date2) {
-    const value2 = new aggregator.w(date2).date();
+    const value2 = new aggregator.m(date2).date();
     let formatted = `:${value2.getSeconds()}`;
     const ms = value2.getMilliseconds();
     if (ms !== 0) {
@@ -5550,46 +5581,46 @@ class Canvas {
   maybeDrawGrid(size, ticks2, f) {
     const { showGrid, gridColor } = this.state;
     if (showGrid) {
-      const startBound = css.L.construct(-1, 1);
-      const endBound = css.L.construct(size - 1, size + 1);
+      const startBound = css.C.construct(-1, 1);
+      const endBound = css.C.construct(size - 1, size + 1);
       this.ctx.lower2d.strokeStyle = gridColor.hex;
       ticks2.filter(
-        ({ position }) => !css.L.contains(startBound, position) && !css.L.contains(endBound, position)
+        ({ position }) => !css.C.contains(startBound, position) && !css.C.contains(endBound, position)
       ).forEach((tick) => this.drawLine(...f(tick)));
     }
   }
 }
 const coreAxisStateZ = axisStateZ.extend({
-  bounds: css.L.bounds.optional(),
+  bounds: css.C.bounds.optional(),
   autoBounds: zod.z.object({
     lower: zod.z.boolean().optional().default(true),
     upper: zod.z.boolean().optional().default(true)
   }).or(zod.z.boolean().optional().default(true)),
   autoBoundPadding: zod.z.number().optional(),
-  autoBoundUpdateInterval: aggregator.y.z.optional().default(aggregator.y.seconds(2)),
+  autoBoundUpdateInterval: aggregator.w.z.optional().default(aggregator.w.seconds(2)),
   size: zod.z.number().optional().default(0),
   label: zod.z.string().optional().default(""),
   labelSize: zod.z.number().optional().default(0)
 }).partial({ color: true, font: true, gridColor: true });
 const AXIS_SIZE_UPADTE_UPPER_THRESHOLD = 2;
 const AXIS_SIZE_UPDATE_LOWER_THRESHOLD = 7;
-const withinSizeThreshold = (prev, next) => css.L.contains(
+const withinSizeThreshold = (prev, next) => css.C.contains(
   {
     lower: prev - AXIS_SIZE_UPDATE_LOWER_THRESHOLD,
     upper: prev + AXIS_SIZE_UPADTE_UPPER_THRESHOLD
   },
   next
 );
-const EMPTY_LINEAR_BOUNDS = css.L.DECIMAL;
-const now$1 = aggregator.w.now();
+const EMPTY_LINEAR_BOUNDS = css.C.DECIMAL;
+const now$1 = aggregator.m.now();
 const EMPTY_TIME_BOUNDS = {
   lower: Number(now$1.valueOf()),
-  upper: Number(now$1.add(aggregator.y.HOUR).valueOf())
+  upper: Number(now$1.add(aggregator.w.HOUR).valueOf())
 };
 const emptyBounds = (type) => type === "linear" ? EMPTY_LINEAR_BOUNDS : EMPTY_TIME_BOUNDS;
 const autoBounds = (b, padding = 0.1, type) => {
-  const m = css.L.max(b.filter(css.L.isFinite));
-  if (!css.L.isFinite(m))
+  const m = css.C.max(b.filter(css.C.isFinite));
+  if (!css.C.isFinite(m))
     return emptyBounds(type);
   const { lower: lower2, upper } = m;
   if (upper === lower2)
@@ -5952,7 +5983,7 @@ class YAxis extends CoreAxis {
     __publicField(this, "schema", coreAxisStateZ);
   }
   async xBounds() {
-    return css.L.max(
+    return css.C.max(
       await Promise.all(this.lines.map(async (el) => await el.xBounds()))
     );
   }
@@ -6022,8 +6053,8 @@ class YAxis extends CoreAxis {
 }
 __publicField(YAxis, "TYPE", "YAxis");
 const annotationStateZ = zod.z.object({
-  start: aggregator.w.z,
-  end: aggregator.w.z
+  start: aggregator.m.z,
+  end: aggregator.m.z
 });
 class Annotation extends aggregator.Leaf {
   constructor() {
@@ -13453,11 +13484,11 @@ class Tooltip extends aggregator.Leaf {
     const validValues = values.filter((c) => css.q.isFinite(c.value));
     const { draw } = this.internal;
     const avgXPosition = validValues.reduce((p, c) => p + c.position.x, 0) / validValues.length;
-    const avgXValue = new aggregator.w(
+    const avgXValue = new aggregator.m(
       validValues.reduce((p, c) => p + c.value.x, 0) / validValues.length
     );
     const rulePosition = scale_.x.pos(avgXPosition);
-    if (!css.L.contains(css.To.xBounds(region), rulePosition))
+    if (!css.C.contains(css.To.xBounds(region), rulePosition))
       return;
     draw.rule({
       stroke: this.state.ruleColor,
@@ -13643,7 +13674,7 @@ class Measure extends aggregator.Leaf {
     const s = css.k.XY.scale(css.To.DECIMAL).scale(props.region);
     const onePos = s.pos(oneValue.position);
     const twoPos = s.pos(twoValue.position);
-    const xDist = new aggregator.y(Math.abs(oneValue.value.x - twoValue.value.x));
+    const xDist = new aggregator.w(Math.abs(oneValue.value.x - twoValue.value.x));
     const yDist = Math.abs(oneValue.value.y - twoValue.value.y);
     const slope = yDist / xDist.seconds;
     draw.line({
@@ -13667,7 +13698,7 @@ class Measure extends aggregator.Leaf {
       lineWidth: strokeWidth
     });
     draw.textContainer({
-      text: [xDist.truncate(aggregator.y.MILLISECOND).toString()],
+      text: [xDist.truncate(aggregator.w.MILLISECOND).toString()],
       direction: "x",
       position: css.q.construct((onePos.x + twoPos.x) / 2, twoPos.y),
       level: "small"
@@ -13852,7 +13883,7 @@ const value = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePropert
   Value
 }, Symbol.toStringTag, { value: "Module" }));
 const selectedStateZ = aggregator.nk.payloadZ.extend({
-  viewport: css.L.bounds
+  viewport: css.C.bounds
 });
 const providerStateZ = zod.z.object({
   cursor: css.q.xy.or(zod.z.null()),
@@ -13891,7 +13922,7 @@ class Provider extends aggregator.Leaf {
   }
   async fetchInitial(timeRange) {
     const { internal: i2 } = this;
-    if (i2.client == null || this.fetchedInitial.roughlyEquals(timeRange, aggregator.y.minutes(1)))
+    if (i2.client == null || this.fetchedInitial.roughlyEquals(timeRange, aggregator.w.minutes(1)))
       return;
     this.fetchedInitial = timeRange;
     const ranges = await i2.client.ranges.retrieve(timeRange);
@@ -13923,7 +13954,7 @@ class Provider extends aggregator.Leaf {
       startPos = css.Y(startPos, css.To.left(region) - 2, css.To.right(region) - 1);
       let hovered = false;
       if (cursor != null)
-        hovered = css.L.contains({ lower: startPos, upper: endPos }, cursor);
+        hovered = css.C.contains({ lower: startPos, upper: endPos }, cursor);
       if (hovered)
         hoveredState = {
           key: r.key,
@@ -14303,4 +14334,4 @@ exports.withinBounds = withinBounds;
 exports.withinSizeThreshold = withinSizeThreshold;
 exports.xAxisStateZ = xAxisStateZ;
 exports.yAxisStateZ = yAxisStateZ;
-//# sourceMappingURL=LinePlot-BZDm4uxJ.cjs.map
+//# sourceMappingURL=LinePlot-Bnb8Ufob.cjs.map