@synnaxlabs/x 0.13.0 → 0.14.2

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @synnaxlabs/x@0.13.0 build /home/runner/work/synnax/synnax/x/ts
+> @synnaxlabs/x@0.14.2 build /home/runner/work/synnax/synnax/x/ts
 > tsc --noEmit && vite build
 
 vite v5.1.2 building for production...
@@ -10,8 +10,8 @@ rendering chunks...
 
 [vite:dts] Start generate declaration files...
 computing gzip size...
-dist/x.js  299.72 kB │ gzip: 56.93 kB │ map: 617.77 kB
-[vite:dts] Declaration files built in 2906ms.
+dist/x.js  213.15 kB │ gzip: 49.72 kB │ map: 639.91 kB
+[vite:dts] Declaration files built in 3061ms.
 
-dist/x.cjs  300.61 kB │ gzip: 57.08 kB │ map: 617.89 kB
-✓ built in 3.78s
+dist/x.cjs  140.09 kB │ gzip: 39.81 kB │ map: 619.46 kB
+✓ built in 3.99s

package/dist/binary/encoder.d.ts

@@ -1,19 +1,4 @@
 import { type ZodSchema, type z } from "zod";
-/**
- * CustomTypeEncoder is an interface for a class that needs to transform its
- * value before encoding.
- */
-interface CustomTypeEncoder {
-    /** The Class the custom encoder is set for */
-    Class: Function;
-    /**
-     * The function that transforms the value before encoding;
-     *
-     * @param instance - The instance of the class to transform.
-     * @returns The transformed value.
-     */
-    write: <P>(instance: P) => unknown;
-}
 /**
  * EncoderDecoder is an entity that encodes and decodes messages to and from a
  * binary format.
@@ -36,24 +21,19 @@ export interface EncoderDecoder {
      */
     decode: <P>(data: Uint8Array | ArrayBuffer, schema?: ZodSchema<P>) => P;
 }
-interface StaticEncoderDecoder {
-    registerCustomType: (encoder: CustomTypeEncoder) => void;
-}
 /** MsgpackEncoderDecoder is a msgpack implementation of EncoderDecoder. */
 export declare class MsgpackEncoderDecoder implements EncoderDecoder {
     contentType: string;
     encode(payload: unknown): ArrayBuffer;
     decode<P extends z.ZodTypeAny>(data: Uint8Array | ArrayBuffer, schema?: P): z.output<P>;
-    static registerCustomType(encoder: CustomTypeEncoder): void;
 }
 /** JSONEncoderDecoder is a JSON implementation of EncoderDecoder. */
 export declare class JSONEncoderDecoder implements EncoderDecoder {
     contentType: string;
+    readonly decoder: TextDecoder;
+    constructor();
     encode(payload: unknown): ArrayBuffer;
     decode<P extends z.ZodTypeAny>(data: Uint8Array | ArrayBuffer, schema?: P): z.output<P>;
     static registerCustomType(): void;
 }
 export declare const ENCODERS: EncoderDecoder[];
-export declare const ENCODER_CLASSES: StaticEncoderDecoder[];
-export declare const registerCustomTypeEncoder: (encoder: CustomTypeEncoder) => void;
-export {};

package/dist/telem/generate.d.ts

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

package/dist/telem/series.d.ts

@@ -1,7 +1,7 @@
 import { type z } from "zod";
 import { bounds } from '../spatial';
 import { type GLBufferController, type GLBufferUsage } from './gl';
-import { DataType, type NativeTypedArray, type Rate, Size, TimeRange, type TimeStamp, type CrudeDataType } from './telem';
+import { DataType, type TypedArray, type Rate, Size, TimeRange, TimeStamp, type CrudeDataType, type TelemValue } from './telem';
 export type SampleValue = number | bigint;
 export interface SeriesDigest {
     key: string;
@@ -20,8 +20,10 @@ interface BaseSeriesProps {
     alignment?: number;
     key?: string;
 }
+export type CrudeSeries = Series | ArrayBuffer | TypedArray | string[] | number[] | boolean[] | unknown[] | TimeStamp[] | Date[] | TelemValue;
+export declare const isCrudeSeries: (value: unknown) => value is CrudeSeries;
 export interface SeriesProps extends BaseSeriesProps {
-    data: ArrayBuffer | NativeTypedArray;
+    data: CrudeSeries;
 }
 export interface SeriesAllocProps extends BaseSeriesProps {
     capacity: number;
@@ -56,19 +58,20 @@ export declare class Series {
     readonly _timeRange?: TimeRange;
     readonly alignment: number;
     /** A cached minimum value. */
-    private _min?;
+    private _cachedMin?;
     /** A cached maximum value. */
-    private _max?;
+    private _cachedMax?;
     /** The write position of the buffer. */
     private writePos;
     /** Tracks the number of entities currently using this array. */
     private _refCount;
+    private _cachedLength?;
+    constructor(props: SeriesProps | CrudeSeries);
     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;
     static fromJSON<T>(data: T[], timeRange?: TimeRange): Series;
-    constructor({ data, dataType, timeRange, sampleOffset, glBufferUsage, alignment, key, }: SeriesProps);
     acquire(gl?: GLBufferController): void;
     release(): void;
     /**
@@ -84,7 +87,7 @@ export declare class Series {
     get buffer(): ArrayBufferLike;
     private get underlyingData();
     /** @returns a native typed array with the proper data type. */
-    get data(): NativeTypedArray;
+    get data(): TypedArray;
     toStrings(): string[];
     toUUIDs(): string[];
     parseJSON<Z extends z.ZodTypeAny>(schema: Z): Array<z.output<Z>>;
@@ -98,6 +101,7 @@ export declare class Series {
     get byteLength(): Size;
     /** @returns the number of samples in this array. */
     get length(): number;
+    private calculateCachedLength;
     /**
      * Creates a new array with a different data type.
      * @param target the data type to convert to.

package/dist/telem/telem.d.ts

@@ -16,7 +16,7 @@ export type DateComponents = [number?, number?, number?];
  * 1. A number representing the number of milliseconds since the Unix epoch.
  * 2. A javascript Date object.
  * 3. An array of numbers satisfying the DateComponents type, where the first element is the
- *   year, the second is the month, and the third is the day. To increaase resolution
+ *   year, the second is the month, and the third is the day. To incraase resolution
  *   when using this method, use the add method. It's important to note that this initializes
  *   a timestamp at midnight UTC, regardless of the timezone specified.
  * 4. An ISO compliant date or date time string. The time zone component is ignored.
@@ -29,9 +29,13 @@ export type DateComponents = [number?, number?, number?];
  * @example ts = new TimeStamp([2021, 1, 1]).add(1 * TimeSpan.HOUR) // 1/1/2021 at 1am UTC
  * @example ts = new TimeStamp("2021-01-01T12:30:00Z") // 1/1/2021 at 12:30pm UTC
  */
-export declare class TimeStamp extends Number implements Stringer {
+export declare class TimeStamp implements Stringer {
+    private readonly value;
+    readonly encodeValue: true;
     constructor(value?: CrudeTimeStamp, tzInfo?: TZInfo);
     private static parseDate;
+    encode(): string;
+    valueOf(): bigint;
     private static parseTimeString;
     private static parseDateTimeString;
     fString(format?: TimeStampStringFormat, tzInfo?: TZInfo): string;
@@ -153,13 +157,14 @@ export declare class TimeStamp extends Number implements Stringer {
     /** @returns true if the day portion TimeStamp is today, false otherwise. */
     get isToday(): boolean;
     truncate(span: TimeSpan | TimeStamp): TimeStamp;
-    get bigInt(): bigint;
     /**
      * @returns A new TimeStamp representing the current time in UTC. It's important to
      * note that this TimeStamp is only accurate to the millisecond level (that's the best
      * JavaScript can do).
      */
     static now(): TimeStamp;
+    static max(...timestamps: CrudeTimeStamp[]): TimeStamp;
+    static min(...timestamps: CrudeTimeStamp[]): TimeStamp;
     /** @returns a new TimeStamp n nanoseconds after the unix epoch */
     static nanoseconds(value: number): TimeStamp;
     static readonly NANOSECOND: TimeStamp;
@@ -194,18 +199,29 @@ export declare class TimeStamp extends Number implements Stringer {
     /** The unix epoch */
     static readonly ZERO: TimeStamp;
     /** A zod schema for validating timestamps */
-    static readonly z: z.ZodUnion<[z.ZodEffects<z.ZodType<Number, z.ZodTypeDef, Number>, TimeStamp, Number>, z.ZodEffects<z.ZodNumber, TimeStamp, number>, z.ZodType<TimeStamp, z.ZodTypeDef, TimeStamp>]>;
+    static readonly z: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
+        value: z.ZodBigInt;
+    }, "strip", z.ZodTypeAny, {
+        value: bigint;
+    }, {
+        value: bigint;
+    }>, TimeStamp, {
+        value: bigint;
+    }>, z.ZodEffects<z.ZodString, TimeStamp, string>, z.ZodEffects<z.ZodType<Number, z.ZodTypeDef, Number>, TimeStamp, Number>, z.ZodEffects<z.ZodNumber, TimeStamp, number>, z.ZodType<TimeStamp, z.ZodTypeDef, TimeStamp>]>;
 }
 /** TimeSpan represents a nanosecond precision duration. */
-export declare class TimeSpan extends Number implements Stringer {
+export declare class TimeSpan implements Stringer {
+    private readonly value;
+    readonly encodeValue: true;
     constructor(value: CrudeTimeSpan);
+    encode(): string;
+    valueOf(): bigint;
     lessThan(other: CrudeTimeSpan): boolean;
     greaterThan(other: CrudeTimeSpan): boolean;
     lessThanOrEqual(other: CrudeTimeSpan): boolean;
     greaterThanOrEqual(other: CrudeTimeSpan): boolean;
     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;
@@ -313,7 +329,15 @@ export declare class TimeSpan extends Number implements Stringer {
     /** The zero value for a TimeSpan. */
     static readonly ZERO: TimeSpan;
     /** A zod schema for validating and transforming timespans */
-    static readonly z: z.ZodUnion<[z.ZodEffects<z.ZodType<Number, z.ZodTypeDef, Number>, TimeSpan, Number>, z.ZodEffects<z.ZodNumber, TimeSpan, number>, z.ZodType<TimeSpan, z.ZodTypeDef, TimeSpan>]>;
+    static readonly z: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
+        value: z.ZodBigInt;
+    }, "strip", z.ZodTypeAny, {
+        value: bigint;
+    }, {
+        value: bigint;
+    }>, TimeSpan, {
+        value: bigint;
+    }>, z.ZodEffects<z.ZodString, TimeSpan, string>, z.ZodEffects<z.ZodType<Number, z.ZodTypeDef, Number>, TimeSpan, Number>, z.ZodEffects<z.ZodNumber, TimeSpan, number>, z.ZodType<TimeSpan, z.ZodTypeDef, TimeSpan>]>;
 }
 /** Rate represents a data rate in Hz. */
 export declare class Rate extends Number implements Stringer {
@@ -490,17 +514,49 @@ export declare class TimeRange implements Stringer {
     static readonly ZERO: TimeRange;
     /** A zod schema for validating and transforming time ranges */
     static readonly z: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
-        start: z.ZodUnion<[z.ZodEffects<z.ZodType<Number, z.ZodTypeDef, Number>, TimeStamp, Number>, z.ZodEffects<z.ZodNumber, TimeStamp, number>, z.ZodType<TimeStamp, z.ZodTypeDef, TimeStamp>]>;
-        end: z.ZodUnion<[z.ZodEffects<z.ZodType<Number, z.ZodTypeDef, Number>, TimeStamp, Number>, z.ZodEffects<z.ZodNumber, TimeStamp, number>, z.ZodType<TimeStamp, z.ZodTypeDef, TimeStamp>]>;
+        start: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
+            value: z.ZodBigInt;
+        }, "strip", z.ZodTypeAny, {
+            value: bigint;
+        }, {
+            value: bigint;
+        }>, TimeStamp, {
+            value: bigint;
+        }>, z.ZodEffects<z.ZodString, TimeStamp, string>, z.ZodEffects<z.ZodType<Number, z.ZodTypeDef, Number>, TimeStamp, Number>, z.ZodEffects<z.ZodNumber, TimeStamp, number>, z.ZodType<TimeStamp, z.ZodTypeDef, TimeStamp>]>;
+        end: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
+            value: z.ZodBigInt;
+        }, "strip", z.ZodTypeAny, {
+            value: bigint;
+        }, {
+            value: bigint;
+        }>, TimeStamp, {
+            value: bigint;
+        }>, z.ZodEffects<z.ZodString, TimeStamp, string>, z.ZodEffects<z.ZodType<Number, z.ZodTypeDef, Number>, TimeStamp, Number>, z.ZodEffects<z.ZodNumber, TimeStamp, number>, z.ZodType<TimeStamp, z.ZodTypeDef, TimeStamp>]>;
     }, "strip", z.ZodTypeAny, {
         start: TimeStamp;
         end: TimeStamp;
     }, {
-        start: (number | Number | TimeStamp) & (number | Number | TimeStamp | undefined);
-        end: (number | Number | TimeStamp) & (number | Number | TimeStamp | undefined);
+        start: (string | number | Number | TimeStamp | {
+            value: bigint;
+        }) & (string | number | Number | TimeStamp | {
+            value: bigint;
+        } | undefined);
+        end: (string | number | Number | TimeStamp | {
+            value: bigint;
+        }) & (string | number | Number | TimeStamp | {
+            value: bigint;
+        } | undefined);
     }>, TimeRange, {
-        start: (number | Number | TimeStamp) & (number | Number | TimeStamp | undefined);
-        end: (number | Number | TimeStamp) & (number | Number | TimeStamp | undefined);
+        start: (string | number | Number | TimeStamp | {
+            value: bigint;
+        }) & (string | number | Number | TimeStamp | {
+            value: bigint;
+        } | undefined);
+        end: (string | number | Number | TimeStamp | {
+            value: bigint;
+        }) & (string | number | Number | TimeStamp | {
+            value: bigint;
+        } | undefined);
     }>, z.ZodType<TimeRange, z.ZodTypeDef, TimeRange>]>;
 }
 /** DataType is a string that represents a data type. */
@@ -509,10 +565,11 @@ export declare class DataType extends String implements Stringer {
     /**
      * @returns the TypedArray constructor for the DataType.
      */
-    get Array(): NativeTypedArrayConstructor;
+    get Array(): TypedArrayConstructor;
     equals(other: DataType): boolean;
     /** @returns a string representation of the DataType. */
     toString(): string;
+    get isVariable(): boolean;
     get density(): Density;
     /**
      * Checks whether the given TypedArray is of the same type as the DataType.
@@ -520,7 +577,7 @@ export declare class DataType extends String implements Stringer {
      * @param array - The TypedArray to check.
      * @returns True if the TypedArray is of the same type as the DataType.
      */
-    checkArray(array: NativeTypedArray): boolean;
+    checkArray(array: TypedArray): boolean;
     toJSON(): string;
     get usesBigInt(): boolean;
     /** Represents an Unknown/Invalid DataType. */
@@ -545,6 +602,8 @@ export declare class DataType extends String implements Stringer {
     static readonly UINT16: DataType;
     /** Represents a 8-bit unsigned integer value. */
     static readonly UINT8: DataType;
+    /** Represents a boolean value. Alias for UINT8. */
+    static readonly BOOLEAN: DataType;
     /** Represents a 64-bit unix epoch. */
     static readonly TIMESTAMP: DataType;
     /** Represents a UUID data type */
@@ -555,7 +614,7 @@ export declare class DataType extends String implements Stringer {
     /** Represents a JSON data type. JSON has an unknown density, and is separated by a
      * newline character. */
     static readonly JSON: DataType;
-    static readonly ARRAY_CONSTRUCTORS: Map<string, NativeTypedArrayConstructor>;
+    static readonly ARRAY_CONSTRUCTORS: Map<string, TypedArrayConstructor>;
     static readonly ARRAY_CONSTRUCTOR_DATA_TYPES: Map<string, DataType>;
     static readonly DENSITIES: Map<string, Density>;
     /** All the data types. */
@@ -633,15 +692,15 @@ export declare class Size extends Number implements Stringer {
     static readonly z: z.ZodUnion<[z.ZodEffects<z.ZodNumber, Size, number>, z.ZodType<Size, z.ZodTypeDef, Size>]>;
     get isZero(): boolean;
 }
-export type CrudeTimeStamp = TimeStamp | TimeSpan | number | Date | string | DateComponents | Number;
+export type CrudeTimeStamp = bigint | BigInt | TimeStamp | TimeSpan | number | Date | string | DateComponents | Number;
 export type TimeStampT = number;
-export type CrudeTimeSpan = TimeSpan | TimeStamp | number | Number;
+export type CrudeTimeSpan = bigint | BigInt | TimeSpan | TimeStamp | number | Number;
 export type TimeSpanT = number;
 export type CrudeRate = Rate | number | Number;
 export type RateT = number;
 export type CrudeDensity = Density | number | Number;
 export type DensityT = number;
-export type CrudeDataType = DataType | string | NativeTypedArray;
+export type CrudeDataType = DataType | string | TypedArray;
 export type DataTypeT = string;
 export type CrudeSize = Size | number | Number;
 export type SizeT = number;
@@ -649,9 +708,11 @@ export interface CrudeTimeRange {
     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>;
-type NativeTypedArrayConstructor = Uint8ArrayConstructor | Uint16ArrayConstructor | Uint32ArrayConstructor | BigUint64ArrayConstructor | Float32ArrayConstructor | Float64ArrayConstructor | Int8ArrayConstructor | Int16ArrayConstructor | Int32ArrayConstructor | BigInt64ArrayConstructor;
-type TelemValue = number | bigint;
-export declare const convertDataType: (source: DataType, target: DataType, value: TelemValue, offset?: number | bigint) => TelemValue;
+export declare const typedArrayZ: 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 TypedArray = z.infer<typeof typedArrayZ>;
+type TypedArrayConstructor = Uint8ArrayConstructor | Uint16ArrayConstructor | Uint32ArrayConstructor | BigUint64ArrayConstructor | Float32ArrayConstructor | Float64ArrayConstructor | Int8ArrayConstructor | Int16ArrayConstructor | Int32ArrayConstructor | BigInt64ArrayConstructor;
+type NumericTelemValue = number | bigint;
+export type TelemValue = number | bigint | string | boolean | Date | TimeStamp | TimeSpan;
+export declare const isTelemValue: (value: unknown) => value is TelemValue;
+export declare const convertDataType: (source: DataType, target: DataType, value: NumericTelemValue, offset?: number | bigint) => NumericTelemValue;
 export {};