@synnaxlabs/x 0.7.0 → 0.9.0

package/.turbo/turbo-build.log

@@ -1,16 +1,17 @@
 
-> @synnaxlabs/x@0.7.0 build /Users/emilianobonilla/Desktop/synnaxlabs/synnax/x/ts
+> @synnaxlabs/x@0.9.0 build /Users/emilianobonilla/Desktop/synnaxlabs/synnax/x/ts
 > vite build
 
-vite v5.0.10 building for production...
+vite v5.1.2 building for production...
 transforming...
-✓ 112 modules transformed.
+[plugin:vite:resolve] Module "crypto" has been externalized for browser compatibility, imported by "/Users/emilianobonilla/Desktop/synnaxlabs/synnax/node_modules/.pnpm/nanoid@3.0.0/node_modules/nanoid/index.js". See https://vitejs.dev/guide/troubleshooting.html#module-externalized-for-browser-compatibility for more details.
+✓ 116 modules transformed.
 rendering chunks...
 
 [vite:dts] Start generate declaration files...
 computing gzip size...
-dist/x.es.js  282.61 kB │ gzip: 52.80 kB │ map: 575.28 kB
-[vite:dts] Declaration files built in 1170ms.
+dist/x.es.js  288.78 kB │ gzip: 54.26 kB │ map: 594.40 kB
+[vite:dts] Declaration files built in 1131ms.
 
-dist/x.cjs.js  283.44 kB │ gzip: 52.94 kB │ map: 575.40 kB
-✓ built in 1.57s
+dist/x.cjs.js  289.65 kB │ gzip: 54.40 kB │ map: 594.52 kB
+✓ built in 1.54s

package/dist/binary/index.d.ts

@@ -1 +1 @@
-export * as binary from '../binary/encoder';
+export * as binary from './encoder';

package/dist/change/change.d.ts

@@ -21,12 +21,14 @@ export declare const Z: <V extends z.ZodTypeAny>(value: V) => z.ZodObject<{
     key: z.ZodString;
     value: V;
 }>[k_2]; }>;
-export type Change<K, V> = {
+export type Set<K, V> = {
     variant: "set";
     key: K;
     value: V;
-} | {
+};
+export type Delete<K, V> = {
     variant: "delete";
     key: K;
     value?: V;
 };
+export type Change<K, V> = Set<K, V> | Delete<K, V>;

package/dist/change/index.d.ts

@@ -1 +1 @@
-export * as change from '../change/change';
+export * as change from './change';

package/dist/compare/index.d.ts

@@ -1 +1 @@
-export * as compare from '../compare/compare';
+export * as compare from './compare';

package/dist/deep/delete.d.ts

@@ -1,2 +1,2 @@
-import { type Key } from '../deep/key';
+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;

package/dist/deep/external.d.ts

@@ -1,7 +1,7 @@
-export * from '../deep/copy';
-export * from '../deep/delete';
-export * from '../deep/key';
-export * from '../deep/merge';
-export * from '../deep/partial';
-export * from '../deep/equal';
-export * from '../deep/memo';
+export * from './copy';
+export * from './delete';
+export * from './path';
+export * from './merge';
+export * from './partial';
+export * from './equal';
+export * from './memo';

package/dist/deep/index.d.ts

@@ -1 +1 @@
-export * as deep from '../deep/external';
+export * as deep from './external';

package/dist/deep/merge.d.ts

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

package/dist/deep/path.d.ts

@@ -0,0 +1,37 @@
+import { type Join } from '../join';
+import { UnknownRecord } from "..";
+type Prev = [
+    never,
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9,
+    10,
+    11,
+    12,
+    13,
+    14,
+    15,
+    16,
+    17,
+    18,
+    19,
+    20,
+    ...Array<0>
+];
+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 declare const get: Get;
+export declare const set: (obj: UnknownRecord, 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 {};

package/dist/deep/path.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/destructor.d.ts

@@ -1 +1,2 @@
 export type Destructor = () => void;
+export type AsyncDestructor = () => Promise<void>;

package/dist/index.d.ts

@@ -23,3 +23,4 @@ export * from './transform';
 export * from './binary';
 export * from './observe';
 export * from './change';
+export * from './shallowCopy';

package/dist/kv/index.d.ts

@@ -1 +1 @@
-export * as kv from '../kv/types';
+export * as kv from './types';

package/dist/mock/index.d.ts

@@ -1 +1 @@
-export * from '../mock/MockGLBufferController';
+export * from './MockGLBufferController';

package/dist/observe/index.d.ts

@@ -1 +1 @@
-export * as observe from '../observe/observe';
+export * as observe from './observe';

package/dist/observe/observe.d.ts

@@ -5,7 +5,7 @@ export interface Observable<T> {
 }
 export declare class Observer<T> implements Observable<T> {
     private readonly handlers;
-    constructor();
+    constructor(handlers?: Map<Handler<T>, null>);
     onChange(handler: Handler<T>): Destructor;
     notify(value: T): void;
 }

package/dist/runtime/external.d.ts

@@ -1,2 +1,2 @@
-export * from '../runtime/detect';
-export * from '../runtime/os';
+export * from './detect';
+export * from './os';

package/dist/runtime/index.d.ts

@@ -1 +1 @@
-export * as runtime from '../runtime/external';
+export * as runtime from './external';

package/dist/shallowCopy.d.ts

@@ -0,0 +1 @@
+export declare const shallowCopy: <T extends unknown>(obj: T) => T;

package/dist/spatial/bounds.d.ts

@@ -1,4 +1,4 @@
-import { type Bounds, bounds, type CrudeBounds } from '../spatial/base';
+import { type Bounds, bounds, type CrudeBounds } from './base';
 export { type Bounds, bounds };
 export type Crude = CrudeBounds;
 export declare const construct: (lower: number | Crude, upper?: number) => Bounds;
@@ -18,14 +18,53 @@ export declare const CLIP: {
     lower: number;
     upper: number;
 };
-export declare const equals: (a?: Bounds, b?: Bounds) => boolean;
+export declare const equals: (_a?: Bounds, _b?: Bounds) => boolean;
 export declare const makeValid: (a: Bounds) => Bounds;
-export declare const clamp: (bounds: Bounds, target: number) => number;
-export declare const contains: (bounds: Bounds, target: number) => boolean;
-export declare const overlapsWith: (a: Bounds, b: Bounds) => boolean;
-export declare const span: (a: Bounds) => number;
-export declare const isZero: (a: Bounds) => boolean;
-export declare const spanIsZero: (a: Bounds) => boolean;
-export declare const isFinite: (a: Bounds) => boolean;
+export declare const clamp: (bounds: Crude, target: number) => number;
+export declare const contains: (bounds: Crude, target: number | CrudeBounds) => boolean;
+export declare const overlapsWith: (a: Crude, b: Crude) => boolean;
+export declare const span: (a: Crude) => number;
+export declare const isZero: (a: Crude) => boolean;
+export declare const spanIsZero: (a: Crude) => boolean;
+export declare const isFinite: (a: Crude) => boolean;
 export declare const max: (bounds: Crude[]) => Bounds;
 export declare const min: (bounds: Crude[]) => Bounds;
+export declare const constructArray: (bounds: Crude) => number[];
+export declare const findInsertPosition: (bounds: Crude[], target: number) => {
+    index: number;
+    position: number;
+};
+/**
+ * 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;
+}
+/**
+ * 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 declare const buildInsertionPlan: (bounds: Crude[], value: Crude) => InsertionPlan | null;
+export declare const insert: (bounds: Crude[], value: Crude) => Crude[];

package/dist/spatial/box.d.ts

@@ -1,9 +1,9 @@
 import { z } from "zod";
-import type * as bounds from '../spatial/bounds';
-import type * as dimensions from '../spatial/dimensions';
-import * as direction from '../spatial/direction';
-import * as location from '../spatial/location';
-import * as xy from '../spatial/xy';
+import type * as bounds from './bounds';
+import type * as dimensions from './dimensions';
+import * as direction from './direction';
+import * as location from './location';
+import * as xy from './xy';
 declare const cssBox: z.ZodObject<{
     top: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
     left: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
@@ -103,29 +103,11 @@ type Crude = DOMRect | Box | {
 /** A box centered at (0,0) with a width and height of 0. */
 export declare const ZERO: {
     one: {
-        x: number; /**
-         * Box represents a general box in 2D space. It typically represents a bounding box
-         * for a DOM element, but can also represent a box in clip space or decimal space.
-         *
-         * It'simportant to note that the behavior of a Box varies depending on its coordinate
-         * system.Make sure you're aware of which coordinate system you're using.
-         *
-         * Many of the properties and methods on a Box access the same semantic value. The
-         * different accessors are there for ease of use and semantics.
-         */
+        x: number;
         y: number;
     };
     two: {
-        x: number; /**
-         * Box represents a general box in 2D space. It typically represents a bounding box
-         * for a DOM element, but can also represent a box in clip space or decimal space.
-         *
-         * It'simportant to note that the behavior of a Box varies depending on its coordinate
-         * system.Make sure you're aware of which coordinate system you're using.
-         *
-         * Many of the properties and methods on a Box access the same semantic value. The
-         * different accessors are there for ease of use and semantics.
-         */
+        x: number;
         y: number;
     };
     root: {
@@ -139,16 +121,7 @@ export declare const ZERO: {
  */
 export declare const DECIMAL: {
     one: {
-        x: number; /**
-         * Box represents a general box in 2D space. It typically represents a bounding box
-         * for a DOM element, but can also represent a box in clip space or decimal space.
-         *
-         * It'simportant to note that the behavior of a Box varies depending on its coordinate
-         * system.Make sure you're aware of which coordinate system you're using.
-         *
-         * Many of the properties and methods on a Box access the same semantic value. The
-         * different accessors are there for ease of use and semantics.
-         */
+        x: number;
         y: number;
     };
     two: {
@@ -174,6 +147,7 @@ export declare const copy: (b: Box, root?: location.CornerXY) => Box;
 export declare const construct: (first: number | DOMRect | xy.XY | Box | {
     getBoundingClientRect: () => DOMRect;
 }, second?: number | xy.XY | dimensions.Dimensions | dimensions.Signed, width?: number, height?: number, coordinateRoot?: location.CornerXY) => Box;
+export declare const resize: (b: Box, dims: dimensions.Dimensions) => Box;
 /**
  * Checks if a box contains a point or another box.
  *

package/dist/spatial/dimensions.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { dimensions, type Dimensions } from '../spatial/base';
+import { dimensions, type Dimensions } from './base';
 export { dimensions, type Dimensions };
 export declare const signed: z.ZodObject<{
     signedWidth: z.ZodNumber;

package/dist/spatial/direction.d.ts

@@ -1,4 +1,4 @@
-import { type Dimension, type Direction, type Location, type direction, type SignedDimension, type CrudeDirection } from '../spatial/base';
+import { type Dimension, type Direction, type Location, type direction, type SignedDimension, type CrudeDirection } from './base';
 export type { Direction, direction };
 export declare const crude: import("zod").ZodUnion<[import("zod").ZodEnum<["x", "y"]>, import("zod").ZodEnum<["top", "right", "bottom", "left", "center"]>]>;
 export type Crude = CrudeDirection;

package/dist/spatial/external.d.ts

@@ -1,8 +1,8 @@
-export * as bounds from '../spatial/bounds';
-export * as box from '../spatial/box';
-export * as dimensions from '../spatial/dimensions';
-export * as direction from '../spatial/direction';
-export * as location from '../spatial/location';
-export * as xy from '../spatial/xy';
-export * as scale from '../spatial/scale';
-export * as spatial from '../spatial/spatial';
+export * as bounds from './bounds';
+export * as box from './box';
+export * as dimensions from './dimensions';
+export * as direction from './direction';
+export * as location from './location';
+export * as xy from './xy';
+export * as scale from './scale';
+export * as spatial from './spatial';

package/dist/spatial/index.d.ts

@@ -1 +1 @@
-export * from '../spatial/external';
+export * from './external';

package/dist/spatial/location.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { location, type Location, X_LOCATIONS, Y_LOCATIONS, CENTER_LOCATIONS, type XLocation, type OuterLocation, type YLocation, outerLocation, type Direction, type CrudeLocation } from '../spatial/base';
+import { location, type Location, X_LOCATIONS, Y_LOCATIONS, CENTER_LOCATIONS, type XLocation, type OuterLocation, type YLocation, outerLocation, type Direction, type CrudeLocation } from './base';
 export { location, type Location, X_LOCATIONS, Y_LOCATIONS, CENTER_LOCATIONS, outerLocation as outer, };
 export declare const x: z.ZodEnum<["left", "right"]>;
 export declare const y: z.ZodEnum<["top", "bottom"]>;

package/dist/spatial/position.d.ts

@@ -1,2 +1,2 @@
-import * as xy from '../spatial/xy';
+import * as xy from './xy';
 export declare const posititonSoVisible: (target: HTMLElement, p: xy.XY) => [xy.XY, boolean];

package/dist/spatial/scale.d.ts

@@ -1,9 +1,9 @@
 import { z } from "zod";
-import * as bounds from '../spatial/bounds';
-import { type Box } from '../spatial/box';
-import type * as dims from '../spatial/dimensions';
-import * as location from '../spatial/location';
-import * as xy from '../spatial/xy';
+import * as bounds from './bounds';
+import { type Box } from './box';
+import type * as dims from './dimensions';
+import * as location from './location';
+import * as xy from './xy';
 export declare const crudeXYTransform: z.ZodObject<{
     offset: z.ZodUnion<[z.ZodNumber, z.ZodObject<{
         x: z.ZodNumber;

package/dist/spatial/spatial.d.ts

@@ -1 +1 @@
-export { ALIGNMENTS, alignment, type Alignment, ORDERS, order, type Order, } from '../spatial/base';
+export { ALIGNMENTS, alignment, type Alignment, ORDERS, order, type Order, } from './base';

package/dist/spatial/xy.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { clientXY, xy, type ClientXY, type XY, type Direction } from '../spatial/base';
+import { clientXY, xy, type ClientXY, type XY, type Direction } from './base';
 export { clientXY, xy, type ClientXY as Client, type XY };
 /** A crude representation of a {@link XY} coordinate as a zod schema. */
 export declare const crudeZ: z.ZodUnion<[z.ZodNumber, z.ZodObject<{
@@ -44,7 +44,8 @@ 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.
  */
@@ -107,6 +108,8 @@ export declare const yDistance: (ca: Crude, cb: Crude) => number;
 export declare const translation: (ca: Crude, cb: Crude) => XY;
 /** @returns true if both the x and y coordinates of the given coordinate are NaN. */
 export declare const isNan: (a: Crude) => boolean;
+/** @returns true if both the x and y coordinates of the given coordinate are finite. */
+export declare const isFinite: (a: Crude) => boolean;
 /** @returns the coordinate represented as a couple of the form [x, y]. */
 export declare const couple: (a: Crude) => [number, number];
 /** @returns the coordinate represented as css properties in the form { left, top }. */

package/dist/telem/generate.d.ts

@@ -1,2 +1,2 @@
-import { DataTypeT, NativeTypedArray } from '../telem/telem';
+import { DataTypeT, NativeTypedArray } from './telem';
 export declare const randomSeries: (length: number, dataType: DataTypeT) => NativeTypedArray;

package/dist/telem/index.d.ts

@@ -1,3 +1,3 @@
-export * from '../telem/series';
-export * from '../telem/telem';
-export type { GLBufferController } from '../telem/gl';
+export * from './series';
+export * from './telem';
+export type { GLBufferController } from './gl';

package/dist/telem/series.d.ts

@@ -1,20 +1,43 @@
 import { type z } from "zod";
 import { bounds } from '../spatial';
-import { type GLBufferController, type GLBufferUsage } from '../telem/gl';
-import { DataType, type NativeTypedArray, type Rate, Size, TimeRange, type TimeStamp, type CrudeDataType } from '../telem/telem';
+import { type GLBufferController, type GLBufferUsage } from './gl';
+import { DataType, type NativeTypedArray, type Rate, Size, TimeRange, type TimeStamp, type CrudeDataType } from './telem';
 export type SampleValue = number | bigint;
 export interface SeriesDigest {
+    key: string;
     dataType: string;
     sampleOffset: SampleValue;
-    alignment: number;
+    alignment: bounds.Bounds;
     timeRange?: string;
     length: number;
 }
+interface BaseSeriesProps {
+    dataType?: CrudeDataType;
+    timeRange?: TimeRange;
+    sampleOffset?: SampleValue;
+    glBufferUsage?: GLBufferUsage;
+    alignment?: number;
+    key?: string;
+}
+export interface SeriesProps extends BaseSeriesProps {
+    data: ArrayBuffer | NativeTypedArray;
+}
+export interface SeriesAllocProps extends BaseSeriesProps {
+    length: number;
+    dataType: CrudeDataType;
+}
+export interface SeriesMemInfo {
+    key: string;
+    length: number;
+    byteLength: Size;
+    glBuffer: boolean;
+}
 /**
  * Series is a strongly typed array of telemetry samples backed by an underlying binary
  * buffer.
  */
 export declare class Series {
+    key: string;
     /** The data type of the array */
     readonly dataType: DataType;
     /**
@@ -39,12 +62,12 @@ export declare class Series {
     private writePos;
     /** Tracks the number of entities currently using this array. */
     private _refCount;
-    static alloc(length: number, dataType: CrudeDataType, timeRange?: TimeRange, sampleOffset?: SampleValue, glBufferUsage?: GLBufferUsage, alignment?: number): Series;
+    static alloc({ length, dataType, ...props }: SeriesAllocProps): Series;
     static generateTimestamps(length: number, rate: Rate, start: TimeStamp): Series;
     get refCount(): number;
     static fromStrings(data: string[], timeRange?: TimeRange): Series;
     static fromJSON<T>(data: T[], timeRange?: TimeRange): Series;
-    constructor(data: ArrayBuffer | NativeTypedArray, dataType?: CrudeDataType, timeRange?: TimeRange, sampleOffset?: SampleValue, glBufferUsage?: GLBufferUsage, alignment?: number);
+    constructor({ data, dataType, timeRange, sampleOffset, glBufferUsage, alignment, key, }: SeriesProps);
     acquire(gl?: GLBufferController): void;
     release(): void;
     write(other: Series): number;
@@ -96,9 +119,12 @@ export declare class Series {
     binarySearch(value: SampleValue): number;
     updateGLBuffer(gl: GLBufferController): void;
     get digest(): SeriesDigest;
+    get memInfo(): SeriesMemInfo;
+    get alignmentBounds(): bounds.Bounds;
     private maybeGarbageCollectGLBuffer;
     get glBuffer(): WebGLBuffer;
     slice(start: number, end?: number): Series;
     reAlign(alignment: number): Series;
 }
 export declare const addSamples: (a: SampleValue, b: SampleValue) => SampleValue;
+export {};

package/dist/telem/telem.d.ts

@@ -467,6 +467,7 @@ export declare class TimeRange implements Stringer {
     overlapsWith(other: TimeRange): boolean;
     contains(other: TimeRange): boolean;
     contains(ts: CrudeTimeStamp): boolean;
+    boundBy(other: TimeRange): TimeRange;
     /** The maximum possible time range. */
     static readonly MAX: TimeRange;
     /** The minimum possible time range. */
@@ -543,6 +544,8 @@ export declare class DataType extends String implements Stringer {
     static readonly ARRAY_CONSTRUCTORS: Map<string, NativeTypedArrayConstructor>;
     static readonly ARRAY_CONSTRUCTOR_DATA_TYPES: Map<string, DataType>;
     static readonly DENSITIES: Map<string, Density>;
+    /** All the data types. */
+    static readonly ALL: DataType[];
     static readonly BIG_INT_TYPES: DataType[];
     /** A zod schema for a DataType. */
     static readonly z: z.ZodUnion<[z.ZodEffects<z.ZodString, DataType, string>, z.ZodType<DataType, z.ZodTypeDef, DataType>]>;

package/dist/toArray.d.ts

@@ -1 +1,2 @@
 export declare const toArray: <T>(value: T | T[]) => T[];
+export declare const nullToArr: <T>(value: T | T[] | null) => T[];