@synnaxlabs/x 0.7.0 → 0.9.0

package/src/spatial/bounds.ts

@@ -8,6 +8,7 @@
 // included in the file licenses/APL.txt.
 
 import { type Bounds, bounds, type CrudeBounds } from "@/spatial/base";
+import { resolveObjectURL } from "buffer";
 
 export { type Bounds, bounds };
 
@@ -40,34 +41,60 @@ export const DECIMAL = { lower: 0, upper: 1 };
 
 export const CLIP = { lower: -1, upper: 1 };
 
-export const equals = (a?: Bounds, b?: Bounds): boolean =>
-  a?.lower === b?.lower && a?.upper === b?.upper;
+export const equals = (_a?: Bounds, _b?: Bounds): boolean => {
+  if (_a == null && _b == null) return true;
+  if (_a == null || _b == null) return false;
+  const a = construct(_a);
+  const b = construct(_b);
+  return a?.lower === b?.lower && a?.upper === b?.upper;
+}
 
 export const makeValid = (a: Bounds): Bounds => {
   if (a.lower > a.upper) return { lower: a.upper, upper: a.lower };
   return a;
 };
 
-export const clamp = (bounds: Bounds, target: number): number => {
-  if (target < bounds.lower) return bounds.lower;
-  if (target >= bounds.upper) return bounds.upper - 1;
+export const clamp = (bounds: Crude, target: number): number => {
+  const _bounds = construct(bounds);
+  if (target < _bounds.lower) return _bounds.lower;
+  if (target >= _bounds.upper) return _bounds.upper - 1;
   return target;
 };
 
-export const contains = (bounds: Bounds, target: number): boolean =>
-  target >= bounds.lower && target < bounds.upper;
-
-export const overlapsWith = (a: Bounds, b: Bounds): boolean =>
-  contains(a, a.lower) || contains(b, b.upper - 1);
-
-export const span = (a: Bounds): number => a.upper - a.lower;
-
-export const isZero = (a: Bounds): boolean => a.lower === 0 && a.upper === 0;
-
-export const spanIsZero = (a: Bounds): boolean => span(a) === 0;
-
-export const isFinite = (a: Bounds): boolean =>
-  Number.isFinite(a.lower) && Number.isFinite(a.upper);
+export const contains = (bounds: Crude, target: number | CrudeBounds): boolean => {
+  const _bounds = construct(bounds);
+  if (typeof target === "number") return target >= _bounds.lower && target < _bounds.upper;
+  const _target = construct(target);
+  return _target.lower >= _bounds.lower && _target.upper <= _bounds.upper;
+}
+
+export const overlapsWith = (a: Crude, b: Crude): boolean => {
+  const _a = construct(a);
+  const _b = construct(b);
+  if (_a.lower ==_b.lower) return true;
+  if (_b.upper == _a.lower || _b.lower == _a.upper) return false;
+  return contains(_a, _b.upper) 
+  || contains(_a, _b.lower) 
+  || contains(_b, _a.upper) 
+  || contains(_b, _a.lower);
+}
+
+export const span = (a: Crude): number => {
+  const _a = construct(a);
+  return _a.upper - _a.lower;
+}
+
+export const isZero = (a: Crude): boolean => {
+  const _a = construct(a);
+  return _a.lower === 0 && _a.upper === 0;
+}
+
+export const spanIsZero = (a: Crude): boolean => span(a) === 0;
+
+export const isFinite = (a: Crude): boolean => {
+  const _a = construct(a);
+  return Number.isFinite(_a.lower) && Number.isFinite(_a.upper);
+}
 
 export const max = (bounds: Crude[]): Bounds => ({
   lower: Math.min(...bounds.map((b) => construct(b).lower)),
@@ -78,3 +105,112 @@ export const min = (bounds: Crude[]): Bounds => ({
   lower: Math.max(...bounds.map((b) => construct(b).lower)),
   upper: Math.min(...bounds.map((b) => construct(b).upper)),
 });
+
+export const constructArray = (bounds: Crude): number[] => {
+  const _bounds = construct(bounds);
+  return Array.from({ length: span(bounds) }, (_, i) => i + _bounds.lower);
+}
+
+export const findInsertPosition = (bounds: Crude[], target: number): { index: number, position: number } => {
+  const _bounds = bounds.map(construct);
+  const index = _bounds.findIndex((b, i) => contains(b, target) || target < _bounds[i].lower);
+  if (index === -1) return { index: bounds.length, position: 0 };
+  const b = _bounds[index];
+  if (contains(b, target)) return { index, position: target - b.lower };
+  return {index: index, position: 0};
+}
+
+
+/**
+ * A plan for inserting a new bound into an ordered array of bounds.
+ */
+export interface InsertionPlan {
+  /** How much to increase the lower bound of the new bound or decrease the upper bound
+   * of the previous bound. */
+  removeBefore: number;
+  /** How much to decrease the upper bound of the new bound or increase the lower bound
+   * of the next bound. */
+  removeAfter: number;
+  /** The index at which to insert the new bound. */
+  insertInto: number;
+  /** The number of bounds to remove from the array. */
+  deleteInBetween: number;
+}
+
+const ZERO_PLAN: InsertionPlan = {
+  removeBefore: 0,
+  removeAfter: 0,
+  insertInto: 0,
+  deleteInBetween: 0,
+}
+
+/**
+ * Build a plan for inserting a new bound into an ordered array of bounds. This function
+ * is particularly useful for inserting a new array into a sorted array of array of arrays
+ * that may overlap. The plan is used to determine how to splice the new array into the
+ * existing array. The following are important constraints:
+ * 
+ * 
+ * 1. If the new bound is entirely contained within an existing bound, the new bound
+ * is not inserted and the plan is null.
+ * 
+ * @param bounds - An ordered array of bounds, where each bound is valid (i.e., lower <= upper)
+ * and the lower bound of each bound is less than the upper bound of the next bound.
+ * @param value - The new bound to insert.
+ * @returns A plan for inserting the new bound into the array of bounds, or null if the
+ * new bound is entirely contained within an existing bound. See the {@link InsertionPlan}
+ * type for more details.
+ */
+export const buildInsertionPlan = (bounds: Crude[], value: Crude):InsertionPlan | null => {
+  const  _bounds = bounds.map(construct);
+  const _target = construct(value);
+  // No bounds to insert into, so just insert the new bound at the beginning of the array.
+  if (_bounds.length === 0) return ZERO_PLAN;
+  const lower = findInsertPosition(bounds, _target.lower);
+  const upper = findInsertPosition(bounds, _target.upper);
+  // Greater than all bounds,
+  if (lower.index == bounds.length) return { ...ZERO_PLAN, insertInto: bounds.length };
+  // Less than all bounds,
+  if (upper.index == 0) return {
+    ...ZERO_PLAN,
+    removeAfter: upper.position
+  }
+  if (lower.index === upper.index) {
+    // The case where the bound is entirely contained within an existing bound.
+    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 we're overlapping with the previous bound, we need to slice out one less
+  // and insert one further up.
+  if (lower.position != 0) {
+    deleteInBetween -= 1;
+    insertInto += 1;
+  // We're not overlapping with the previous bound, so don't need to remove anything
+  } else removeBefore = 0;
+  return {
+    removeBefore,
+    removeAfter: upper.position,
+    insertInto, 
+    deleteInBetween,
+  }
+}
+
+
+export const insert = (bounds: Crude[], value: Crude): Crude[] => {
+  const plan = buildInsertionPlan(bounds, value);
+  if (plan == null) return bounds;
+  const _target = construct(value);
+  _target.lower += plan.removeBefore;
+  _target.upper -= plan.removeAfter;
+  bounds.splice(plan.insertInto, plan.deleteInBetween, _target);
+  return bounds.map(construct);
+}

package/src/spatial/box.ts

@@ -115,6 +115,11 @@ export const construct = (
   return b;
 };
 
+export const resize = (
+  b: Box,
+  dims: dimensions.Dimensions,
+): Box => construct(b.one, dims);
+
 /**
  * Checks if a box contains a point or another box.
  *
@@ -184,6 +189,8 @@ export const dim = (
   return signed ? dim : Math.abs(dim);
 };
 
+
+
 /** @returns the pont corresponding to the given corner of the box. */
 export const xyLoc = (b: Crude, l: location.XY): xy.XY => {
   const b_ = construct(b);

package/src/spatial/dimensions.ts

@@ -62,3 +62,8 @@ export const min = (crude: Crude[]): Dimensions => ({
   width: Math.min(...crude.map((c) => construct(c).width)),
   height: Math.min(...crude.map((c) => construct(c).height)),
 });
+
+export const scale = (ca: Crude, factor: number): Dimensions => {
+  const a = construct(ca);
+  return { width: a.width * factor, height: a.height * factor };
+}

package/src/spatial/direction.ts

@@ -32,16 +32,16 @@ export const construct = (c: Crude): Direction => {
   else return "x";
 };
 
-export const swap = (direction: Direction): Direction =>
-  direction === "x" ? "y" : "x";
+export const swap = (direction: CrudeDirection): Direction =>
+  construct(direction) === "x" ? "y" : "x";
 
-export const dimension = (direction: Direction): Dimension =>
-  direction === "x" ? "width" : "height";
+export const dimension = (direction: CrudeDirection): Dimension =>
+  construct(direction) === "x" ? "width" : "height";
 
-export const location = (direction: Direction): Location =>
-  direction === "x" ? "left" : "top";
+export const location = (direction: CrudeDirection): Location =>
+  construct(direction) === "x" ? "left" : "top";
 
 export const isDirection = (c: unknown): c is Direction => crude.safeParse(c).success;
 
-export const signedDimension = (direction: Direction): SignedDimension =>
-  direction === "x" ? "signedWidth" : "signedHeight";
+export const signedDimension = (direction: CrudeDirection): SignedDimension =>
+  construct(direction) === "x" ? "signedWidth" : "signedHeight";

package/src/spatial/location.ts

@@ -52,6 +52,14 @@ const SWAPPED: Record<Location, Location> = {
   center: "center",
 };
 
+const ROTATE_90: Record<Location, Location> = {
+  top: "left",
+  right: "top",
+  bottom: "right",
+  left: "bottom",
+  center: "center",
+};
+
 export const crude = crudeLocation;
 
 export type Crude = CrudeLocation;
@@ -65,6 +73,8 @@ export const construct = (cl: Crude): Location => {
 
 export const swap = (cl: Crude): Location => SWAPPED[construct(cl)];
 
+export const rotate90 = (cl: Crude): Location => ROTATE_90[construct(cl)];
+
 export const direction = (cl: Crude): Direction => {
   const l = construct(cl);
   if (l === "top" || l === "bottom") return "y";
@@ -76,6 +86,7 @@ export const corner = z.object({ x: xLocation, y: yLocation });
 
 export type XY = z.infer<typeof xy>;
 export type CornerXY = z.infer<typeof corner>;
+export type CornerXYString = "topLeft" | "topRight" | "bottomLeft" | "bottomRight";
 
 export const TOP_LEFT: CornerXY = { x: "left", y: "top" };
 export const TOP_RIGHT: CornerXY = { x: "right", y: "top" };

package/src/spatial/xy.spec.ts

@@ -46,6 +46,14 @@ test("translate", () => {
   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);
+});
+
 describe("equals", () => {
   const TESTS: Array<[xy.Crude, xy.Crude, boolean]> = [
     [[1, 1], { x: 1, y: 1 }, true],

package/src/spatial/xy.ts

@@ -25,6 +25,7 @@ export { clientXY, xy, type ClientXY as Client, type XY };
 
 /** A crude representation of a {@link XY} coordinate as a zod schema. */
 export const crudeZ = z.union([
+  z.number(),
   xy,
   numberCouple,
   dimensions,
@@ -38,17 +39,19 @@ export type Crude = z.infer<typeof crudeZ>;
 /**
  * @constructs XY
  * @param x - A crude representation of the XY coordinate as a number, number couple,
- * dimensions, signed dimensions, or client XY.
+ * dimensions, signed dimensions, or mouse event. If it's a mouse event, the clientX and
+ * clientY coordinates are preferred over the x and y coordinates.
  * @param y - If x is a number, the y coordinate. If x is a number and this argument is
  * not given, the y coordinate is assumed to be the same as the x coordinate.
  */
-export const construct = (x: Crude | number, y?: number): XY => {
+export const construct = (x: Crude, y?: number): XY => {
+  // The order in which we execute these checks is very important.
   if (typeof x === "number") return { x, y: y ?? x };
   if (Array.isArray(x)) return { x: x[0], y: x[1] };
   if ("signedWidth" in x) return { x: x.signedWidth, y: x.signedHeight };
   if ("clientX" in x) return { x: x.clientX, y: x.clientY };
   if ("width" in x) return { x: x.width, y: x.height };
-  return { ...x };
+  return { x: x.x, y: x.y };
 };
 
 /** An x and y coordinate of zero */
@@ -63,11 +66,12 @@ export const INFINITY = { x: Infinity, y: Infinity };
 /** An x and y coordinate of NaN */
 export const NAN = { x: NaN, y: NaN };
 
-/** @returns true if the two XY coordinates are semntically equal. */
-export const equals = (a: Crude, b: Crude): boolean => {
+/** @returns true if the two XY coordinates are semantically equal. */
+export const equals = (a: Crude, b: Crude, threshold: number = 0): boolean => {
   const a_ = construct(a);
   const b_ = construct(b);
-  return a_.x === b_.x && a_.y === b_.y;
+  if (threshold === 0) return a_.x === b_.x && a_.y === b_.y;
+  return Math.abs(a_.x - b_.x) <= threshold && Math.abs(a_.y - b_.y) <= threshold;
 };
 
 /** Is zero is true if the XY coordinate has a semantic x and y value of zero. */
@@ -94,15 +98,28 @@ export const translateY = (c: Crude, y: number): XY => {
   return { x: p.x, y: p.y + y };
 };
 
+type TranslateOverloadOne = (a: Crude, b: Crude, ...cb: Crude[]) => XY;
+type TranslateOverloadTwo = (a: Crude, direction: Direction, value: number) => XY;
+
 /**
  * @returns the given coordinate translated by an arbitrary number of translation
  * coordinates.
  */
-export const translate = (a: Crude, b: Crude, ...cb: Crude[]): XY =>
-  [a, b, ...cb].reduce((p: XY, c) => {
-    const xy = construct(c);
+export const translate: TranslateOverloadOne & TranslateOverloadTwo = (
+  a,
+  b,
+  v,
+  ...cb
+): XY => {
+  if (typeof b === "string" && typeof v === "number") {
+    if (b === "x") return translateX(a, v);
+    return translateY(a, v);
+  }
+  return [a, b, v ?? ZERO, ...cb].reduce((p: XY, c) => {
+    const xy = construct(c as Crude);
     return { x: p.x + xy.x, y: p.y + xy.y };
   }, ZERO);
+};
 
 /**
  * @returns the given coordinate the given direction set to the given value.
@@ -151,6 +168,12 @@ export const isNan = (a: Crude): boolean => {
   return Number.isNaN(xy.x) || Number.isNaN(xy.y);
 };
 
+/** @returns true if both the x and y coordinates of the given coordinate are finite. */
+export const isFinite = (a: Crude): boolean => {
+  const xy = construct(a);
+  return Number.isFinite(xy.x) && Number.isFinite(xy.y);
+}
+
 /** @returns the coordinate represented as a couple of the form [x, y]. */
 export const couple = (a: Crude): NumberCouple => {
   const xy = construct(a);

package/src/telem/series.spec.ts

@@ -17,42 +17,42 @@ import { DataType, Rate, Size, TimeRange, TimeStamp } from "@/telem/telem";
 describe("Series", () => {
   describe("construction", () => {
     test("valid from native", () => {
-      const a = new Series(new Float32Array([1, 2, 3]));
+      const a = new Series({data: new Float32Array([1, 2, 3])});
       expect(a.dataType.toString()).toBe(DataType.FLOAT32.toString());
       expect(a.length).toEqual(3);
       expect(a.byteLength).toEqual(Size.bytes(12));
       expect(a.byteCap).toEqual(Size.bytes(12));
       expect(a.cap).toEqual(3);
-      const b = new Series(new BigInt64Array([BigInt(1)]));
+      const b = new Series({data: new BigInt64Array([BigInt(1)])});
       expect(b.dataType.toString()).toBe(DataType.INT64.toString());
-      const c = new Series(new BigInt64Array([BigInt(1)]), DataType.TIMESTAMP);
+      const c = new Series({data: new BigInt64Array([BigInt(1)]), dataType: DataType.TIMESTAMP});
       expect(c.dataType.toString()).toBe(DataType.TIMESTAMP.toString());
     });
 
     test("from buffer without data type provided", () => {
       expect(() => {
         // eslint-disable-next-line no-new
-        new Series(new ArrayBuffer(4));
+        new Series({data: new ArrayBuffer(4)});
       }).toThrow();
     });
 
     test("from buffer with data type provided", () => {
-      const a = new Series(new ArrayBuffer(4), DataType.FLOAT32);
+      const a = new Series({data: new ArrayBuffer(4), dataType: DataType.FLOAT32});
       expect(a.dataType.toString()).toBe(DataType.FLOAT32.toString());
     });
 
     test("with time range", () => {
-      const a = new Series(
-        new Float32Array([1, 2, 3]),
-        DataType.FLOAT32,
-        new TimeRange(1, 2),
-      );
+      const a = new Series({
+        data: new Float32Array([1, 2, 3]),
+        dataType: DataType.FLOAT32,
+        timeRange: new TimeRange(1, 2),
+    });
       expect(a.timeRange.span.valueOf()).toBe(1);
     });
 
     describe("allocation", () => {
       it("should allocate a lazy array", () => {
-        const arr = Series.alloc(10, DataType.FLOAT32);
+        const arr = Series.alloc({length: 10, dataType: DataType.FLOAT32});
         expect(arr.byteCap).toEqual(Size.bytes(40));
         expect(arr.cap).toEqual(10);
         expect(arr.length).toEqual(0);
@@ -60,33 +60,32 @@ describe("Series", () => {
       });
       it("should throw an error when attempting to allocate an array of lenght 0", () => {
         expect(() => {
-          Series.alloc(0, DataType.FLOAT32);
+          Series.alloc({length: 0, dataType: DataType.FLOAT32});
         }).toThrow();
       });
     });
   });
 
-  test("at", () => {
+  describe("at", () => {
     it("should return the value at the given index and add the sample offset", () => {
-      const arr = new Series(
-        new Float32Array([1, 2, 3]),
-        DataType.FLOAT32,
-        undefined,
-        2,
-      );
+      const arr = new Series({
+        data: new Float32Array([1, 2, 3]),
+        dataType: DataType.FLOAT32,
+        sampleOffset: 2,
+    });
       expect(arr.at(0)).toEqual(3);
       expect(arr.at(1)).toEqual(4);
       expect(arr.at(2)).toEqual(5);
     });
     it("should return undefined when the index is out of bounds", () => {
-      const arr = new Series(new Float32Array([1, 2, 3]), DataType.FLOAT32);
+      const arr = new Series({data: new Float32Array([1, 2, 3]), dataType: DataType.FLOAT32});
       expect(arr.at(3)).toBeUndefined();
     });
   });
 
   describe("slice", () => {
     it("should slice a lazy array", () => {
-      const a = new Series(new Float32Array([1, 2, 3]), DataType.FLOAT32);
+      const a = new Series({data: new Float32Array([1, 2, 3]), dataType: DataType.FLOAT32});
       const b = a.slice(1, 2);
       expect(b.dataType.toString()).toBe(DataType.FLOAT32.toString());
       expect(b.data).toEqual(new Float32Array([2]));
@@ -99,12 +98,12 @@ describe("Series", () => {
 
   describe("min and max", () => {
     it("should return a min and max of zero on an allocated array", () => {
-      const arr = Series.alloc(10, DataType.FLOAT32);
+      const arr = Series.alloc({length: 10, dataType: DataType.FLOAT32});
       expect(arr.max).toEqual(-Infinity);
       expect(arr.min).toEqual(Infinity);
     });
     it("should correctly calculate the min and max of a lazy array", () => {
-      const arr = new Series(new Float32Array([1, 2, 3]), DataType.FLOAT32);
+      const arr = new Series({data: new Float32Array([1, 2, 3]), dataType: DataType.FLOAT32});
       expect(arr.max).toEqual(3);
       expect(arr.min).toEqual(1);
     });
@@ -112,21 +111,21 @@ describe("Series", () => {
 
   describe("conversion", () => {
     test("from float64 to float32", () => {
-      const a = new Series(new Float64Array([1, 2, 3]), DataType.FLOAT64);
+      const a = new Series({data: new Float64Array([1, 2, 3]), dataType: DataType.FLOAT64});
       const b = a.convert(DataType.FLOAT32);
       expect(b.dataType.toString()).toBe(DataType.FLOAT32.toString());
       expect(b.data).toEqual(new Float32Array([1, 2, 3]));
     });
 
     test("from int64 to int32", () => {
-      const a = new Series(new BigInt64Array([BigInt(1), BigInt(2), BigInt(3)]));
+      const a = new Series({data: new BigInt64Array([BigInt(1), BigInt(2), BigInt(3)])});
       const b = a.convert(DataType.INT32);
       expect(b.dataType.toString()).toBe(DataType.INT32.toString());
       expect(b.data).toEqual(new Int32Array([1, 2, 3]));
     });
 
     test("from float32 to int64", () => {
-      const a = new Series(new Float32Array([1, 2, 3]), DataType.FLOAT32);
+      const a = new Series({data: new Float32Array([1, 2, 3]), dataType: DataType.FLOAT32});
       const b = a.convert(DataType.INT64);
       expect(b.dataType.toString()).toBe(DataType.INT64.toString());
       expect(b.data).toEqual(new BigInt64Array([BigInt(1), BigInt(2), BigInt(3)]));
@@ -135,35 +134,35 @@ describe("Series", () => {
 
   describe("writing", () => {
     it("should correctly write to an allocated lazy array", () => {
-      const arr = Series.alloc(10, DataType.FLOAT32);
+      const arr = Series.alloc({length: 10, dataType: DataType.FLOAT32});
       expect(arr.byteCap).toEqual(Size.bytes(40));
       expect(arr.length).toEqual(0);
-      const writeOne = new Series(new Float32Array([1]));
+      const writeOne = new Series({data:new Float32Array([1])});
       expect(arr.write(writeOne)).toEqual(1);
       expect(arr.length).toEqual(1);
-      const writeTwo = new Series(new Float32Array([2, 3]));
+      const writeTwo = new Series({data: new Float32Array([2, 3])});
       expect(arr.write(writeTwo)).toEqual(2);
       expect(arr.length).toEqual(3);
     });
     it("should recompute cached max and min correctly", () => {
-      const arr = Series.alloc(10, DataType.FLOAT32);
+      const arr = Series.alloc({length: 10, dataType: DataType.FLOAT32});
       arr.enrich();
-      const writeTwo = new Series(new Float32Array([2, 3]));
+      const writeTwo = new Series({data: new Float32Array([2, 3])});
       arr.write(writeTwo);
       expect(arr.max).toEqual(3);
       expect(arr.min).toEqual(2);
     });
     it("should correctly adjust the sample offset of a written array", () => {
-      const arr = Series.alloc(2, DataType.FLOAT32, TimeRange.ZERO, -3);
-      const writeOne = new Series(new Float32Array([-2]));
+      const arr = Series.alloc({length: 2, dataType: DataType.FLOAT32, timeRange: TimeRange.ZERO, sampleOffset: -3});
+      const writeOne = new Series({data: new Float32Array([-2])});
       expect(arr.write(writeOne)).toEqual(1);
       expect(arr.min).toEqual(-5);
-      const writeTwo = new Series(
-        new Float32Array([1]),
-        DataType.FLOAT32,
-        TimeRange.ZERO,
-        -1,
-      );
+      const writeTwo = new Series({
+        data: new Float32Array([1]),
+        dataType: DataType.FLOAT32,
+        timeRange: TimeRange.ZERO,
+        sampleOffset: -1,
+    });
       expect(arr.write(writeTwo)).toEqual(1);
       expect(arr.min).toEqual(-5);
       expect(arr.max).toEqual(-2);
@@ -193,7 +192,7 @@ describe("Series", () => {
 
   describe("webgl buffering", () => {
     it("should correctly buffer a new lazy array", () => {
-      const arr = new Series(new Float32Array([1, 2, 3]), DataType.FLOAT32);
+      const arr = new Series({data: new Float32Array([1, 2, 3]), dataType: DataType.FLOAT32});
       const controller = new MockGLBufferController();
       arr.updateGLBuffer(controller);
       expect(controller.createBufferMock).toHaveBeenCalledTimes(1);
@@ -206,7 +205,7 @@ describe("Series", () => {
       expect(buf).toEqual(new Float32Array([1, 2, 3]));
     });
     it("should correctly update a buffer when writing to an allocated array", () => {
-      const arr = Series.alloc(10, DataType.FLOAT32);
+      const arr = Series.alloc({length: 10, dataType: DataType.FLOAT32});
       const controller = new MockGLBufferController();
       arr.updateGLBuffer(controller);
       expect(controller.createBufferMock).toHaveBeenCalledTimes(1);
@@ -216,7 +215,7 @@ describe("Series", () => {
       let buf = controller.buffers[arr.glBuffer as number];
       expect(buf).toBeDefined();
       expect(buf.byteLength).toEqual(0);
-      const writeOne = new Series(new Float32Array([1]));
+      const writeOne = new Series({data: new Float32Array([1])});
       arr.write(writeOne);
       arr.updateGLBuffer(controller);
       expect(controller.bufferDataMock).toHaveBeenCalledTimes(1);
@@ -224,7 +223,7 @@ describe("Series", () => {
       buf = controller.buffers[arr.glBuffer as number];
       expect(buf.byteLength).toEqual(arr.byteCap.valueOf());
       expect(new Float32Array(buf)[0]).toEqual(1);
-      const writeTwo = new Series(new Float32Array([2, 3]));
+      const writeTwo = new Series({data: new Float32Array([2, 3])});
       arr.write(writeTwo);
       arr.updateGLBuffer(controller);
       expect(controller.bufferDataMock).not.toHaveBeenCalledTimes(2);
@@ -239,7 +238,7 @@ describe("Series", () => {
 
   describe("acquire", () => {
     it("should increase the reference count and buffer gl data", () => {
-      const s = new Series(new Float32Array([1, 2, 3]));
+      const s = new Series({data: new Float32Array([1, 2, 3])});
       expect(s.refCount).toEqual(0);
       const control = new MockGLBufferController();
       s.acquire(control);
@@ -259,7 +258,7 @@ describe("Series", () => {
       expect(outStrings).toEqual(["apple", "banana", "carrot"]);
     });
     it("should throw an error if the series is not of type string", () => {
-      const s = new Series(new Float32Array([1, 2, 3]));
+      const s = new Series({data: new Float32Array([1, 2, 3])});
       expect(() => {
         s.toStrings();
       }).toThrow();
@@ -278,7 +277,6 @@ describe("Series", () => {
         { a: 3, b: "carrot" },
       ]);
       const outJSON = s.parseJSON(schema);
-      print(outJSON);
       expect(outJSON).toEqual([
         { a: 1, b: "apple" },
         { a: 2, b: "banana" },
@@ -286,4 +284,14 @@ describe("Series", () => {
       ]);
     });
   });
+  
+  describe("binarySearch", () => {
+    it("should correctly binary search a pre-allocated array", () => {
+      const arr = Series.alloc({length: 10, dataType: DataType.FLOAT32});
+      const writeOne = new Series({data: new Float32Array([1, 2, 3, 4, 5])});
+      arr.write(writeOne);
+      expect(arr.binarySearch(3)).toEqual(2);
+      expect(arr.binarySearch(6)).toEqual(5);
+    })
+  })
 });