@synnaxlabs/x 0.7.0 → 0.8.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@synnaxlabs/x",
   "private": false,
-  "version": "0.7.0",
+  "version": "0.8.0",
   "type": "module",
   "description": "Common Utilities for Synnax Labs",
   "repository": "https://github.com/synnaxlabs/synnax/tree/main/x/go",

package/src/deep/external.ts

@@ -13,3 +13,4 @@ export * from "@/deep/key";
 export * from "@/deep/merge";
 export * from "@/deep/partial";
 export * from "@/deep/equal";
+export * from "@/deep/memo";

package/src/deep/memo.ts

@@ -0,0 +1,15 @@
+import { equal } from "@/deep/equal"
+
+
+export const memo = <F extends (...args: any[]) => any>(func: F): F => {
+    let prevArgs: Parameters<F> = undefined as any
+    let prevResult: ReturnType<F> = undefined as any
+    const v = ((...args: Parameters<F>) => {
+        if (equal(prevArgs, args)) return prevResult
+        const result = func(...args)
+        prevArgs = args
+        prevResult = result
+        return result
+    })
+    return v as F;
+}

package/src/spatial/box.ts

@@ -184,6 +184,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,
@@ -42,7 +43,7 @@ export type Crude = z.infer<typeof crudeZ>;
  * @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 => {
   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 };
@@ -63,11 +64,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 +96,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.

package/src/telem/series.ts

@@ -7,8 +7,9 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { type z } from "zod";
+import { date, type z } from "zod";
 
+import { compare } from "@/compare";
 import { bounds } from "@/spatial";
 import { type GLBufferController, type GLBufferUsage } from "@/telem/gl";
 import {
@@ -21,7 +22,6 @@ import {
   type TimeStamp,
   type CrudeDataType,
 } from "@/telem/telem";
-import { compare } from "@/compare";
 
 export type SampleValue = number | bigint;
 
@@ -204,6 +204,22 @@ export class Series {
     return new TextDecoder().decode(this.buffer).split("\n").slice(0, -1);
   }
 
+  toUUIDs(): string[] {
+    if (!this.dataType.equals(DataType.UUID))
+      throw new Error("cannot convert non-uuid series to uuids");
+    const den = DataType.UUID.density.valueOf();
+    const r = Array(this.length);
+
+    for (let i = 0; i < this.length; i++) {
+      const v = this.buffer.slice(i * den, (i + 1) * den);
+      const id = Array.from(new Uint8Array(v), (b) => b.toString(16).padStart(2, "0"))
+        .join("")
+        .replace(/(.{8})(.{4})(.{4})(.{4})(.{12})/, "$1-$2-$3-$4-$5");
+      r[i] = id;
+    }
+    return r;
+  }
+
   parseJSON<Z extends z.ZodTypeAny>(schema: Z): Array<z.output<Z>> {
     if (!this.dataType.equals(DataType.JSON))
       throw new Error("cannot convert non-string series to strings");
@@ -217,7 +233,7 @@ export class Series {
   /** @returns the time range of this array. */
   get timeRange(): TimeRange {
     validateFieldNotNull("timeRange", this._timeRange);
-    return this._timeRange as TimeRange;
+    return this._timeRange!;
   }
 
   /** @returns the capacity of the underlying buffer in bytes. */

package/src/telem/telem.ts

@@ -328,6 +328,11 @@ export class TimeStamp extends Number implements Stringer {
     return remainder(this, divisor);
   }
 
+  /** @returns true if the day portion TimeStamp is today, false otherwise. */
+  get isToday(): boolean {
+    return this.truncate(TimeSpan.DAY).equals(TimeStamp.now().truncate(TimeSpan.DAY));
+  }
+
   truncate(span: TimeSpan | TimeStamp): TimeStamp {
     return this.sub(this.remainder(span));
   }