@synnaxlabs/x 0.7.0

package/dist/spatial/scale.spec.d.ts

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

package/dist/spatial/spatial.d.ts

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

package/dist/spatial/xy.d.ts

@@ -0,0 +1,116 @@
+import { z } from "zod";
+import { clientXY, xy, type ClientXY, type XY, type Direction } from '../spatial/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<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    x: number;
+    y: number;
+}, {
+    x: number;
+    y: number;
+}>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodObject<{
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    width: number;
+    height: number;
+}, {
+    width: number;
+    height: number;
+}>, z.ZodObject<{
+    signedWidth: z.ZodNumber;
+    signedHeight: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    signedWidth: number;
+    signedHeight: number;
+}, {
+    signedWidth: number;
+    signedHeight: number;
+}>, z.ZodObject<{
+    clientX: z.ZodNumber;
+    clientY: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    clientX: number;
+    clientY: number;
+}, {
+    clientX: number;
+    clientY: number;
+}>]>;
+/** A crude representation of a {@link XY} coordinate. */
+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.
+ * @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 declare const construct: (x: Crude, y?: number) => XY;
+/** An x and y coordinate of zero */
+export declare const ZERO: {
+    x: number;
+    y: number;
+};
+/** An x and y coordinate of one */
+export declare const ONE: {
+    x: number;
+    y: number;
+};
+/** An x and y coordinate of infinity */
+export declare const INFINITY: {
+    x: number;
+    y: number;
+};
+/** An x and y coordinate of NaN */
+export declare const NAN: {
+    x: number;
+    y: number;
+};
+/** @returns true if the two XY coordinates are semantically equal. */
+export declare const equals: (a: Crude, b: Crude, threshold?: number) => boolean;
+/** Is zero is true if the XY coordinate has a semantic x and y value of zero. */
+export declare const isZero: (c: Crude) => boolean;
+/**
+ * @returns the given coordinate scaled by the given factors. If only one factor is given,
+ * the y factor is assumed to be the same as the x factor.
+ */
+export declare const scale: (c: Crude, x: number, y?: number) => XY;
+/** @returns the given coordinate translated in the X direction by the given amount. */
+export declare const translateX: (c: Crude, x: number) => XY;
+/** @returns the given coordinate translated in the Y direction by the given amount. */
+export declare const translateY: (c: Crude, y: number) => XY;
+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 declare const translate: TranslateOverloadOne & TranslateOverloadTwo;
+/**
+ * @returns the given coordinate the given direction set to the given value.
+ * @example set({ x: 1, y: 2 }, "x", 3) // { x: 3, y: 2 }
+ */
+export declare const set: (c: Crude, direction: Direction, value: number) => XY;
+/** @returns the magnitude of the distance between the two given coordinates. */
+export declare const distance: (ca: Crude, cb: Crude) => number;
+/** @returns the magnitude of the x distance between the two given coordinates. */
+export declare const xDistance: (ca: Crude, cb: Crude) => number;
+/** @returns the magnitude of the y distance between the two given coordinates. */
+export declare const yDistance: (ca: Crude, cb: Crude) => number;
+/**
+ * @returns the translation that would need to be applied to move the first coordinate
+ * to the second coordinate.
+ */
+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 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 }. */
+export declare const css: (a: Crude) => {
+    left: number;
+    top: number;
+};

package/dist/spatial/xy.spec.d.ts

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

package/dist/telem/encode.d.ts

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

package/dist/telem/generate.d.ts

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

package/dist/telem/gl.d.ts

@@ -0,0 +1,11 @@
+export interface GLBufferController {
+    createBuffer: () => WebGLBuffer | null;
+    bufferData: ((target: number, data: ArrayBufferLike, usage: number) => void) & ((target: number, size: number, usage: number) => void);
+    bufferSubData: (target: number, offset: number, data: ArrayBufferLike) => void;
+    bindBuffer: (target: number, buffer: WebGLBuffer | null) => void;
+    deleteBuffer: (buffer: WebGLBuffer | null) => void;
+    ARRAY_BUFFER: number;
+    STATIC_DRAW: number;
+    DYNAMIC_DRAW: number;
+}
+export type GLBufferUsage = "static" | "dynamic";

package/dist/telem/index.d.ts

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

package/dist/telem/series.d.ts

@@ -0,0 +1,104 @@
+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';
+export type SampleValue = number | bigint;
+export interface SeriesDigest {
+    dataType: string;
+    sampleOffset: SampleValue;
+    alignment: number;
+    timeRange?: string;
+    length: number;
+}
+/**
+ * Series is a strongly typed array of telemetry samples backed by an underlying binary
+ * buffer.
+ */
+export declare class Series {
+    /** The data type of the array */
+    readonly dataType: DataType;
+    /**
+     * A sample offset that can be used to shift the values of all samples upwards or
+     * downwards. Typically used to convert arrays to lower precision while preserving
+     * the relative range of actual values.
+     */
+    sampleOffset: SampleValue;
+    /**
+     * Stores information about the buffer state of this array into a WebGL buffer.
+     */
+    private readonly gl;
+    /** The underlying data. */
+    private readonly _data;
+    readonly _timeRange?: TimeRange;
+    readonly alignment: number;
+    /** A cached minimum value. */
+    private _min?;
+    /** A cached maximum value. */
+    private _max?;
+    /** The write position of the buffer. */
+    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 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);
+    acquire(gl?: GLBufferController): void;
+    release(): void;
+    write(other: Series): number;
+    /** @returns the underlying buffer backing this array. */
+    get buffer(): ArrayBufferLike;
+    private get underlyingData();
+    /** @returns a native typed array with the proper data type. */
+    get data(): NativeTypedArray;
+    toStrings(): string[];
+    toUUIDs(): string[];
+    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. */
+    get byteLength(): Size;
+    /** @returns the number of samples in this array. */
+    get length(): number;
+    /**
+     * Creates a new array with a different data type.
+     * @param target the data type to convert to.
+     * @param sampleOffset an offset to apply to each sample. This can help with precision
+     * issues when converting between data types.
+     *
+     * 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;
+    private calcRawMax;
+    /** @returns the maximum value in the array */
+    get max(): SampleValue;
+    private calcRawMin;
+    /** @returns the minimum value in the array */
+    get min(): SampleValue;
+    /** @returns the bounds of this array. */
+    get bounds(): bounds.Bounds;
+    private maybeRecomputeMinMax;
+    enrich(): void;
+    get range(): SampleValue;
+    at(index: number): SampleValue;
+    /**
+     * @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;
+    updateGLBuffer(gl: GLBufferController): void;
+    get digest(): SeriesDigest;
+    private maybeGarbageCollectGLBuffer;
+    get glBuffer(): WebGLBuffer;
+    slice(start: number, end?: number): Series;
+    reAlign(alignment: number): Series;
+}
+export declare const addSamples: (a: SampleValue, b: SampleValue) => SampleValue;

package/dist/telem/series.spec.d.ts

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