@synnaxlabs/x 0.16.1 → 0.23.0

package/src/spatial/xy/xy.spec.ts

@@ -1,4 +1,4 @@
-// Copyright 2023 Synnax Labs, Inc.
+// Copyright 2024 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.
@@ -7,7 +7,7 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { describe, expect, test } from "vitest";
+import { describe, expect, it,test } from "vitest";
 
 import * as xy from "@/spatial/xy/xy";
 
@@ -26,51 +26,100 @@ describe("XY", () => {
         expect(p.y).toEqual(2);
       });
     });
+    it("should set the x coordinate if the direction is x", () => {
+      const p = xy.construct("x", 1);
+      expect(p.x).toEqual(1);
+      expect(p.y).toEqual(0);
+    });
+    it("should set the y coordinate if the direction is y", () => {
+      const p = xy.construct("y", 1);
+      expect(p.x).toEqual(0);
+      expect(p.y).toEqual(1);
+    });
+  });
+  test("translateX", () => {
+    let p = xy.construct([1, 2]);
+    p = xy.translateX(p, 5);
+    expect(p.x).toEqual(6);
+    expect(p.y).toEqual(2);
+  });
+  test("translateY", () => {
+    let p = xy.construct([1, 2]);
+    p = xy.translateY(p, 5);
+    expect(p.x).toEqual(1);
+    expect(p.y).toEqual(7);
+  });
+  test("translate", () => {
+    let p = xy.construct([1, 2]);
+    p = xy.translate(p, [5, 5]);
+    expect(p.x).toEqual(6);
+    expect(p.y).toEqual(7);
   });
-});
-test("translateX", () => {
-  let p = xy.construct([1, 2]);
-  p = xy.translateX(p, 5);
-  expect(p.x).toEqual(6);
-  expect(p.y).toEqual(2);
-});
-test("translateY", () => {
-  let p = xy.construct([1, 2]);
-  p = xy.translateY(p, 5);
-  expect(p.x).toEqual(1);
-  expect(p.y).toEqual(7);
-});
-test("translate", () => {
-  let p = xy.construct([1, 2]);
-  p = xy.translate(p, [5, 5]);
-  expect(p.x).toEqual(6);
-  expect(p.y).toEqual(7);
-});
 
-test("translate multiple", () => {
-  let p = xy.construct([1, 2]);
-  p = xy.translate(p, [5, 5], [2, 2]);
-  expect(p.x).toEqual(8);
-  expect(p.y).toEqual(9);
-});
+  test("translate multiple", () => {
+    let p = xy.construct([1, 2]);
+    p = xy.translate(p, [5, 5], [2, 2]);
+    expect(p.x).toEqual(8);
+    expect(p.y).toEqual(9);
+  });
 
-describe("equals", () => {
-  const TESTS: Array<[xy.Crude, xy.Crude, boolean]> = [
-    [[1, 1], { x: 1, y: 1 }, true],
-    [[1, 1], [1, 1], true],
-    [{ x: 1, y: 12 }, { x: 1, y: 1 }, false],
-    [{ x: 1, y: 12 }, { width: 1, height: 12 }, true],
-    [{ x: 1, y: 12 }, { width: 12, height: 1 }, false],
-    [{ x: 1, y: 12 }, { signedWidth: 1, signedHeight: 12 }, true],
-  ];
-  TESTS.forEach(([one, two, expected], i) => {
-    test(`equals ${i}`, () => {
-      const p = xy.construct(one);
-      expect(xy.equals(p, two)).toEqual(expected);
+  describe("equals", () => {
+    const TESTS: Array<[xy.Crude, xy.Crude, boolean]> = [
+      [[1, 1], { x: 1, y: 1 }, true],
+      [[1, 1], [1, 1], true],
+      [{ x: 1, y: 12 }, { x: 1, y: 1 }, false],
+      [{ x: 1, y: 12 }, { width: 1, height: 12 }, true],
+      [{ x: 1, y: 12 }, { width: 12, height: 1 }, false],
+      [{ x: 1, y: 12 }, { signedWidth: 1, signedHeight: 12 }, true],
+    ];
+    TESTS.forEach(([one, two, expected], i) => {
+      test(`equals ${i}`, () => {
+        const p = xy.construct(one);
+        expect(xy.equals(p, two)).toEqual(expected);
+      });
+    });
+    it("should retrun true if the two points are within the given threshold", () => {
+      const p = xy.construct([1, 1]);
+      expect(xy.equals(p, [1.1, 1.1], 0.15)).toBe(true);
+    });
+  });
+  test("couple", () => {
+    const p = xy.construct([1, 2]);
+    expect(xy.couple(p)).toEqual([1, 2]);
+  });
+  describe("isNan", () => {
+    it("should return true if x or y is NaN", () => {
+      expect(xy.isNan(xy.construct([1, NaN]))).toBe(true);
+      expect(xy.isNan(xy.construct([NaN, 1]))).toBe(true);
+    });
+  });
+  describe("isFinite", () => {
+    it("should return true if x or y is finite", () => {
+      expect(xy.isFinite(xy.construct([1, 2]))).toBe(true);
+      expect(xy.isFinite(xy.construct([Infinity, 2]))).toBe(false);
+      expect(xy.isFinite(xy.construct([1, Infinity]))).toBe(false);
+    });
+  });
+  describe("distance", () => {
+    it("should return the distance between two points", () => {
+      expect(xy.distance([1, 1], [1, 1])).toBe(0);
+      expect(xy.distance([1, 1], [1, 2])).toBe(1);
+      expect(xy.distance([1, 1], [2, 2])).toBe(Math.sqrt(2));
+    });
+  });
+  describe("css", () => {
+    it("should return the css properties of the point", () => {
+      expect(xy.css([1, 2])).toEqual({ left: 1, top: 2 });
+    });
+  });
+  describe("truncate", () => {
+    it("should truncate the point to the given precision", () => {
+      expect(xy.truncate([1.12345, 2.12345], 2)).toEqual({ x: 1.12, y: 2.12 });
+    });
+  });
+  describe("scale", () => {
+    it("should scale the point by the given factor", () => {
+      expect(xy.scale([1, 2], 2)).toEqual({ x: 2, y: 4 });
     });
   });
-});
-test("couple", () => {
-  const p = xy.construct([1, 2]);
-  expect(xy.couple(p)).toEqual([1, 2]);
 });

package/src/spatial/xy/xy.ts

@@ -1,4 +1,4 @@
-// Copyright 2023 Synnax Labs, Inc.
+// Copyright 2024 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.
@@ -10,18 +10,18 @@
 import { z } from "zod";
 
 import {
+  type ClientXY,
   clientXY,
   dimensions,
-  numberCouple,
-  xy,
+  type Direction,
   type NumberCouple,
-  type ClientXY,
-  type XY,
+  numberCouple,
   signedDimensions,
-  type Direction,
+  type XY,
+  xy,
 } from "@/spatial/base";
 
-export { clientXY, xy, type ClientXY as Client, type XY };
+export { type ClientXY as Client, clientXY, type XY,xy };
 
 /** A crude representation of a {@link XY} coordinate as a zod schema. */
 export const crudeZ = z.union([
@@ -60,16 +60,16 @@ export const construct = (x: Crude | Direction, y?: number): XY => {
 };
 
 /** An x and y coordinate of zero */
-export const ZERO = { x: 0, y: 0 };
+export const ZERO: XY = Object.freeze({ x: 0, y: 0 });
 
 /** An x and y coordinate of one */
-export const ONE = { x: 1, y: 1 };
+export const ONE: XY = Object.freeze({ x: 1, y: 1 });
 
 /** An x and y coordinate of infinity */
-export const INFINITY = { x: Infinity, y: Infinity };
+export const INFINITY: XY = Object.freeze({ x: Infinity, y: Infinity });
 
 /** An x and y coordinate of NaN */
-export const NAN = { x: NaN, y: NaN };
+export const NAN: XY = Object.freeze({ x: NaN, y: NaN });
 
 /** @returns true if the two XY coordinates are semantically equal. */
 export const equals = (a: Crude, b: Crude, threshold: number = 0): boolean => {
@@ -138,20 +138,6 @@ export const distance = (ca: Crude, cb: Crude): number => {
   return Math.sqrt((a.x - b.x) ** 2 + (a.y - b.y) ** 2);
 };
 
-/** @returns the magnitude of the x distance between the two given coordinates. */
-export const xDistance = (ca: Crude, cb: Crude): number => {
-  const a = construct(ca);
-  const b = construct(cb);
-  return Math.abs(a.x - b.x);
-};
-
-/** @returns the magnitude of the y distance between the two given coordinates. */
-export const yDistance = (ca: Crude, cb: Crude): number => {
-  const a = construct(ca);
-  const b = construct(cb);
-  return Math.abs(a.y - b.y);
-};
-
 /**
  * @returns the translation that would need to be applied to move the first coordinate
  * to the second coordinate.
@@ -186,6 +172,12 @@ export const css = (a: Crude): { left: number; top: number } => {
   return { left: xy.x, top: xy.y };
 };
 
+/**
+ * Truncate the given coordinates to the given precision.
+ * @param a - The coordinates to truncate.
+ * @param precision - The number of decimal places to truncate to.
+ * @returns The truncated coordinates.
+ */
 export const truncate = (a: Crude, precision: number = 0): XY => {
   const xy = construct(a);
   return { x: Number(xy.x.toFixed(precision)), y: Number(xy.y.toFixed(precision)) };

package/src/telem/generate.ts

@@ -1,4 +1,4 @@
-// Copyright 2023 Synnax Labs, Inc.
+// Copyright 2024 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.

package/src/telem/gl.ts

@@ -1,4 +1,4 @@
-// Copyright 2023 Synnax Labs, Inc.
+// Copyright 2024 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.

package/src/telem/index.ts

@@ -1,4 +1,4 @@
-// Copyright 2023 Synnax Labs, Inc.
+// Copyright 2024 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.
@@ -7,6 +7,6 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
+export type { GLBufferController } from "@/telem/gl";
 export * from "@/telem/series";
 export * from "@/telem/telem";
-export type { GLBufferController } from "@/telem/gl";

package/src/telem/series.spec.ts

@@ -1,4 +1,4 @@
-// Copyright 2023 Synnax Labs, Inc.
+// Copyright 2024 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.
@@ -7,11 +7,11 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { describe, expect, test, it } from "vitest";
+import { describe, expect, it,test } from "vitest";
 import { z } from "zod";
 
 import { MockGLBufferController } from "@/mock/MockGLBufferController";
-import { Series, isCrudeSeries, MultiSeries } from "@/telem/series";
+import { isCrudeSeries, MultiSeries,Series } from "@/telem/series";
 import { DataType, Rate, Size, TimeRange, TimeSpan, TimeStamp } from "@/telem/telem";
 
 describe("Series", () => {
@@ -30,6 +30,26 @@ describe("Series", () => {
       });
     });
 
+    describe("length", () => {
+      it("should return the correct length for a fixed density series", () => {
+        const a = new Series({
+          data: new Float32Array([1, 2, 3]),
+          dataType: DataType.FLOAT32,
+        });
+        expect(a.length).toEqual(3);
+      });
+      it("should return the correct length for a variable density series", () => {
+        const a = new Series({
+          data: [{ value: 1 }, { value: 2, red: "blue" }, { value: 3, dog: "14" }],
+        });
+        expect(a.dataType.equals(DataType.JSON)).toBeTruthy();
+        expect(a.length).toEqual(3);
+        const buf = a.data.buffer;
+        const c = new Series({ data: buf, dataType: DataType.JSON });
+        expect(c.length).toEqual(3);
+      });
+    });
+
     test("from another series", () => {
       const a = new Series({
         data: new Float32Array([1, 2, 3]),
@@ -58,7 +78,7 @@ describe("Series", () => {
 
     test("from buffer without data type provided", () => {
       expect(() => {
-        // eslint-disable-next-line no-new
+         
         new Series({ data: new ArrayBuffer(4) });
       }).toThrow();
     });
@@ -98,6 +118,7 @@ describe("Series", () => {
       const s = new Series({ data: [{ a: 1, b: "apple" }] });
       expect(s.dataType.equals(DataType.JSON));
       expect(s.length).toEqual(1);
+      expect(s.data.at(-1)).toEqual(10);
     });
 
     it("should correctly interpret a bigint as an int64", () => {
@@ -560,7 +581,6 @@ describe("Series", () => {
     describe("bigint", () => {
       it("should correctly interpret the series as a bigint", () => {
         const s = new Series([BigInt(1), BigInt(2), BigInt(3)]);
-        console.log(s.dataType);
         const s2 = s.as("bigint");
         expect(s2.at(0)).toEqual(BigInt(1));
       });
@@ -572,6 +592,30 @@ describe("Series", () => {
       });
     });
   });
+
+  describe("alignmentBounds", () => {
+    it("should correctly return the alignment bounds of a multi-series", () => {
+      const a = new Series({
+        data: new Float32Array([1, 2, 3]),
+        timeRange: new TimeRange(1, 2),
+        alignment: 1n,
+      });
+      expect(a.alignmentBounds).toEqual({ lower: 1n, upper: 4n });
+    });
+  });
+
+  describe("digest", () => {
+    it("should return a digest of information about the series", () => {
+      const digest = new Series({
+        data: new Float32Array([1, 2, 3]),
+        timeRange: new TimeRange(1, 3),
+      }).digest;
+      expect(digest.alignment).toEqual({ lower: 0n, upper: 3n });
+      expect(digest.dataType).toEqual("float32");
+      expect(digest.length).toEqual(3);
+      expect(digest.timeRange).toEqual(new TimeRange(1, 3).toString());
+    });
+  });
 });
 
 describe("MultiSeries", () => {
@@ -661,4 +705,19 @@ describe("MultiSeries", () => {
       expect(data).toEqual(new Float32Array([1, 2, 3, 4, 5, 6]));
     });
   });
+
+  describe("timeRange", () => {
+    it("should correctly return the time range of a multi-series", () => {
+      const a = new Series({
+        data: new Float32Array([1, 2, 3]),
+        timeRange: new TimeRange(1, 2),
+      });
+      const b = new Series({
+        data: new Float32Array([4, 5, 6]),
+        timeRange: new TimeRange(3, 4),
+      });
+      const multi = new MultiSeries([a, b]);
+      expect(multi.timeRange).toEqual(new TimeRange(1, 4));
+    });
+  });
 });

package/src/telem/series.ts

@@ -1,5 +1,4 @@
-/* eslint-disable @typescript-eslint/no-misused-new */
-// Copyright 2023 Synnax Labs, Inc.
+// Copyright 2024 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.
@@ -11,23 +10,24 @@
 import { nanoid } from "nanoid/non-secure";
 import { type z } from "zod";
 
+import { caseconv } from "@/caseconv";
 import { compare } from "@/compare";
 import { bounds } from "@/spatial";
 import { type GLBufferController, type GLBufferUsage } from "@/telem/gl";
 import {
   convertDataType,
+  type CrudeDataType,
+  type CrudeTimeStamp,
   DataType,
-  type TypedArray,
+  isTelemValue,
+  type NumericTelemValue,
   type Rate,
   Size,
-  TimeRange,
-  TimeStamp,
-  type CrudeDataType,
   type TelemValue,
-  isTelemValue,
+  TimeRange,
   TimeSpan,
-  type CrudeTimeStamp,
-  type NumericTelemValue,
+  TimeStamp,
+  type TypedArray,
 } from "@/telem/telem";
 
 interface GL {
@@ -41,7 +41,7 @@ export interface SeriesDigest {
   key: string;
   dataType: string;
   sampleOffset: NumericTelemValue;
-  alignment: bounds.Bounds;
+  alignment: bounds.Bounds<bigint>;
   timeRange?: string;
   length: number;
   capacity: number;
@@ -52,7 +52,7 @@ interface BaseSeriesProps {
   timeRange?: TimeRange;
   sampleOffset?: NumericTelemValue;
   glBufferUsage?: GLBufferUsage;
-  alignment?: number;
+  alignment?: bigint;
   key?: string;
 }
 
@@ -101,6 +101,7 @@ export interface SeriesMemInfo {
  */
 export class Series<T extends TelemValue = TelemValue> {
   key: string = "";
+  isSynnaxSeries = true;
   /** The data type of the array */
   readonly dataType: DataType;
   /**
@@ -116,7 +117,7 @@ export class Series<T extends TelemValue = TelemValue> {
   /** The underlying data. */
   private readonly _data: ArrayBufferLike;
   readonly _timeRange?: TimeRange;
-  readonly alignment: number = 0;
+  readonly alignment: bigint = 0n;
   /** A cached minimum value. */
   private _cachedMin?: NumericTelemValue;
   /** A cached maximum value. */
@@ -134,24 +135,30 @@ export class Series<T extends TelemValue = TelemValue> {
       timeRange,
       sampleOffset = 0,
       glBufferUsage = "static",
-      alignment = 0,
+      alignment = 0n,
       key = nanoid(),
     } = props;
     const { data } = props;
 
-    if (data instanceof Series) {
-      this.key = data.key;
-      this.dataType = data.dataType;
-      this.sampleOffset = data.sampleOffset;
-      this.gl = data.gl;
-      this._data = data._data;
-      this._timeRange = data._timeRange;
-      this.alignment = data.alignment;
-      this._cachedMin = data._cachedMin;
-      this._cachedMax = data._cachedMax;
-      this.writePos = data.writePos;
-      this._refCount = data._refCount;
-      this._cachedLength = data._cachedLength;
+    if (
+      data instanceof Series ||
+      (typeof data === "object" &&
+        "isSynnaxSeries" in data &&
+        data.isSynnaxSeries === true)
+    ) {
+      const data_ = data as Series;
+      this.key = data_.key;
+      this.dataType = data_.dataType;
+      this.sampleOffset = data_.sampleOffset;
+      this.gl = data_.gl;
+      this._data = data_._data;
+      this._timeRange = data_._timeRange;
+      this.alignment = data_.alignment;
+      this._cachedMin = data_._cachedMin;
+      this._cachedMax = data_._cachedMax;
+      this.writePos = data_.writePos;
+      this._refCount = data_._refCount;
+      this._cachedLength = data_._cachedLength;
       return;
     }
     const isSingle = isTelemValue(data);
@@ -291,7 +298,10 @@ export class Series<T extends TelemValue = TelemValue> {
     const available = this.capacity - this.writePos;
 
     const toWrite = available < other.length ? other.slice(0, available) : other;
-    this.underlyingData.set(toWrite.data as ArrayLike<any>, this.writePos);
+    this.underlyingData.set(
+      toWrite.data as unknown as ArrayLike<bigint> & ArrayLike<number>,
+      this.writePos,
+    );
     this.maybeRecomputeMinMax(toWrite);
     this._cachedLength = undefined;
     this.writePos += toWrite.length;
@@ -342,7 +352,7 @@ export class Series<T extends TelemValue = TelemValue> {
       .decode(this.buffer)
       .split("\n")
       .slice(0, -1)
-      .map((s) => schema.parse(JSON.parse(s)));
+      .map((s) => schema.parse(caseconv.toCamel(JSON.parse(s))));
   }
 
   /** @returns the time range of this array. */
@@ -475,7 +485,7 @@ export class Series<T extends TelemValue = TelemValue> {
 
   enrich(): void {
     let _ = this.max;
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+     
     _ = this.min;
   }
 
@@ -520,7 +530,9 @@ export class Series<T extends TelemValue = TelemValue> {
     const slice = this.data.slice(start, end);
     if (this.dataType.equals(DataType.STRING))
       return new TextDecoder().decode(slice) as unknown as T;
-    return JSON.parse(new TextDecoder().decode(slice)) as unknown as T;
+    return caseconv.toCamel(
+      JSON.parse(new TextDecoder().decode(slice)),
+    ) as unknown as T;
   }
 
   /**
@@ -629,8 +641,8 @@ export class Series<T extends TelemValue = TelemValue> {
     };
   }
 
-  get alignmentBounds(): bounds.Bounds {
-    return bounds.construct(this.alignment, this.alignment + this.length);
+  get alignmentBounds(): bounds.Bounds<bigint> {
+    return bounds.construct(this.alignment, this.alignment + BigInt(this.length));
   }
 
   private maybeGarbageCollectGLBuffer(gl: GLBufferController): void {
@@ -667,11 +679,11 @@ export class Series<T extends TelemValue = TelemValue> {
       timeRange: this._timeRange,
       sampleOffset: this.sampleOffset,
       glBufferUsage: this.gl.bufferUsage,
-      alignment: this.alignment + start,
+      alignment: this.alignment + BigInt(start),
     });
   }
 
-  reAlign(alignment: number): Series {
+  reAlign(alignment: bigint): Series {
     return new Series({
       data: this.buffer,
       dataType: this.dataType,
@@ -724,7 +736,7 @@ class JSONSeriesIterator implements Iterator<unknown> {
   next(): IteratorResult<object> {
     const next = this.wrapped.next();
     if (next.done === true) return { done: true, value: undefined };
-    return { done: false, value: JSON.parse(next.value) };
+    return { done: false, value: caseconv.toCamel(JSON.parse(next.value)) };
   }
 
   [Symbol.iterator](): Iterator<object> {