@synnaxlabs/x 0.14.1 → 0.15.0

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @synnaxlabs/x@0.14.1 build /home/runner/work/synnax/synnax/x/ts
+> @synnaxlabs/x@0.15.0 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  209.89 kB │ gzip: 49.04 kB │ map: 632.82 kB
-[vite:dts] Declaration files built in 3265ms.
+dist/x.js  217.59 kB │ gzip: 50.60 kB │ map: 651.51 kB
+[vite:dts] Declaration files built in 3123ms.
 
-dist/x.cjs  137.61 kB │ gzip: 39.21 kB │ map: 612.53 kB
-✓ built in 4.16s
+dist/x.cjs  143.43 kB │ gzip: 40.54 kB │ map: 630.60 kB
+✓ built in 4.05s

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,12 +1,11 @@
 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';
-export type SampleValue = number | bigint;
+import { DataType, type TypedArray, type Rate, Size, TimeRange, TimeStamp, type CrudeDataType, type TelemValue, type NumericTelemValue } from './telem';
 export interface SeriesDigest {
     key: string;
     dataType: string;
-    sampleOffset: SampleValue;
+    sampleOffset: NumericTelemValue;
     alignment: bounds.Bounds;
     timeRange?: string;
     length: number;
@@ -15,13 +14,15 @@ export interface SeriesDigest {
 interface BaseSeriesProps {
     dataType?: CrudeDataType;
     timeRange?: TimeRange;
-    sampleOffset?: SampleValue;
+    sampleOffset?: NumericTelemValue;
     glBufferUsage?: GLBufferUsage;
     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;
@@ -37,7 +38,7 @@ export interface SeriesMemInfo {
  * Series is a strongly typed array of telemetry samples backed by an underlying binary
  * buffer.
  */
-export declare class Series {
+export declare class Series<T extends TelemValue = TelemValue> {
     key: string;
     /** The data type of the array */
     readonly dataType: DataType;
@@ -46,7 +47,7 @@ export declare class Series {
      * downwards. Typically used to convert arrays to lower precision while preserving
      * the relative range of actual values.
      */
-    sampleOffset: SampleValue;
+    sampleOffset: NumericTelemValue;
     /**
      * Stores information about the buffer state of this array into a WebGL buffer.
      */
@@ -56,19 +57,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 +86,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 +100,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.
@@ -107,34 +110,55 @@ export declare class Series {
      * WARNING: This method is expensive and copies the entire underlying array. There
      * also may be untimely precision issues when converting between data types.
      */
-    convert(target: DataType, sampleOffset?: SampleValue): Series;
+    convert(target: DataType, sampleOffset?: NumericTelemValue): Series;
     private calcRawMax;
     /** @returns the maximum value in the array */
-    get max(): SampleValue;
+    get max(): NumericTelemValue;
     private calcRawMin;
     /** @returns the minimum value in the array */
-    get min(): SampleValue;
+    get min(): NumericTelemValue;
     /** @returns the bounds of this array. */
     get bounds(): bounds.Bounds;
     private maybeRecomputeMinMax;
     enrich(): void;
-    get range(): SampleValue;
-    at(index: number, required: true): SampleValue;
-    at(index: number, required?: false): SampleValue | undefined;
+    get range(): NumericTelemValue;
+    at(index: number, required: true): T;
+    at(index: number, required?: false): T | undefined;
+    private atVariable;
     /**
      * @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.
      * @param value the value to search for.
      */
-    binarySearch(value: SampleValue): number;
+    binarySearch(value: NumericTelemValue): number;
     updateGLBuffer(gl: GLBufferController): void;
+    as(dataType: "string"): Series<string>;
+    as(dataType: "number"): Series<number>;
+    as(dataType: "bigint"): Series<bigint>;
+    as(dataType: "numeric"): Series<NumericTelemValue>;
     get digest(): SeriesDigest;
     get memInfo(): SeriesMemInfo;
     get alignmentBounds(): bounds.Bounds;
     private maybeGarbageCollectGLBuffer;
     get glBuffer(): WebGLBuffer;
+    [Symbol.iterator](): Iterator<T>;
     slice(start: number, end?: number): Series;
     reAlign(alignment: number): Series;
 }
-export declare const addSamples: (a: SampleValue, b: SampleValue) => SampleValue;
+export declare const addSamples: (a: NumericTelemValue, b: NumericTelemValue) => NumericTelemValue;
+export declare class MultiSeries<T extends TelemValue = TelemValue> implements Iterable<T> {
+    readonly series: Array<Series<T>>;
+    constructor(series: Array<Series<T>>);
+    as(dataType: "string"): MultiSeries<string>;
+    as(dataType: "number"): MultiSeries<number>;
+    as(dataType: "bigint"): MultiSeries<bigint>;
+    as(dataType: "numeric"): MultiSeries<NumericTelemValue>;
+    get dataType(): DataType;
+    get timeRange(): TimeRange;
+    push(series: Series<T>): void;
+    get length(): number;
+    at(index: number, required: true): T;
+    at(index: number, required?: false): T | undefined;
+    [Symbol.iterator](): Iterator<T>;
+}
 export {};

package/dist/telem/telem.d.ts

@@ -565,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.
@@ -576,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. */
@@ -601,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 */
@@ -611,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. */
@@ -697,7 +700,7 @@ 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;
@@ -705,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;
+export 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 {};