@synnaxlabs/x 0.34.0 → 0.36.0

package/src/breaker/breaker.spec.ts

@@ -0,0 +1,74 @@
+import { describe, it, expect, vi } from "vitest";
+import { breaker } from "@/breaker";
+import { TimeSpan } from "@/telem";
+
+describe("breaker", () => {
+  it("should allow first attempt without sleeping", async () => {
+    const mockSleep = vi.fn();
+    const brk = breaker.create({ sleepFn: mockSleep });
+    const canRetry = await brk();
+
+    expect(canRetry).toBe(true);
+    expect(mockSleep).toHaveBeenCalled();
+  });
+
+  it("should retry specified number of times before failing", async () => {
+    const mockSleep = vi.fn();
+    const brk = breaker.create({
+      maxRetries: 2,
+      interval: TimeSpan.milliseconds(1),
+      sleepFn: mockSleep,
+    });
+
+    // First attempt
+    expect(await brk()).toBe(true);
+    // Second attempt
+    expect(await brk()).toBe(true);
+    // Third attempt (should fail)
+    expect(await brk()).toBe(false);
+
+    expect(mockSleep).toHaveBeenCalledTimes(2);
+  });
+
+  it("should increase delay between retries according to scale", async () => {
+    const mockSleep = vi.fn();
+    const brk = breaker.create({
+      interval: TimeSpan.seconds(1),
+      maxRetries: 3,
+      scale: 2,
+      sleepFn: mockSleep,
+    });
+
+    await brk(); // First attempt - 1s
+    await brk(); // Second attempt - 1s * 2 = 2s;
+    await brk(); // Third attempt - 2s *2 = 4s;
+
+    expect(mockSleep).toHaveBeenNthCalledWith(1, TimeSpan.seconds(1));
+    expect(mockSleep).toHaveBeenNthCalledWith(2, TimeSpan.seconds(2));
+    expect(mockSleep).toHaveBeenNthCalledWith(3, TimeSpan.seconds(4));
+  });
+
+  it("should use default values when no options provided", async () => {
+    const brk = breaker.create();
+    let attempts = 0;
+
+    while (await brk()) {
+      attempts++;
+    }
+
+    expect(attempts).toBe(5); // Default maxRetries is 5
+  });
+
+  it("should use custom sleep function when provided", async () => {
+    const customSleep = vi.fn();
+    const brk = breaker.create({
+      interval: TimeSpan.milliseconds(100),
+      sleepFn: customSleep,
+    });
+
+    await brk();
+    await brk();
+
+    expect(customSleep).toHaveBeenCalledTimes(2);
+  });
+});

package/src/breaker/breaker.ts

@@ -0,0 +1,32 @@
+import { sleep } from "@/sleep";
+import { CrudeTimeSpan, TimeSpan } from "@/telem";
+import { z } from "zod";
+
+export const breakerConfig = z.object({
+  interval: TimeSpan.z.optional(),
+  maxRetries: z.number().optional(),
+  scale: z.number().optional(),
+});
+
+export interface Config extends Omit<z.infer<typeof breakerConfig>, "interval"> {
+  interval?: CrudeTimeSpan;
+  maxRetries?: number;
+  scale?: number;
+  sleepFn?: (duration: TimeSpan) => Promise<void>;
+}
+
+export const create = (options: Config = {}): (() => Promise<boolean>) => {
+  const sleepFn = options.sleepFn || sleep.sleep;
+  const maxRetries = options.maxRetries ?? 5;
+  const scale = options.scale ?? 1;
+  let retries = 0;
+  let interval = new TimeSpan(options.interval ?? TimeSpan.milliseconds(1));
+  return async () => {
+    // Change from arrow function to regular function to preserve 'this'
+    if (retries >= maxRetries) return false;
+    await sleepFn(interval);
+    interval = interval.mult(scale);
+    retries++;
+    return true;
+  };
+};

package/src/breaker/index.ts

@@ -0,0 +1 @@
+export * as breaker from "@/breaker/breaker";

package/src/deep/path.ts

@@ -163,7 +163,12 @@ export const set = <V>(obj: V, path: string, value: unknown): void => {
     result[part] ??= {};
     result = result[part] as UnknownRecord;
   }
-  result[parts[parts.length - 1]] = value;
+  try {
+    result[parts[parts.length - 1]] = value;
+  } catch (e) {
+    console.error("failed to set value", value, "at path", path, "on object", obj);
+    throw e;
+  }
 };
 
 /**

package/src/index.ts

@@ -41,3 +41,4 @@ export * from "@/unique";
 export * from "@/url";
 export * from "@/worker";
 export * from "@/zodutil";
+export * from "@/breaker";

package/src/mock/MockGLBufferController.ts

@@ -41,14 +41,14 @@ export class MockGLBufferController implements GLBufferController {
 
   bufferData(
     target: number,
-    dataOrSize: ArrayBufferLike | number,
+    dataOrSize: AllowSharedBufferSource | number,
     usage: number,
   ): void {
     if (typeof dataOrSize === "number")
       this.buffers[this.targets[target]] = new ArrayBuffer(dataOrSize);
-    else this.buffers[this.targets[target]] = dataOrSize;
+    else this.buffers[this.targets[target]] = dataOrSize as ArrayBuffer;
 
-    this.bufferDataMock(target, dataOrSize, usage);
+    this.bufferDataMock(target, dataOrSize as ArrayBuffer, usage);
   }
 
   bindBuffer(target: number, buffer: WebGLBuffer | null): void {
@@ -57,14 +57,14 @@ export class MockGLBufferController implements GLBufferController {
     this.bindBufferMock(target, buffer);
   }
 
-  bufferSubData(target: number, offset: number, data: ArrayBufferLike): void {
+  bufferSubData(target: number, offset: number, data: AllowSharedBufferSource): void {
     let buffer = this.buffers[this.targets[target]];
     if (buffer == null) {
       buffer = new ArrayBuffer(offset + data.byteLength);
       this.buffers[target] = buffer;
     }
     const view = new Uint8Array(buffer);
-    view.set(new Uint8Array(data), offset);
-    this.bufferSubDataMock(target, offset, data);
+    view.set(new Uint8Array(data as ArrayBuffer), offset);
+    this.bufferSubDataMock(target, offset, data as ArrayBuffer);
   }
 }

package/src/record.spec.ts

@@ -0,0 +1,29 @@
+import { describe, expect, it } from "vitest";
+
+import { mapValues } from "@/record";
+
+describe("mapValues", () => {
+  it("should map values of a record using the provided function", () => {
+    const input = { a: 1, b: 2, c: 3 };
+    const result = mapValues(input, (x) => x * 2);
+    expect(result).toEqual({ a: 2, b: 4, c: 6 });
+  });
+
+  it("should handle empty objects", () => {
+    const input = {};
+    const result = mapValues(input, (x) => x * 2);
+    expect(result).toEqual({});
+  });
+
+  it("should handle different value types", () => {
+    const input = { name: "John", age: 30 };
+    const result = mapValues(input, (value) => String(value));
+    expect(result).toEqual({ name: "John", age: "30" });
+  });
+
+  it("should preserve keys while transforming values", () => {
+    const input = { x: "hello", y: "world" };
+    const result = mapValues(input, (str) => str.toUpperCase());
+    expect(result).toEqual({ x: "HELLO", y: "WORLD" });
+  });
+});

package/src/record.ts

@@ -35,3 +35,9 @@ export type Entries<T> = Array<
 
 export const getEntries = <T extends Record<Key, unknown>>(obj: T): Entries<T> =>
   Object.entries(obj) as Entries<T>;
+
+export const mapValues = <T extends Record<Key, unknown>, U>(
+  obj: T,
+  fn: (value: T[keyof T], key: Key) => U,
+): Record<Key, U> =>
+  Object.fromEntries(getEntries(obj).map(([key, value]) => [key, fn(value, key as Key)]));

package/src/sleep/index.ts

@@ -0,0 +1 @@
+export * as sleep from "@/sleep/sleep";

package/src/sleep/sleep.ts

@@ -0,0 +1,6 @@
+import { CrudeTimeSpan, TimeSpan } from "@/telem";
+
+export const sleep = async (span: CrudeTimeSpan): Promise<void> =>
+  await new Promise((resolve) =>
+    setTimeout(resolve, TimeSpan.fromMilliseconds(span).milliseconds),
+  );

package/src/spatial/bounds/bounds.spec.ts

@@ -387,4 +387,10 @@ describe("Bounds", () => {
       expect(bounds.clamp(b, 4)).toEqual(2);
     });
   });
+  describe("mean", () => {
+    it("should return the mean of the bounds", () => {
+      const b = bounds.construct([1, 3]);
+      expect(bounds.mean(b)).toEqual(2);
+    });
+  });
 });

package/src/spatial/bounds/bounds.ts

@@ -191,6 +191,22 @@ export const isFinite = (a: Crude): boolean => {
   return Number.isFinite(_a.lower) && Number.isFinite(_a.upper);
 };
 
+/**
+ * Returns the mean value between the lower and upper bounds.
+ *
+ * @param a - The bounds to find the mean of. Can be either a strict bounds object
+ * with 'lower' and 'upper' properties or an array of length 2.
+ * @returns The mean value between the lower and upper bounds.
+ *
+ * @example
+ * bounds.mean([0, 10]) // => 5
+ * bounds.mean({ lower: 0, upper: 10 }) // => 5
+ */
+export const mean = (a: Crude): number => {
+  const _a = construct(a);
+  return (_a.upper + _a.lower) / 2;
+};
+
 /**
  * @returns bounds that have the maximum span of the given bounds i.e. the min of all
  * of the lower bounds and the max of all of the upper bounds.

package/src/spatial/location/location.ts

@@ -41,6 +41,7 @@ export {
 
 export const x = xLocation;
 export const y = yLocation;
+export const center = centerLocation;
 
 export type X = XLocation;
 export type Y = YLocation;

package/src/spatial/scale/scale.spec.ts

@@ -15,60 +15,71 @@ import { Scale, XY } from "@/spatial/scale/scale";
 type ScaleSpec = [name: string, scale: Scale<number>, i: number, o: number];
 
 describe("Scale", () => {
-  describe("Scale", () => {
-    const simpleScale = Scale.scale<number>(0, 10).scale(0, 1);
-    const translateScale = Scale.scale<number>(0, 10).translate(5).scale(0, 1);
-    const translateMagnifyScale = Scale.scale<number>(0, 10)
-      .translate(5)
-      .magnify(2)
-      .scale(0, 1);
-    describe("position", () => {
-      const positionSpecs: ScaleSpec[] = [
-        ["basic", simpleScale, 0, 0],
-        ["basic II", simpleScale, 5, 0.5],
-        ["reverse basic", simpleScale.reverse(), 0, 0],
-        ["reverse basic II", simpleScale.reverse(), 0.5, 5],
-        ["translate", translateScale, 0, 0.5],
-        ["translate II", translateScale, 5, 1],
-        ["reverse translate", translateScale.reverse(), 0.5, 0],
-        ["reverse translate II", translateScale.reverse(), 0, -5],
-        ["translate magnify", translateMagnifyScale, 0, 1],
-        ["translate magnify II", translateMagnifyScale, 5, 2],
-        ["reverse translate magnify", translateMagnifyScale.reverse(), 1, 0],
-        ["reverse translate magnify II", translateMagnifyScale.reverse(), 0, -5],
-      ];
-      positionSpecs.forEach(([name, scale, i, o]) => {
-        it(`should return ${o} for ${i} on ${name}`, () => {
-          expect(scale.pos(i)).toBe(o);
-        });
+  const simpleScale = Scale.scale<number>(0, 10).scale(0, 1);
+  const translateScale = Scale.scale<number>(0, 10).translate(5).scale(0, 1);
+  const translateMagnifyScale = Scale.scale<number>(0, 10)
+    .translate(5)
+    .magnify(2)
+    .scale(0, 1);
+  describe("position", () => {
+    const positionSpecs: ScaleSpec[] = [
+      ["basic", simpleScale, 0, 0],
+      ["basic II", simpleScale, 5, 0.5],
+      ["reverse basic", simpleScale.reverse(), 0, 0],
+      ["reverse basic II", simpleScale.reverse(), 0.5, 5],
+      ["translate", translateScale, 0, 0.5],
+      ["translate II", translateScale, 5, 1],
+      ["reverse translate", translateScale.reverse(), 0.5, 0],
+      ["reverse translate II", translateScale.reverse(), 0, -5],
+      ["translate magnify", translateMagnifyScale, 0, 1],
+      ["translate magnify II", translateMagnifyScale, 5, 2],
+      ["reverse translate magnify", translateMagnifyScale.reverse(), 1, 0],
+      ["reverse translate magnify II", translateMagnifyScale.reverse(), 0, -5],
+    ];
+    positionSpecs.forEach(([name, scale, i, o]) => {
+      it(`should return ${o} for ${i} on ${name}`, () => {
+        expect(scale.pos(i)).toBe(o);
       });
     });
-    describe("dimension", () => {
-      const dimensionSpecs: ScaleSpec[] = [
-        ["basic", simpleScale, 0, 0],
-        ["basic II", simpleScale, 5, 0.5],
-        ["reverse basic", simpleScale.reverse(), 0, 0],
-        ["reverse basic II", simpleScale.reverse(), 0.5, 5],
-        ["translate", translateScale, 0, 0],
-        ["translate II", translateScale, 5, 0.5],
-        ["reverse translate", translateScale.reverse(), 0.5, 5],
-        ["translate magnify", translateMagnifyScale, 0, 0],
-        ["translate magnify II", translateMagnifyScale, 5, 1],
-      ];
-      dimensionSpecs.forEach(([name, scale, i, o]) => {
-        it(`should return ${o} for ${i} on ${name}`, () =>
-          expect(scale.dim(i)).toBe(o));
-      });
+  });
+  describe("dimension", () => {
+    const dimensionSpecs: ScaleSpec[] = [
+      ["basic", simpleScale, 0, 0],
+      ["basic II", simpleScale, 5, 0.5],
+      ["reverse basic", simpleScale.reverse(), 0, 0],
+      ["reverse basic II", simpleScale.reverse(), 0.5, 5],
+      ["translate", translateScale, 0, 0],
+      ["translate II", translateScale, 5, 0.5],
+      ["reverse translate", translateScale.reverse(), 0.5, 5],
+      ["translate magnify", translateMagnifyScale, 0, 0],
+      ["translate magnify II", translateMagnifyScale, 5, 1],
+    ];
+    dimensionSpecs.forEach(([name, scale, i, o]) => {
+      it(`should return ${o} for ${i} on ${name}`, () => expect(scale.dim(i)).toBe(o));
     });
-    describe("XYScale", () => {
-      test("converting a DOM rect to decimal coordinates", () => {
-        const s = XY.scale(box.construct(100, 100, 1000, 1000)).scale(box.DECIMAL);
-        const b1 = s.box(box.construct(100, 100, 1000, 1000));
-        expect(box.bottomLeft(b1)).toEqual({ x: 0, y: 0 });
-        const b2 = s.box(box.construct(200, 200, 200, 200));
-        expect(box.bottomLeft(b2).x).toBeCloseTo(0.1);
-        expect(box.bottomLeft(b2).y).toBeCloseTo(0.7);
-      });
+  });
+  describe("XYScale", () => {
+    test("converting a DOM rect to decimal coordinates", () => {
+      const s = XY.scale(box.construct(100, 100, 1000, 1000)).scale(box.DECIMAL);
+      const b1 = s.box(box.construct(100, 100, 1000, 1000));
+      expect(box.bottomLeft(b1)).toEqual({ x: 0, y: 0 });
+      const b2 = s.box(box.construct(200, 200, 200, 200));
+      expect(box.bottomLeft(b2).x).toBeCloseTo(0.1);
+      expect(box.bottomLeft(b2).y).toBeCloseTo(0.7);
+    });
+  });
+  describe("transform", () => {
+    it("should return the correct transform", () => {
+      const s = Scale.scale<number>(0, 10).translate(5).magnify(2).scale(0, 1);
+      const t = s.transform;
+      expect(t.scale).toBe(0.2);
+      expect(t.offset).toBe(1);
+    });
+    it("should return the correct transform for an XY scale", () => {
+      const s = XY.translate({ x: 5, y: 5 }).magnify({ x: 2, y: 2 });
+      const t = s.transform;
+      expect(t.scale).toEqual({ x: 2, y: 2 });
+      expect(t.offset).toEqual({ x: 10, y: 10 });
     });
   });
 });

package/src/spatial/scale/scale.ts

@@ -19,9 +19,14 @@ import * as location from "@/spatial/location/location";
 import * as xy from "@/spatial/xy/xy";
 
 export const crudeXYTransform = z.object({ offset: xy.crudeZ, scale: xy.crudeZ });
-
 export type XYTransformT = z.infer<typeof crudeXYTransform>;
 
+export const transform = z.object({ offset: z.number(), scale: z.number() });
+export type TransformT<T extends numeric.Value = number> = {
+  offset: T;
+  scale: T;
+};
+
 export type BoundVariant = "domain" | "range";
 
 type ValueType = "position" | "dimension";
@@ -402,20 +407,13 @@ export class Scale<T extends numeric.Value = number> {
     return scale;
   }
 
+  get transform(): TransformT<T> {
+    return { scale: this.dim(1 as T), offset: this.pos(0 as T) };
+  }
+
   static readonly IDENTITY = new Scale();
 }
 
-export const xyScaleToTransform = (scale: XY): XYTransformT => ({
-  scale: {
-    x: scale.x.dim(1),
-    y: scale.y.dim(1),
-  },
-  offset: {
-    x: scale.x.pos(0),
-    y: scale.y.pos(0),
-  },
-});
-
 export class XY {
   x: Scale<number>;
   y: Scale<number>;
@@ -537,6 +535,10 @@ export class XY {
     return { x: this.x.pos(xy.x), y: this.y.pos(xy.y) };
   }
 
+  dim(xy: xy.XY): xy.XY {
+    return { x: this.x.dim(xy.x), y: this.y.dim(xy.y) };
+  }
+
   box(b: Box): Box {
     return box.construct(
       this.pos(b.one),
@@ -547,5 +549,12 @@ export class XY {
     );
   }
 
+  get transform(): XYTransformT {
+    return {
+      scale: this.dim({ x: 1, y: 1 }),
+      offset: this.pos({ x: 0, y: 0 }),
+    };
+  }
+
   static readonly IDENTITY = new XY();
 }

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

@@ -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, it,test } from "vitest";
+import { describe, expect, it, test } from "vitest";
 
 import * as xy from "@/spatial/xy/xy";
 
@@ -122,4 +122,25 @@ describe("XY", () => {
       expect(xy.scale([1, 2], 2)).toEqual({ x: 2, y: 4 });
     });
   });
+  describe("sub", () => {
+    it("should subtract the second point from the first point", () => {
+      expect(xy.sub([1, 2], [2, 1])).toEqual({ x: -1, y: 1 });
+    });
+  });
+
+  describe("calculateMiters", () => {
+    it("should calculate the miters of the given points", () => {
+      const points: xy.XY[] = [
+        { x: 0, y: 0 },
+        { x: 0, y: 1 },
+        { x: 1, y: 1 },
+      ];
+      const miters = xy.calculateMiters(points, 1);
+      expect(miters).toEqual([
+        { x: -1, y: 0 },
+        { x: -1, y: 1 },
+        { x: -0, y: 1 },
+      ]);
+    });
+  });
 });

package/src/spatial/xy/xy.ts

@@ -21,7 +21,7 @@ import {
   xy,
 } from "@/spatial/base";
 
-export { type ClientXY as Client, clientXY, type XY,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([
@@ -143,10 +143,10 @@ export const distance = (ca: Crude, cb: Crude): number => {
  * @returns the translation that would need to be applied to move the first coordinate
  * to the second coordinate.
  */
-export const translation = (ca: Crude, cb: Crude): XY => {
-  const a = construct(ca);
-  const b = construct(cb);
-  return { x: b.x - a.x, y: b.y - a.y };
+export const translation = (to: Crude, from: Crude): XY => {
+  const to_ = construct(to);
+  const from_ = construct(from);
+  return { x: from_.x - to_.x, y: from_.y - to_.y };
 };
 
 /** @returns true if both the x and y coordinates of the given coordinate are NaN. */
@@ -183,3 +183,99 @@ 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)) };
 };
+
+/**
+ * Subtracts the second coordinate from the first coordinate.
+ * @param a - The first coordinate.
+ * @param b - The second coordinate.
+ * @returns The difference between the two coordinates.
+ */
+export const sub = (a: Crude, b: Crude): XY => {
+  const xy = construct(a);
+  const xy_ = construct(b);
+  return { x: xy.x - xy_.x, y: xy.y - xy_.y };
+};
+
+/**
+ * Interprets the given coordinates as a vector and returns the normal of the given
+ * vector.
+ * @param a - The coordinates to get the normal of.
+ * @returns The normal of the given coordinates.
+ */
+export const normal = (a: Crude): XY => {
+  const xy = construct(a);
+  const length = Math.hypot(xy.x, xy.y);
+  if (length === 0) return { x: 0, y: 0 };
+  return { x: -xy.y / length, y: xy.x / length };
+};
+
+/**
+ * Interprets the given coordinates as a vector and returns the unit vector of the given
+ * vector.
+ * @param a - The coordinates to get the unit vector of.
+ * @returns The unit vector of the given coordinates.
+ */
+export const normalize = (a: Crude): XY => {
+  const xy = construct(a);
+  const length = Math.hypot(xy.x, xy.y);
+  if (length === 0) return { x: 0, y: 0 };
+  return { x: xy.x / length, y: xy.y / length };
+};
+
+/**
+ * @returns the average of the given coordinates.
+ * @param coordinates - The coordinates to average.
+ */
+export const average = (...coordinates: Crude[]): XY => {
+  const sum = coordinates.reduce((p, c) => translate(p, c), ZERO);
+  return scale(sum, 1 / coordinates.length);
+};
+
+/**
+ * Calculates the miter vectors for the given path and offset. This function is useful
+ * for calculate the translations need to create an offset and parallel path to the
+ * given path.
+ * @param path - The path to calculate the miters for.
+ * @param offset - The magnitude of the miter vectors.
+ * @returns The miter vectors for the given path.
+ */
+export const calculateMiters = (path: XY[], offset: number): XY[] => {
+  const miters: XY[] = [];
+  for (let i = 0; i < path.length; i++) {
+    const currPoint = path[i];
+    let normalPrev: XY;
+    let normalNext: XY;
+    let miterNormal: XY;
+    let miterLength: number;
+    if (i === 0) {
+      const nextPoint = path[i + 1];
+      const dirNext = sub(nextPoint, currPoint);
+      normalNext = normal(dirNext);
+      miterNormal = normalNext;
+      miterLength = offset;
+    } else if (i === path.length - 1) {
+      const prevPoint = path[i - 1];
+      const dirPrev = sub(currPoint, prevPoint);
+      normalPrev = normal(dirPrev);
+      miterNormal = normalPrev;
+      miterLength = offset;
+    } else {
+      const prevPoint = path[i - 1];
+      const nextPoint = path[i + 1];
+      const dirPrev = sub(currPoint, prevPoint);
+      const dirNext = sub(nextPoint, currPoint);
+      normalPrev = normal(dirPrev);
+      normalNext = normal(dirNext);
+      const angle = Math.acos(
+        (dirPrev.x * dirNext.x + dirPrev.y * dirNext.y) /
+          (Math.hypot(dirPrev.x, dirPrev.y) * Math.hypot(dirNext.x, dirNext.y)),
+      );
+      const sinHalfAngle = Math.sin(angle / 2);
+      if (sinHalfAngle === 0) miterLength = offset;
+      else miterLength = offset / sinHalfAngle;
+      miterNormal = normalize(average(normalPrev, normalNext));
+    }
+    miters.push(scale(miterNormal, miterLength));
+  }
+  return miters;
+};

package/src/strings/strings.spec.ts

@@ -62,7 +62,3 @@ describe("generateShortIdentifiers", () => {
       expect.arrayContaining(["ab", "a_b", "alibob", "ali_bob"]),
     ));
 });
-
-console.log(generateShortIdentifiers("John Doe")); // ["jd", "j_d", "johdoe", "joh_doe"]
-console.log(generateShortIdentifiers("Alice 123")); // ["a1", "a_1", "ali123", "ali_123"]
-console.log(generateShortIdentifiers("Bob")); // ["bob"]

package/src/telem/gl.ts

@@ -11,9 +11,13 @@ import { z } from "zod";
 
 export interface GLBufferController {
   createBuffer: () => WebGLBuffer | null;
-  bufferData: ((target: number, data: ArrayBufferLike, usage: number) => void) &
+  bufferData: ((target: number, data: AllowSharedBufferSource, usage: number) => void) &
     ((target: number, size: number, usage: number) => void);
-  bufferSubData: (target: number, offset: number, data: ArrayBufferLike) => void;
+  bufferSubData: (
+    target: number,
+    offset: number,
+    data: AllowSharedBufferSource,
+  ) => void;
   bindBuffer: (target: number, buffer: WebGLBuffer | null) => void;
   deleteBuffer: (buffer: WebGLBuffer | null) => void;
   ARRAY_BUFFER: number;

package/src/telem/series.spec.ts

@@ -435,7 +435,7 @@ describe("Series", () => {
       const buf = controller.buffers[series.glBuffer as number];
       expect(buf).toBeDefined();
       expect(buf.byteLength).toEqual(12);
-      expect(buf).toEqual(new Float32Array([1, 2, 3]));
+      expect(buf).toEqual(new Float32Array([1, 2, 3]).buffer);
     });
     it("should correctly update a buffer when writing to an allocated array", () => {
       const series = Series.alloc({ capacity: 10, dataType: DataType.FLOAT32 });
@@ -694,7 +694,8 @@ describe("Series", () => {
         data: new Float32Array([1, 2, 3]),
         timeRange: new TimeRange(1, 3),
       }).digest;
-      expect(digest.alignment).toEqual({ lower: 0n, upper: 3n });
+      expect(digest.alignment.lower).toEqual({ domain: 0n, sample: 0n });
+      expect(digest.alignment.upper).toEqual({ domain: 0n, sample: 3n });
       expect(digest.dataType).toEqual("float32");
       expect(digest.length).toEqual(3);
       expect(digest.timeRange).toEqual(new TimeRange(1, 3).toString());
@@ -885,7 +886,6 @@ describe("MultiSeries", () => {
         data: new Float32Array([6, 7, 8, 9, 10]),
         alignment: 8n,
       });
-      console.log(a.alignmentBounds.upper);
       const multi = new MultiSeries([a, b]);
       const iter = multi.subAlignmentIterator(7n, 10n);
       expect(iter.next().value).toEqual(6);