@synnaxlabs/x 0.10.0 → 0.12.0

package/.turbo/turbo-build.log

@@ -1,6 +1,6 @@
 
-> @synnaxlabs/x@0.10.0 build /home/runner/work/synnax/synnax/x/ts
-> vite build
+> @synnaxlabs/x@0.12.0 build /home/runner/work/synnax/synnax/x/ts
+> tsc --noEmit && vite build
 
 vite v5.1.2 building for production...
 transforming...
@@ -10,8 +10,8 @@ rendering chunks...
 
 [vite:dts] Start generate declaration files...
 computing gzip size...
-dist/x.es.js  288.78 kB │ gzip: 54.42 kB │ map: 594.40 kB
-[vite:dts] Declaration files built in 2871ms.
+dist/x.es.js  289.91 kB │ gzip: 54.74 kB │ map: 595.98 kB
+[vite:dts] Declaration files built in 2784ms.
 
-dist/x.cjs.js  289.65 kB │ gzip: 54.57 kB │ map: 594.52 kB
-✓ built in 3.78s
+dist/x.cjs.js  290.78 kB │ gzip: 54.89 kB │ map: 596.09 kB
+✓ built in 3.63s

package/dist/case.d.ts

@@ -1,5 +1,5 @@
 export declare namespace Case {
-    const toSnake: <T>(entity: T) => Record<string, T[keyof T]>;
-    const toCamel: <T extends Partial<Record<keyof T, unknown>>>(entity: T) => Record<string, T[keyof T]>;
+    const toSnake: <T>(entity: T) => T;
+    const toCamel: <T>(entity: T) => T;
     const capitalize: (str: string) => string;
 }

package/dist/deep/copy.d.ts

@@ -1 +1 @@
-export declare const copy: <T extends Partial<Record<keyof T, unknown>>>(obj: T) => T;
+export declare const copy: <T>(obj: T) => T;

package/dist/deep/delete.d.ts

@@ -1,2 +1,2 @@
 import { type Key } from './path';
-export declare const deleteD: <T extends Partial<Record<keyof T, unknown>>, D extends number = 5>(target: T, ...keys: Key<T, D>[]) => T;
+export declare const deleteD: <T extends unknown, D extends number = 5>(target: T, ...keys: Key<T, D>[]) => T;

package/dist/deep/equal.d.ts

@@ -1,8 +1,2 @@
-import { type UnknownRecord } from '../record';
-import { Primitive } from '../primitive';
-type DeepEqualBaseRecord = UnknownRecord | {
-    equals?: (other: any) => boolean;
-};
-export declare const equal: <T extends DeepEqualBaseRecord | DeepEqualBaseRecord[] | Primitive[]>(a: T, b: T) => boolean;
-export declare const partialEqual: <T extends Partial<Record<keyof T, unknown>>>(base: T, partial: Partial<T>) => boolean;
-export {};
+export declare const equal: <T extends unknown>(a: T, b: T) => boolean;
+export declare const partialEqual: <T extends unknown>(base: T, partial: Partial<T>) => boolean;

package/dist/deep/merge.d.ts

@@ -1,2 +1,2 @@
 import { type Partial } from './partial';
-export declare const merge: <T extends globalThis.Partial<Record<keyof T, unknown>>>(base: T, ...objects: Partial<T>[]) => T;
+export declare const merge: <T>(base: T, ...objects: Partial<T>[]) => T;

package/dist/deep/path.d.ts

@@ -1,5 +1,4 @@
 import { type Join } from '../join';
-import { UnknownRecord } from "..";
 type Prev = [
     never,
     0,
@@ -28,10 +27,10 @@ type Prev = [
 export type Key<T, D extends number = 5> = [D] extends [never] ? never : T extends object ? {
     [K in keyof T]-?: K extends string | number ? `${K}` | Join<K, Key<T[K], Prev[D]>> : never;
 }[keyof T] : "";
-export type Get<V extends UnknownRecord = UnknownRecord> = ((obj: V, path: string, allowNull: true) => unknown | null) & ((obj: V, path: string, allowNull: boolean) => unknown);
+export type Get = (<T>(obj: T, path: string, allowNull: true) => unknown | null) & (<T>(obj: T, path: string, allowNull?: boolean) => unknown);
 export declare const get: Get;
-export declare const set: (obj: UnknownRecord, path: string, value: unknown) => void;
+export declare const set: <V>(obj: V, path: string, value: unknown) => void;
 export declare const element: (path: string, index: number) => string;
 export declare const join: (path: string[]) => string;
-export declare const has: (obj: UnknownRecord, path: string) => boolean;
+export declare const has: <V>(obj: V, path: string) => boolean;
 export {};

package/dist/identity.d.ts

@@ -1 +1,2 @@
-export declare const isObject: <T extends Partial<Record<import('./record').Key, unknown>> = Partial<Record<import('./record').Key, unknown>>>(item?: unknown) => item is T;
+import { type UnknownRecord } from './record';
+export declare const isObject: <T extends UnknownRecord = UnknownRecord>(item?: unknown) => item is T;

package/dist/record.d.ts

@@ -1,12 +1,11 @@
 import { z } from "zod";
-import { type RenderableValue } from './renderable';
 export type Key = string | number | symbol;
-export type KeyedRecord<K extends Key = Key, E extends Record<string, unknown> = Record<string, unknown>> = {
+export type UnknownRecord = {
+    [key: Key]: unknown;
+};
+export type Keyed<K extends Key> = {
     key: K;
-} & Partial<Record<keyof E, unknown>>;
-export type UnknownRecord<E extends Record<Key, unknown> = Record<Key, unknown>> = Partial<Record<keyof E, unknown>>;
-export type RenderableRecord<E extends Record<string, RenderableValue> = Record<string, RenderableValue>> = E;
-export type KeyedRenderableRecord<K extends Key = Key, E extends Record<string, RenderableValue> = Record<string, RenderableValue>> = KeyedRecord<K, E> & Omit<RenderableRecord<E>, "key">;
+};
 export declare const unknownRecordZ: z.ZodRecord<z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodSymbol]>, z.ZodUnknown>;
 export type Entries<T> = {
     [K in keyof T]: [K, T[K]];

package/dist/search.d.ts

@@ -1,14 +1,14 @@
 import { type CompareF } from './compare/compare';
-import { type Key, type KeyedRecord } from './record';
+import { type Key, type Keyed } from './record';
 export declare const Search: {
     binary: <T>(arr: T[], target: T, compare: CompareF<T>) => number;
 };
-export interface TermSearcher<T, K extends Key, E extends KeyedRecord<K, E>> {
+export interface TermSearcher<T, K extends Key, E extends Keyed<K>> {
     search: (term: T) => E[];
     retrieve: (keys: K[]) => E[];
     page: (offset: number, limit: number) => E[];
 }
-export interface AsyncTermSearcher<T, K extends Key, E extends KeyedRecord<K, E>> {
+export interface AsyncTermSearcher<T, K extends Key, E extends Keyed<K>> {
     search: (term: T) => Promise<E[]>;
     retrieve: (keys: K[]) => Promise<E[]>;
     page: (offset: number, limit: number) => Promise<E[]>;

package/dist/spatial/box.d.ts

@@ -236,4 +236,5 @@ export declare const isBox: (value: unknown) => value is {
     };
 };
 export declare const aspect: (b: Box) => number;
+export declare const translate: (b: Box, t: xy.XY) => Box;
 export {};

package/dist/telem/series.d.ts

@@ -23,7 +23,7 @@ export interface SeriesProps extends BaseSeriesProps {
     data: ArrayBuffer | NativeTypedArray;
 }
 export interface SeriesAllocProps extends BaseSeriesProps {
-    length: number;
+    capacity: number;
     dataType: CrudeDataType;
 }
 export interface SeriesMemInfo {
@@ -62,7 +62,7 @@ export declare class Series {
     private writePos;
     /** Tracks the number of entities currently using this array. */
     private _refCount;
-    static alloc({ length, dataType, ...props }: SeriesAllocProps): Series;
+    static alloc({ capacity: length, dataType, ...props }: SeriesAllocProps): Series;
     static generateTimestamps(length: number, rate: Rate, start: TimeStamp): Series;
     get refCount(): number;
     static fromStrings(data: string[], timeRange?: TimeRange): Series;
@@ -70,6 +70,14 @@ export declare class Series {
     constructor({ data, dataType, timeRange, sampleOffset, glBufferUsage, alignment, key, }: SeriesProps);
     acquire(gl?: GLBufferController): void;
     release(): void;
+    /**
+     * Writes the given series to this series. If the series being written exceeds the
+     * remaining of series being written to, only the portion that fits will be written.
+     * @param other the series to write to this series. The data type of the series written
+     * must be the same as the data type of the series being written to.
+     * @returns the number of samples written. If the entire series fits, this value is
+     * equal to the length of the series being written.
+     */
     write(other: Series): number;
     /** @returns the underlying buffer backing this array. */
     get buffer(): ArrayBufferLike;
@@ -81,11 +89,11 @@ export declare class Series {
     parseJSON<Z extends z.ZodTypeAny>(schema: Z): Array<z.output<Z>>;
     /** @returns the time range of this array. */
     get timeRange(): TimeRange;
-    /** @returns the capacity of the underlying buffer in bytes. */
-    get byteCap(): Size;
-    /** @returns the capacity of the underlying buffer in samples. */
-    get cap(): number;
-    /** @returns the length of the underlying buffer in samples. */
+    /** @returns the capacity of the series in bytes. */
+    get byteCapacity(): Size;
+    /** @returns the capacity of the series in samples. */
+    get capacity(): number;
+    /** @returns the length of the series in bytes. */
     get byteLength(): Size;
     /** @returns the number of samples in this array. */
     get length(): number;
@@ -110,7 +118,8 @@ export declare class Series {
     private maybeRecomputeMinMax;
     enrich(): void;
     get range(): SampleValue;
-    at(index: number): SampleValue;
+    at(index: number, required: true): SampleValue;
+    at(index: number, required?: false): SampleValue | undefined;
     /**
      * @returns the index of the first sample that is greater than or equal to the given value.
      * The underlying array must be sorted. If it is not, the behavior of this method is undefined.

package/dist/telem/telem.d.ts

@@ -200,6 +200,7 @@ export declare class TimeSpan extends Number implements Stringer {
     constructor(value: CrudeTimeSpan);
     remainder(divisor: TimeSpan): TimeSpan;
     truncate(span: TimeSpan): TimeSpan;
+    multiply(factor: number): TimeSpan;
     toString(): string;
     /** @returns the decimal number of days in the timespan */
     get days(): number;
@@ -625,8 +626,8 @@ export type DataTypeT = string;
 export type CrudeSize = Size | number | Number;
 export type SizeT = number;
 export interface CrudeTimeRange {
-    start: TimeStampT;
-    end: TimeStampT;
+    start: CrudeTimeStamp;
+    end: CrudeTimeStamp;
 }
 export declare const nativeTypedArray: z.ZodUnion<[z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>, z.ZodType<Uint16Array, z.ZodTypeDef, Uint16Array>, z.ZodType<Uint32Array, z.ZodTypeDef, Uint32Array>, z.ZodType<BigUint64Array, z.ZodTypeDef, BigUint64Array>, z.ZodType<Float32Array, z.ZodTypeDef, Float32Array>, z.ZodType<Float64Array, z.ZodTypeDef, Float64Array>, z.ZodType<Int8Array, z.ZodTypeDef, Int8Array>, z.ZodType<Int16Array, z.ZodTypeDef, Int16Array>, z.ZodType<Int32Array, z.ZodTypeDef, Int32Array>, z.ZodType<BigInt64Array, z.ZodTypeDef, BigInt64Array>]>;
 export type NativeTypedArray = z.infer<typeof nativeTypedArray>;

package/dist/x.cjs.js

@@ -4740,7 +4740,7 @@ const translateY = (c, y2) => {
   const p = construct$2(c);
   return { x: p.x, y: p.y + y2 };
 };
-const translate = (a, b, v, ...cb) => {
+const translate$1 = (a, b, v, ...cb) => {
   if (typeof b === "string" && typeof v === "number") {
     if (b === "x")
       return translateX(a, v);
@@ -4811,7 +4811,7 @@ const xy = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   isZero: isZero$1,
   scale: scale$2,
   set: set$1,
-  translate,
+  translate: translate$1,
   translateX,
   translateY,
   translation,
@@ -4950,7 +4950,7 @@ const right = (b) => loc(b, "right");
 const bottom = (b) => loc(b, "bottom");
 const left = (b) => loc(b, "left");
 const top = (b) => loc(b, "top");
-const center = (b) => translate(topLeft(b), {
+const center = (b) => translate$1(topLeft(b), {
   x: signedWidth(b) / 2,
   y: signedHeight(b) / 2
 });
@@ -4997,6 +4997,16 @@ const isBox = (value) => {
   return "one" in value && "two" in value && "root" in value;
 };
 const aspect = (b) => width(b) / height(b);
+const translate = (b, t) => {
+  const b_ = construct$1(b);
+  return construct$1(
+    translate$1(b_.one, t),
+    translate$1(b_.two, t),
+    void 0,
+    void 0,
+    b_.root
+  );
+};
 const box$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   DECIMAL: DECIMAL$1,
@@ -5032,6 +5042,7 @@ const box$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePropert
   top,
   topLeft,
   topRight,
+  translate,
   width,
   x,
   xBounds,
@@ -5709,6 +5720,9 @@ const _TimeSpan = class _TimeSpan extends Number {
   truncate(span2) {
     return new _TimeSpan(Math.trunc(this.valueOf() / span2.valueOf()) * span2.valueOf());
   }
+  multiply(factor) {
+    return new _TimeSpan(this.valueOf() * factor);
+  }
   toString() {
     const totalDays = this.truncate(_TimeSpan.DAY);
     const totalHours = this.truncate(_TimeSpan.HOUR);
@@ -6456,7 +6470,7 @@ class Series {
       bufferUsage: glBufferUsage
     };
   }
-  static alloc({ length, dataType, ...props }) {
+  static alloc({ capacity: 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);
@@ -6501,12 +6515,20 @@ class Series {
     else if (this._refCount < 0)
       throw new Error("cannot release an array with a negative reference count");
   }
+  /**
+   * Writes the given series to this series. If the series being written exceeds the 
+   * remaining of series being written to, only the portion that fits will be written. 
+   * @param other the series to write to this series. The data type of the series written
+   * must be the same as the data type of the series being written to.
+   * @returns the number of samples written. If the entire series fits, this value is
+   * equal to the length of the series being written.
+   */
   write(other) {
     if (!other.dataType.equals(this.dataType))
       throw new Error("buffer must be of the same type as this array");
     if (this.writePos === FULL_BUFFER)
       return 0;
-    const available = this.cap - this.writePos;
+    const available = this.capacity - this.writePos;
     const toWrite = available < other.length ? other.slice(0, available) : other;
     this.underlyingData.set(toWrite.data, this.writePos);
     this.maybeRecomputeMinMax(toWrite);
@@ -6553,18 +6575,18 @@ class Series {
     validateFieldNotNull("timeRange", this._timeRange);
     return this._timeRange;
   }
-  /** @returns the capacity of the underlying buffer in bytes. */
-  get byteCap() {
+  /** @returns the capacity of the series in bytes. */
+  get byteCapacity() {
     return new Size(this.buffer.byteLength);
   }
-  /** @returns the capacity of the underlying buffer in samples. */
-  get cap() {
-    return this.dataType.density.length(this.byteCap);
+  /** @returns the capacity of the series in samples. */
+  get capacity() {
+    return this.dataType.density.length(this.byteCapacity);
   }
-  /** @returns the length of the underlying buffer in samples. */
+  /** @returns the length of the series in bytes. */
   get byteLength() {
     if (this.writePos === FULL_BUFFER)
-      return this.byteCap;
+      return this.byteCapacity;
     return this.dataType.density.size(this.writePos);
   }
   /** @returns the number of samples in this array. */
@@ -6665,10 +6687,15 @@ class Series {
   get range() {
     return addSamples(this.max, -this.min);
   }
-  at(index) {
+  at(index, required) {
+    if (index < 0)
+      index = this.length + index;
     const v = this.data[index];
-    if (v == null)
+    if (v == null) {
+      if (required)
+        throw new Error(`[series] - no value at index ${index}`);
       return void 0;
+    }
     return addSamples(v, this.sampleOffset);
   }
   /**
@@ -6682,7 +6709,7 @@ class Series {
     const cf = newF(value);
     while (left2 <= right2) {
       const mid = Math.floor((left2 + right2) / 2);
-      const cmp = cf(this.at(mid), value);
+      const cmp = cf(this.at(mid, true), value);
       if (cmp === 0)
         return mid;
       if (cmp < 0)
@@ -6697,15 +6724,14 @@ 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);
     if (this.writePos !== FULL_BUFFER) {
       if (prevBuffer === 0) {
-        gl.bufferData(gl.ARRAY_BUFFER, this.byteCap.valueOf(), gl.STATIC_DRAW);
+        gl.bufferData(gl.ARRAY_BUFFER, this.byteCapacity.valueOf(), gl.STATIC_DRAW);
       }
       const byteOffset = this.dataType.density.size(prevBuffer).valueOf();
       const slice = this.underlyingData.slice(this.gl.prevBuffer, this.writePos);
@@ -6748,6 +6774,7 @@ class Series {
     gl.deleteBuffer(this.gl.buffer);
     this.gl.buffer = null;
     this.gl.prevBuffer = 0;
+    this.gl.control = null;
   }
   get glBuffer() {
     if (this.gl.buffer == null)
@@ -6857,8 +6884,10 @@ const deleteD = (target2, ...keys) => {
   });
   return target2;
 };
-const get = (obj, path, allowNull) => {
+const get = (obj, path, allowNull = false) => {
   const parts = path.split(".");
+  if (parts.length === 1 && parts[0] === "")
+    return obj;
   let result = obj;
   for (const part of parts) {
     const v = result[part];
@@ -6932,13 +6961,12 @@ const equal = (a, b) => {
     const bArr = b;
     if (aArr.length !== bArr.length)
       return false;
-    for (let i = 0; i < aArr.length; i++) {
+    for (let i = 0; i < aArr.length; i++)
       if (!equal(aArr[i], bArr[i]))
         return false;
-    }
     return true;
   }
-  if (typeof a !== "object" || typeof b !== "object")
+  if (a == null || b == null || typeof a !== "object" || typeof b !== "object")
     return a === b;
   if ("equals" in a)
     return a.equals(b);
@@ -6958,6 +6986,8 @@ const equal = (a, b) => {
   return true;
 };
 const partialEqual = (base, partial) => {
+  if (typeof base !== "object" || base == null)
+    return base === partial;
   const baseKeys = Object.keys(base);
   const partialKeys = Object.keys(partial);
   if (partialKeys.length > baseKeys.length)