@synnaxlabs/pluto 0.12.0

package/dist/telem/aether/transformers.d.ts

@@ -0,0 +1,197 @@
+import { z } from "zod";
+import { status } from '../../status/aether';
+import { type Factory } from '../../telem/aether/factory';
+import { type Telem, type Spec, type BooleanSinkSpec, UnarySinkTransformer, type BooleanSink, UnarySourceTransformer, type BooleanSource, type BooleanSourceSpec, MultiSourceTransformer, type StringSourceSpec } from '../../telem/aether/telem';
+export declare class TransformerFactory implements Factory {
+    type: string;
+    create(spec: Spec): Telem | null;
+}
+declare const setpointProps: z.ZodObject<{
+    truthy: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    falsy: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    truthy: number;
+    falsy: number;
+}, {
+    truthy?: number | undefined;
+    falsy?: number | undefined;
+}>;
+export type SetpointProps = z.infer<typeof setpointProps>;
+export declare const setpoint: (props: SetpointProps) => BooleanSinkSpec;
+export declare class Setpoint extends UnarySinkTransformer<boolean, number, typeof setpointProps> implements BooleanSink {
+    static readonly TYPE = "boolean-numeric-converter-sink";
+    static readonly propsZ: z.ZodObject<{
+        truthy: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        falsy: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        truthy: number;
+        falsy: number;
+    }, {
+        truthy?: number | undefined;
+        falsy?: number | undefined;
+    }>;
+    schema: z.ZodObject<{
+        truthy: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        falsy: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        truthy: number;
+        falsy: number;
+    }, {
+        truthy?: number | undefined;
+        falsy?: number | undefined;
+    }>;
+    transform(value: boolean): number;
+}
+declare const withinBoundsProps: z.ZodObject<{
+    trueBound: z.ZodObject<{
+        lower: z.ZodNumber;
+        upper: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        lower: number;
+        upper: number;
+    }, {
+        lower: number;
+        upper: number;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    trueBound: {
+        lower: number;
+        upper: number;
+    };
+}, {
+    trueBound: {
+        lower: number;
+        upper: number;
+    };
+}>;
+export type WithinBoundsProps = z.infer<typeof withinBoundsProps>;
+export declare const withinBounds: (props: WithinBoundsProps) => BooleanSourceSpec;
+export declare class WithinBounds extends UnarySourceTransformer<number, boolean, typeof withinBoundsProps> implements BooleanSource {
+    static readonly TYPE = "boolean-source";
+    static readonly propsZ: z.ZodObject<{
+        trueBound: z.ZodObject<{
+            lower: z.ZodNumber;
+            upper: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            lower: number;
+            upper: number;
+        }, {
+            lower: number;
+            upper: number;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        trueBound: {
+            lower: number;
+            upper: number;
+        };
+    }, {
+        trueBound: {
+            lower: number;
+            upper: number;
+        };
+    }>;
+    schema: z.ZodObject<{
+        trueBound: z.ZodObject<{
+            lower: z.ZodNumber;
+            upper: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            lower: number;
+            upper: number;
+        }, {
+            lower: number;
+            upper: number;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        trueBound: {
+            lower: number;
+            upper: number;
+        };
+    }, {
+        trueBound: {
+            lower: number;
+            upper: number;
+        };
+    }>;
+    curr: boolean | null;
+    protected shouldNotify(value: number): boolean;
+    protected transform(value: number): boolean;
+}
+declare const meanProps: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare class Mean extends MultiSourceTransformer<number, number, typeof meanProps> {
+    static readonly TYPE = "mean";
+    static readonly propsZ: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    schema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    protected transform(values: Record<string, number>): number;
+}
+export declare const mean: (props: z.input<typeof meanProps>) => BooleanSourceSpec;
+export declare const booleanStatusProps: z.ZodObject<{
+    trueVariant: z.ZodDefault<z.ZodOptional<z.ZodEnum<["success", "error", "warning", "info", "loading", "disabled"]>>>;
+}, "strip", z.ZodTypeAny, {
+    trueVariant: "disabled" | "loading" | "error" | "success" | "warning" | "info";
+}, {
+    trueVariant?: "disabled" | "loading" | "error" | "success" | "warning" | "info" | undefined;
+}>;
+export declare class BooleanStatus extends UnarySourceTransformer<status.Spec, boolean, typeof booleanStatusProps> {
+    static readonly TYPE = "boolean-status";
+    static readonly propsZ: z.ZodObject<{
+        trueVariant: z.ZodDefault<z.ZodOptional<z.ZodEnum<["success", "error", "warning", "info", "loading", "disabled"]>>>;
+    }, "strip", z.ZodTypeAny, {
+        trueVariant: "disabled" | "loading" | "error" | "success" | "warning" | "info";
+    }, {
+        trueVariant?: "disabled" | "loading" | "error" | "success" | "warning" | "info" | undefined;
+    }>;
+    schema: z.ZodObject<{
+        trueVariant: z.ZodDefault<z.ZodOptional<z.ZodEnum<["success", "error", "warning", "info", "loading", "disabled"]>>>;
+    }, "strip", z.ZodTypeAny, {
+        trueVariant: "disabled" | "loading" | "error" | "success" | "warning" | "info";
+    }, {
+        trueVariant?: "disabled" | "loading" | "error" | "success" | "warning" | "info" | undefined;
+    }>;
+    protected transform(value: status.Spec): boolean;
+}
+export declare const booleanStatus: (props: z.input<typeof booleanStatusProps>) => BooleanSourceSpec;
+export declare const stringifyNumberProps: z.ZodObject<{
+    precision: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    prefix: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    suffix: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    prefix: string;
+    precision: number;
+    suffix: string;
+}, {
+    precision?: number | undefined;
+    prefix?: string | undefined;
+    suffix?: string | undefined;
+}>;
+export declare class StringifyNumber extends UnarySourceTransformer<number, string, typeof stringifyNumberProps> {
+    static readonly TYPE = "stringify-number";
+    static readonly propsZ: z.ZodObject<{
+        precision: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        prefix: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        suffix: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        prefix: string;
+        precision: number;
+        suffix: string;
+    }, {
+        precision?: number | undefined;
+        prefix?: string | undefined;
+        suffix?: string | undefined;
+    }>;
+    schema: z.ZodObject<{
+        precision: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        prefix: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        suffix: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        prefix: string;
+        precision: number;
+        suffix: string;
+    }, {
+        precision?: number | undefined;
+        prefix?: string | undefined;
+        suffix?: string | undefined;
+    }>;
+    protected transform(value: number): string;
+}
+export declare const stringifyNumber: (props: z.input<typeof stringifyNumberProps>) => StringSourceSpec;
+export {};

package/dist/telem/client/cache/cache.d.ts

@@ -0,0 +1,14 @@
+import { type Channel, TimeRange } from "@synnaxlabs/client";
+import { type Series } from "@synnaxlabs/x";
+import { Dynamic } from '../../../telem/client/cache/dynamic';
+import { type DirtyReadResult, Static, type DirtyReadForWriteResult } from '../../../telem/client/cache/static';
+export declare class Cache {
+    channel: Channel;
+    static: Static;
+    dynamic: Dynamic;
+    constructor(dynamicCap: number, channel: Channel);
+    writeDynamic(series: Series[]): Series[];
+    writeStatic(tr: TimeRange, series: Series[]): void;
+    dirtyRead(tr: TimeRange): DirtyReadResult;
+    dirtyReadForStaticWrite(tr: TimeRange): Promise<DirtyReadForWriteResult>;
+}

package/dist/telem/client/cache/dynamic.d.ts

@@ -0,0 +1,32 @@
+import { DataType, Series } from "@synnaxlabs/x";
+export interface DynamicWriteResponse {
+    flushed: Series[];
+    allocated: Series[];
+}
+/**
+ * A cache for channel data that maintains a single, rolling Series as a buffer
+ * for channel data.
+ */
+export declare class Dynamic {
+    buffer: Series | null;
+    private readonly cap;
+    private readonly dataType;
+    /**
+     * @constructor
+     *
+     * @param cap - The capacity of the cache buffer.
+     * @param dataType - The data type of the channel.
+     */
+    constructor(cap: number, dataType: DataType);
+    /** @returns the number of samples currenly held in the cache. */
+    get length(): number;
+    /**
+     * Writes the given arrays to the cache.
+     *
+     * @returns a list of buffers that were filled by the cache during the write. If
+     * the current buffer is able to fit all writes, no buffers will be returned.
+     */
+    write(series: Series[]): DynamicWriteResponse;
+    private allocate;
+    private _write;
+}

package/dist/telem/client/cache/dynamic.spec.d.ts

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

package/dist/telem/client/cache/external.d.ts

@@ -0,0 +1 @@
+export * from '../../../telem/client/cache/cache';

package/dist/telem/client/cache/index.d.ts

@@ -0,0 +1,2 @@
+import * as cache from '../../../telem/client/cache/external';
+export { cache };

package/dist/telem/client/cache/static.d.ts

@@ -0,0 +1,31 @@
+import { TimeRange, type Series, type Destructor } from "@synnaxlabs/x";
+export interface DirtyReadResult {
+    series: Series[];
+    gaps: TimeRange[];
+}
+export interface DirtyReadForWriteResult {
+    series: Series[];
+    gaps: TimeRange[];
+    done: Destructor;
+}
+/**
+ * A cache for channel data that only accepts pre-written arrays i.e. it performs
+ * no allocatio, buffering, or modification of new arrays.
+ */
+export declare class Static {
+    private readonly mu;
+    private readonly entries;
+    constructor();
+    /**
+     * @returns the total time range of all entries in the cache.
+     */
+    get extent(): TimeRange;
+    /**
+     * @returns a list of all gaps between cache reads.
+     */
+    get gaps(): TimeRange[];
+    write(tr: TimeRange, series: Series[]): void;
+    private getInsertionIndex;
+    dirtyReadForWrite(tr: TimeRange): Promise<DirtyReadForWriteResult>;
+    dirtyRead(tr: TimeRange): DirtyReadResult;
+}

package/dist/telem/client/cache/static.spec.d.ts

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

package/dist/telem/client/client.d.ts

@@ -0,0 +1,104 @@
+import { type alamos } from "@synnaxlabs/alamos";
+import { type Channel, type channel, type Synnax } from "@synnaxlabs/client";
+import { type Destructor, type Series, TimeRange, type SeriesDigest } from "@synnaxlabs/x";
+export declare const CACHE_BUFFER_SIZE = 10000;
+export type StreamHandler = (data: Record<channel.Key, ReadResponse>) => void;
+/**
+ * A client that can be used to retrieve a channel from the Synnax cluster
+ * by its key.
+ */
+export interface ChannelClient {
+    /**
+     * Retrieves a channel from the Synnax cluster by its key.
+     *
+     * @param key - The key of the channel to retrieve.
+     * @returns the channel with the given key.
+     * @throws QueryError if the channel does not exist.
+     */
+    retrieveChannel: (key: channel.Key) => Promise<Channel>;
+}
+/** A client that can be used to read telemetry from the Synnax cluster. */
+export interface ReadClient {
+    /**
+     * Reads telemetry from the given channels for the given time range.
+     *
+     * @param tr  - The time range to read from.
+     * @param keys - The keys of the channels to read from.
+     * @returns a record with a read response for each channel in keys, regardless of
+     * whether or not data was found for the given chnannel. NOTE: Responses are not
+     * guaranteed to have the same topology i.e each response may contain a different
+     * number of Series with different lengths. It's up to the caller to use the
+     * 'alignment' field of the Series to normalize the data shape if necessary.
+     */
+    read: (tr: TimeRange, keys: channel.Keys) => Promise<Record<channel.Key, ReadResponse>>;
+}
+/** A client that can be used to stream telemetry from the Synnax cluster. */
+export interface StreamClient {
+    stream: (handler: StreamHandler, keys: channel.Keys) => Promise<Destructor>;
+}
+/**
+ * Client provides an interface for performing basic telemetry operations
+ * against a Synnax cluster. This interface is a simplification of the Synnax
+ * client to make it easy to stub out for testing.
+ */
+export interface Client extends ChannelClient, ReadClient, StreamClient {
+    /** Close closes the client, releasing all resources from the cache. */
+    close: () => void;
+}
+/**
+ * Proxy is a Client implementation that proxies all operations to another Client,
+ * allowing the underlying Client to be swapped out at runtime. If no Client is
+ * set, all operations will throw an error.
+ */
+export declare class Proxy implements Client {
+    readonly _client: Client | null;
+    swap(client: Client | null): void;
+    /** Implements ChannelClient. */
+    retrieveChannel(key: channel.Key): Promise<Channel>;
+    /** Implements ReadClient. */
+    read(tr: TimeRange, channels: channel.Keys): Promise<Record<channel.Key, ReadResponse>>;
+    /** Stream implements StreamClient. */
+    stream(handler: StreamHandler, keys: channel.Keys): Promise<Destructor>;
+    /** Close implements CLient. */
+    close(): void;
+    private get client();
+}
+/**
+ * Core wraps a Synnax client to implement the pluto telemetry Client interface,
+ * adding a transparent caching layer.
+ */
+export declare class Core implements Client {
+    readonly key: string;
+    private readonly core;
+    private readonly ins;
+    private readonly mu;
+    private readonly cache;
+    private readonly listeners;
+    private _streamer;
+    constructor(wrap: Synnax, ins: alamos.Instrumentation);
+    /** Implements ChannelClient. */
+    retrieveChannel(key: channel.Key): Promise<Channel>;
+    /** Implements ReadClient. */
+    read(tr: TimeRange, channels: channel.Keys): Promise<Record<channel.Key, ReadResponse>>;
+    /** Implements StreamClient. */
+    stream(handler: StreamHandler, keys: channel.Keys): Promise<Destructor>;
+    /** Implements Client. */
+    close(): void;
+    private removeStreamHandler;
+    private getCache;
+    private updateStreamer;
+    private start;
+}
+export interface ReadResponseDigest {
+    channel: channel.Key;
+    timeRange: string;
+    series: SeriesDigest[];
+}
+export declare const responseDigests: (responses: ReadResponse[]) => ReadResponseDigest[];
+export declare class ReadResponse {
+    channel: Channel;
+    data: Series[];
+    constructor(channel: Channel, data: Series[]);
+    get timeRange(): TimeRange;
+    get digest(): ReadResponseDigest;
+}

package/dist/telem/client/index.d.ts

@@ -0,0 +1 @@
+export * as client from '../../telem/client/client';

package/dist/telem/control/Chip.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { Button } from '../../button';
+import { control } from '../../telem/control/aether';
+export interface ChipProps extends Pick<typeof control.chipStateZ, "source" | "sink">, Omit<Button.IconProps, "onClick" | "children"> {
+}
+export declare const Chip: import("react").FC<ChipProps & {
+    aetherKey?: string | undefined;
+}>;

package/dist/telem/control/Controller.d.ts

@@ -0,0 +1,15 @@
+import { type PropsWithChildren } from "react";
+import { type channel } from "@synnaxlabs/client";
+import { type z } from "zod";
+import { control } from '../../telem/control/aether';
+export interface ControllerProps extends Omit<z.input<typeof control.controllerStateZ>, "needsControlOf">, PropsWithChildren {
+    onStatusChange?: (status: control.Status) => void;
+    name: string;
+}
+export interface ContextValue {
+    needsControlOf: channel.Keys;
+}
+export declare const useContext: () => ContextValue;
+export declare const Controller: import("react").FC<ControllerProps & {
+    aetherKey?: string | undefined;
+}>;

package/dist/telem/control/Indicator.d.ts

@@ -0,0 +1,8 @@
+import { type PropsWithChildren } from "react";
+import { type z } from "zod";
+import { control } from '../../telem/control/aether';
+export interface IndicatorProps extends Omit<z.input<typeof control.indicatorStateZ>, "status" | "color">, PropsWithChildren {
+}
+export declare const Indicator: import("react").FC<IndicatorProps & {
+    aetherKey?: string | undefined;
+}>;

package/dist/telem/control/Legend.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import { Legend as Core } from '../../vis/legend';
+export interface LegendProps extends Core.SimpleProps {
+}
+export declare const Legend: import("react").FC<LegendProps & {
+    aetherKey?: string | undefined;
+}>;

package/dist/telem/control/StateProvider.d.ts

@@ -0,0 +1,8 @@
+import { type PropsWithChildren } from "react";
+import { type z } from "zod";
+import { control } from '../../telem/control/aether';
+export interface StateProviderProps extends z.input<typeof control.stateProviderStateZ>, PropsWithChildren {
+}
+export declare const StateProvider: import("react").FC<StateProviderProps & {
+    aetherKey?: string | undefined;
+}>;