@synnaxlabs/x 0.8.0 → 0.9.0

package/dist/x.es.js

@@ -5,6 +5,15 @@ var __publicField = (obj, key, value) => {
   return value;
 };
 var _a;
+let urlAlphabet = "_-0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+let nanoid = (size = 21) => {
+  let id = "";
+  let i = size;
+  while (i--) {
+    id += urlAlphabet[Math.random() * 64 | 0];
+  }
+  return id;
+};
 const isStringer = (value) => value != null && typeof value === "object" && "toString" in value;
 const primitiveIsZero = (value) => {
   if (isStringer(value))
@@ -2926,12 +2935,12 @@ class ZodSet extends ZodType {
     const valueType = this._def.valueType;
     function finalizeSet(elements2) {
       const parsedSet = /* @__PURE__ */ new Set();
-      for (const element of elements2) {
-        if (element.status === "aborted")
+      for (const element2 of elements2) {
+        if (element2.status === "aborted")
           return INVALID;
-        if (element.status === "dirty")
+        if (element2.status === "dirty")
           status.dirty();
-        parsedSet.add(element.value);
+        parsedSet.add(element2.value);
       }
       return { status: status.value, value: parsedSet };
     }
@@ -3876,25 +3885,57 @@ const ZERO$3 = { lower: 0, upper: 0 };
 const INFINITE = { lower: -Infinity, upper: Infinity };
 const DECIMAL$2 = { lower: 0, upper: 1 };
 const CLIP = { lower: -1, upper: 1 };
-const equals$3 = (a, b) => (a == null ? void 0 : a.lower) === (b == null ? void 0 : b.lower) && (a == null ? void 0 : a.upper) === (b == null ? void 0 : b.upper);
+const equals$3 = (_a2, _b) => {
+  if (_a2 == null && _b == null)
+    return true;
+  if (_a2 == null || _b == null)
+    return false;
+  const a = construct$5(_a2);
+  const b = construct$5(_b);
+  return (a == null ? void 0 : a.lower) === (b == null ? void 0 : b.lower) && (a == null ? void 0 : a.upper) === (b == null ? void 0 : b.upper);
+};
 const makeValid = (a) => {
   if (a.lower > a.upper)
     return { lower: a.upper, upper: a.lower };
   return a;
 };
 const clamp$1 = (bounds2, target2) => {
-  if (target2 < bounds2.lower)
-    return bounds2.lower;
-  if (target2 >= bounds2.upper)
-    return bounds2.upper - 1;
+  const _bounds = construct$5(bounds2);
+  if (target2 < _bounds.lower)
+    return _bounds.lower;
+  if (target2 >= _bounds.upper)
+    return _bounds.upper - 1;
   return target2;
 };
-const contains$1 = (bounds2, target2) => target2 >= bounds2.lower && target2 < bounds2.upper;
-const overlapsWith = (a, b) => contains$1(a, a.lower) || contains$1(b, b.upper - 1);
-const span = (a) => a.upper - a.lower;
-const isZero$2 = (a) => a.lower === 0 && a.upper === 0;
+const contains$1 = (bounds2, target2) => {
+  const _bounds = construct$5(bounds2);
+  if (typeof target2 === "number")
+    return target2 >= _bounds.lower && target2 < _bounds.upper;
+  const _target = construct$5(target2);
+  return _target.lower >= _bounds.lower && _target.upper <= _bounds.upper;
+};
+const overlapsWith = (a, b) => {
+  const _a2 = construct$5(a);
+  const _b = construct$5(b);
+  if (_a2.lower == _b.lower)
+    return true;
+  if (_b.upper == _a2.lower || _b.lower == _a2.upper)
+    return false;
+  return contains$1(_a2, _b.upper) || contains$1(_a2, _b.lower) || contains$1(_b, _a2.upper) || contains$1(_b, _a2.lower);
+};
+const span = (a) => {
+  const _a2 = construct$5(a);
+  return _a2.upper - _a2.lower;
+};
+const isZero$2 = (a) => {
+  const _a2 = construct$5(a);
+  return _a2.lower === 0 && _a2.upper === 0;
+};
 const spanIsZero = (a) => span(a) === 0;
-const isFinite$1 = (a) => Number.isFinite(a.lower) && Number.isFinite(a.upper);
+const isFinite$2 = (a) => {
+  const _a2 = construct$5(a);
+  return Number.isFinite(_a2.lower) && Number.isFinite(_a2.upper);
+};
 const max$1 = (bounds2) => ({
   lower: Math.min(...bounds2.map((b) => construct$5(b).lower)),
   upper: Math.max(...bounds2.map((b) => construct$5(b).upper))
@@ -3903,6 +3944,75 @@ const min$1 = (bounds2) => ({
   lower: Math.max(...bounds2.map((b) => construct$5(b).lower)),
   upper: Math.min(...bounds2.map((b) => construct$5(b).upper))
 });
+const constructArray = (bounds2) => {
+  const _bounds = construct$5(bounds2);
+  return Array.from({ length: span(bounds2) }, (_, i) => i + _bounds.lower);
+};
+const findInsertPosition = (bounds2, target2) => {
+  const _bounds = bounds2.map(construct$5);
+  const index = _bounds.findIndex((b2, i) => contains$1(b2, target2) || target2 < _bounds[i].lower);
+  if (index === -1)
+    return { index: bounds2.length, position: 0 };
+  const b = _bounds[index];
+  if (contains$1(b, target2))
+    return { index, position: target2 - b.lower };
+  return { index, position: 0 };
+};
+const ZERO_PLAN = {
+  removeBefore: 0,
+  removeAfter: 0,
+  insertInto: 0,
+  deleteInBetween: 0
+};
+const buildInsertionPlan = (bounds2, value) => {
+  const _bounds = bounds2.map(construct$5);
+  const _target = construct$5(value);
+  if (_bounds.length === 0)
+    return ZERO_PLAN;
+  const lower = findInsertPosition(bounds2, _target.lower);
+  const upper = findInsertPosition(bounds2, _target.upper);
+  if (lower.index == bounds2.length)
+    return { ...ZERO_PLAN, insertInto: bounds2.length };
+  if (upper.index == 0)
+    return {
+      ...ZERO_PLAN,
+      removeAfter: upper.position
+    };
+  if (lower.index === upper.index) {
+    if (lower.position !== 0 && upper.position !== 0)
+      return null;
+    return {
+      removeAfter: upper.position,
+      removeBefore: lower.position,
+      insertInto: lower.index,
+      deleteInBetween: 0
+    };
+  }
+  let deleteInBetween = upper.index - lower.index;
+  let insertInto = lower.index;
+  let removeBefore = span(_bounds[lower.index]) - lower.position;
+  if (lower.position != 0) {
+    deleteInBetween -= 1;
+    insertInto += 1;
+  } else
+    removeBefore = 0;
+  return {
+    removeBefore,
+    removeAfter: upper.position,
+    insertInto,
+    deleteInBetween
+  };
+};
+const insert = (bounds2, value) => {
+  const plan = buildInsertionPlan(bounds2, value);
+  if (plan == null)
+    return bounds2;
+  const _target = construct$5(value);
+  _target.lower += plan.removeBefore;
+  _target.upper -= plan.removeAfter;
+  bounds2.splice(plan.insertInto, plan.deleteInBetween, _target);
+  return bounds2.map(construct$5);
+};
 const bounds = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   CLIP,
@@ -3910,11 +4020,15 @@ const bounds = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProper
   INFINITE,
   ZERO: ZERO$3,
   bounds: bounds$1,
+  buildInsertionPlan,
   clamp: clamp$1,
   construct: construct$5,
+  constructArray,
   contains: contains$1,
   equals: equals$3,
-  isFinite: isFinite$1,
+  findInsertPosition,
+  insert,
+  isFinite: isFinite$2,
   isZero: isZero$2,
   makeValid,
   max: max$1,
@@ -4598,7 +4712,7 @@ const construct$2 = (x2, y2) => {
     return { x: x2.clientX, y: x2.clientY };
   if ("width" in x2)
     return { x: x2.width, y: x2.height };
-  return { ...x2 };
+  return { x: x2.x, y: x2.y };
 };
 const ZERO$2 = { x: 0, y: 0 };
 const ONE = { x: 1, y: 1 };
@@ -4635,7 +4749,7 @@ const translate = (a, b, v, ...cb) => {
     return { x: p.x + xy2.x, y: p.y + xy2.y };
   }, ZERO$2);
 };
-const set = (c, direction2, value) => {
+const set$1 = (c, direction2, value) => {
   const xy2 = construct$2(c);
   if (direction2 === "x")
     return { x: value, y: xy2.y };
@@ -4665,6 +4779,10 @@ const isNan = (a) => {
   const xy2 = construct$2(a);
   return Number.isNaN(xy2.x) || Number.isNaN(xy2.y);
 };
+const isFinite$1 = (a) => {
+  const xy2 = construct$2(a);
+  return Number.isFinite(xy2.x) && Number.isFinite(xy2.y);
+};
 const couple$1 = (a) => {
   const xy2 = construct$2(a);
   return [xy2.x, xy2.y];
@@ -4686,10 +4804,11 @@ const xy = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   css: css$1,
   distance,
   equals: equals$2,
+  isFinite: isFinite$1,
   isNan,
   isZero: isZero$1,
   scale: scale$2,
-  set,
+  set: set$1,
   translate,
   translateX,
   translateY,
@@ -4764,6 +4883,7 @@ const construct$1 = (first, second, width2 = 0, height2 = 0, coordinateRoot) =>
     b.two = second;
   return b;
 };
+const resize = (b, dims2) => construct$1(b.one, dims2);
 const contains = (b, value) => {
   const b_ = construct$1(b);
   if ("one" in value)
@@ -4901,6 +5021,7 @@ const box$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePropert
   positionInCenter,
   positionSoVisible,
   reRoot,
+  resize,
   right,
   root,
   signedDims,
@@ -5988,6 +6109,18 @@ const _TimeRange = class _TimeRange {
       return this.contains(other.start) && this.contains(other.end);
     return this.start.beforeEq(other) && this.end.after(other);
   }
+  boundBy(other) {
+    const next = new _TimeRange(this.start, this.end);
+    if (other.start.after(this.start))
+      next.start = other.start;
+    if (other.start.after(this.end))
+      next.end = other.start;
+    if (other.end.before(this.end))
+      next.end = other.end;
+    if (other.end.before(this.start))
+      next.start = other.end;
+    return next;
+  }
 };
 /** The maximum possible time range. */
 __publicField(_TimeRange, "MAX", new _TimeRange(TimeStamp.MIN, TimeStamp.MAX));
@@ -6130,6 +6263,24 @@ __publicField(_DataType, "DENSITIES", /* @__PURE__ */ new Map([
   [_DataType.JSON.toString(), Density.UNKNOWN],
   [_DataType.UUID.toString(), Density.BIT128]
 ]));
+/** All the data types. */
+__publicField(_DataType, "ALL", [
+  _DataType.UNKNOWN,
+  _DataType.FLOAT64,
+  _DataType.FLOAT32,
+  _DataType.INT64,
+  _DataType.INT32,
+  _DataType.INT16,
+  _DataType.INT8,
+  _DataType.UINT64,
+  _DataType.UINT32,
+  _DataType.UINT16,
+  _DataType.UINT8,
+  _DataType.TIMESTAMP,
+  _DataType.UUID,
+  _DataType.STRING,
+  _DataType.JSON
+]);
 __publicField(_DataType, "BIG_INT_TYPES", [_DataType.INT64, _DataType.UINT64, _DataType.TIMESTAMP]);
 /** A zod schema for a DataType. */
 __publicField(_DataType, "z", z.union([
@@ -6248,7 +6399,16 @@ const validateFieldNotNull = (name, field) => {
 };
 const FULL_BUFFER = -1;
 class Series {
-  constructor(data, dataType, timeRange, sampleOffset, glBufferUsage = "static", alignment2 = 0) {
+  constructor({
+    data,
+    dataType,
+    timeRange,
+    sampleOffset = 0,
+    glBufferUsage = "static",
+    alignment: alignment2 = 0,
+    key = nanoid()
+  }) {
+    __publicField(this, "key", "");
     /** The data type of the array */
     __publicField(this, "dataType");
     /**
@@ -6282,6 +6442,7 @@ class Series {
         "must provide a data type when constructing a Series from a buffer"
       );
     }
+    this.key = key;
     this.alignment = alignment2;
     this.sampleOffset = sampleOffset ?? 0;
     this._data = data;
@@ -6293,41 +6454,38 @@ class Series {
       bufferUsage: glBufferUsage
     };
   }
-  static alloc(length, dataType, timeRange, sampleOffset, glBufferUsage = "static", alignment2 = 0) {
+  static alloc({ length, dataType, ...props }) {
     if (length === 0)
       throw new Error("[Series] - cannot allocate an array of length 0");
     const data = new new DataType(dataType).Array(length);
-    const arr = new Series(
-      data.buffer,
+    const arr = new Series({
+      data: data.buffer,
       dataType,
-      timeRange,
-      sampleOffset,
-      glBufferUsage,
-      alignment2
-    );
+      ...props
+    });
     arr.writePos = 0;
     return arr;
   }
   static generateTimestamps(length, rate, start) {
-    const tr = start.spanRange(rate.span(length));
+    const timeRange = start.spanRange(rate.span(length));
     const data = new BigInt64Array(length);
     for (let i = 0; i < length; i++) {
       data[i] = BigInt(start.add(rate.span(i)).valueOf());
     }
-    return new Series(data, DataType.TIMESTAMP, tr);
+    return new Series({ data, dataType: DataType.TIMESTAMP, timeRange });
   }
   get refCount() {
     return this._refCount;
   }
   static fromStrings(data, timeRange) {
     const buffer = new TextEncoder().encode(data.join("\n") + "\n");
-    return new Series(buffer, DataType.STRING, timeRange);
+    return new Series({ data: buffer, dataType: DataType.STRING, timeRange });
   }
   static fromJSON(data, timeRange) {
     const buffer = new TextEncoder().encode(
       data.map((d) => JSON.stringify(d)).join("\n") + "\n"
     );
-    return new Series(buffer, DataType.JSON, timeRange);
+    return new Series({ data: buffer, dataType: DataType.JSON, timeRange });
   }
   acquire(gl) {
     this._refCount++;
@@ -6429,14 +6587,14 @@ class Series {
     for (let i = 0; i < this.length; i++) {
       data[i] = convertDataType(this.dataType, target2, this.data[i], sampleOffset);
     }
-    return new Series(
-      data.buffer,
-      target2,
-      this._timeRange,
+    return new Series({
+      data: data.buffer,
+      dataType: target2,
+      timeRange: this._timeRange,
       sampleOffset,
-      this.gl.bufferUsage,
-      this.alignment
-    );
+      glBufferUsage: this.gl.bufferUsage,
+      alignment: this.alignment
+    });
   }
   calcRawMax() {
     if (this.length === 0)
@@ -6537,8 +6695,9 @@ class Series {
     if (!this.dataType.equals(DataType.FLOAT32))
       throw new Error("Only FLOAT32 arrays can be used in WebGL");
     const { buffer, bufferUsage, prevBuffer } = this.gl;
-    if (buffer == null)
+    if (buffer == null) {
       this.gl.buffer = gl.createBuffer();
+    }
     if (this.writePos === prevBuffer)
       return;
     gl.bindBuffer(gl.ARRAY_BUFFER, this.gl.buffer);
@@ -6562,13 +6721,25 @@ class Series {
   get digest() {
     var _a2;
     return {
+      key: this.key,
       dataType: this.dataType.toString(),
       sampleOffset: this.sampleOffset,
-      alignment: this.alignment,
+      alignment: this.alignmentBounds,
       timeRange: (_a2 = this._timeRange) == null ? void 0 : _a2.toString(),
       length: this.length
     };
   }
+  get memInfo() {
+    return {
+      key: this.key,
+      length: this.length,
+      byteLength: this.byteLength,
+      glBuffer: this.gl.buffer != null
+    };
+  }
+  get alignmentBounds() {
+    return construct$5(this.alignment, this.alignment + this.length);
+  }
   maybeGarbageCollectGLBuffer(gl) {
     if (this.gl.buffer == null)
       return;
@@ -6584,25 +6755,27 @@ class Series {
     return this.gl.buffer;
   }
   slice(start, end) {
-    const d = this.data.slice(start, end);
-    return new Series(
-      d,
-      this.dataType,
-      TimeRange.ZERO,
-      this.sampleOffset,
-      this.gl.bufferUsage,
-      this.alignment + start
-    );
+    if (start <= 0 && (end == null || end >= this.length))
+      return this;
+    const data = this.data.slice(start, end);
+    return new Series({
+      data,
+      dataType: this.dataType,
+      timeRange: this._timeRange,
+      sampleOffset: this.sampleOffset,
+      glBufferUsage: this.gl.bufferUsage,
+      alignment: this.alignment + start
+    });
   }
   reAlign(alignment2) {
-    return new Series(
-      this.buffer,
-      this.dataType,
-      TimeRange.ZERO,
-      this.sampleOffset,
-      "static",
-      alignment2
-    );
+    return new Series({
+      data: this.buffer,
+      dataType: this.dataType,
+      timeRange: TimeRange.ZERO,
+      sampleOffset: this.sampleOffset,
+      glBufferUsage: "static",
+      alignment: alignment2
+    });
   }
 }
 const addSamples = (a, b) => {
@@ -6682,6 +6855,47 @@ const deleteD = (target2, ...keys) => {
   });
   return target2;
 };
+const get = (obj, path, allowNull) => {
+  const parts = path.split(".");
+  let result = obj;
+  for (const part of parts) {
+    const v = result[part];
+    if (v == null) {
+      if (allowNull)
+        return null;
+      throw new Error(`Path ${path} does not exist. ${part} is null`);
+    }
+    result = v;
+  }
+  return result;
+};
+const set = (obj, path, value) => {
+  const parts = path.split(".");
+  let result = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (result[part] == null) {
+      throw new Error(`Path ${path} does not exist`);
+    }
+    result = result[part];
+  }
+  result[parts[parts.length - 1]] = value;
+};
+const element = (path, index) => {
+  const parts = path.split(".");
+  if (index < 0)
+    return parts[parts.length + index];
+  return parts[index];
+};
+const join = (path) => path.join(".");
+const has = (obj, path) => {
+  try {
+    get(obj, path);
+    return true;
+  } catch {
+    return false;
+  }
+};
 const merge = (base, ...objects) => {
   if (objects.length === 0)
     return base;
@@ -6774,10 +6988,15 @@ const external = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProp
   __proto__: null,
   copy,
   deleteD,
+  element,
   equal,
+  get,
+  has,
+  join,
   memo,
   merge,
-  partialEqual
+  partialEqual,
+  set
 }, Symbol.toStringTag, { value: "Module" }));
 const debounce = (func, waitFor) => {
   let timeout = null;
@@ -6879,6 +7098,7 @@ let URL$1 = (_a = class {
   }
 }, __publicField(_a, "UNKNOWN", new _a({ host: "unknown", port: 0 })), _a);
 const toArray = (value) => Array.isArray(value) ? value : [value];
+const nullToArr = (value) => Array.isArray(value) ? value : value === null ? [] : [value];
 const binary = (arr, target2, compare2) => {
   let left2 = 0;
   let right2 = arr.length - 1;
@@ -8973,9 +9193,9 @@ const encoder = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePrope
   registerCustomTypeEncoder
 }, Symbol.toStringTag, { value: "Module" }));
 class Observer {
-  constructor() {
+  constructor(handlers) {
     __publicField(this, "handlers");
-    this.handlers = /* @__PURE__ */ new Map();
+    this.handlers = handlers ?? /* @__PURE__ */ new Map();
   }
   onChange(handler) {
     this.handlers.set(handler, null);
@@ -8998,6 +9218,13 @@ const change = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProper
   __proto__: null,
   Z
 }, Symbol.toStringTag, { value: "Module" }));
+const shallowCopy = (obj) => {
+  if (Array.isArray(obj))
+    return [...obj];
+  if (typeof obj === "object" && obj !== null)
+    return { ...obj };
+  return obj;
+};
 export {
   Case,
   DataType,
@@ -9033,10 +9260,12 @@ export {
   types as kv,
   location,
   nativeTypedArray,
+  nullToArr,
   observe,
   primitiveIsZero,
   external$1 as runtime,
   scale,
+  shallowCopy,
   spatial,
   throttle,
   toArray,