@synnaxlabs/pluto 0.12.0

package/dist/tabs/Selector.d.ts

@@ -0,0 +1,23 @@
+import { type ReactElement } from "react";
+import { Align } from '../align';
+import { type ComponentSize } from '../util/component';
+export interface TabSpec {
+    tabKey: string;
+    name: string;
+    closable?: boolean;
+    icon?: ReactElement;
+    editable?: boolean;
+}
+export interface SelectorProps extends Omit<Align.SpaceProps, "children" | "size"> {
+    size: ComponentSize;
+}
+export declare const Selector: ({ className, size, ...props }: SelectorProps) => ReactElement | null;
+export interface SelectorButtonProps extends TabSpec {
+    selected?: string;
+    onDragStart?: (e: React.DragEvent<HTMLDivElement>, tab: TabSpec) => void;
+    onDragEnd?: (e: React.DragEvent<HTMLDivElement>, tab: TabSpec) => void;
+    onSelect?: (key: string) => void;
+    onClose?: (key: string) => void;
+    onRename?: (key: string, name: string) => void;
+    size: ComponentSize;
+}

package/dist/tabs/Tabs.d.ts

@@ -0,0 +1,40 @@
+import React, { type ReactElement, type ReactNode } from "react";
+import { Align } from '../align';
+import { type TabSpec } from '../tabs/Selector';
+import { type ComponentSize } from '../util/component';
+import { type RenderProp } from '../util/renderProp';
+export interface Tab extends TabSpec {
+    content?: ReactNode;
+}
+export type TabRenderProp = RenderProp<Tab>;
+export interface UseStaticTabsProps {
+    tabs: Tab[];
+    content?: TabRenderProp;
+    onSelect?: (key: string) => void;
+}
+export declare const resetSelection: (selected?: string, tabs?: Tab[]) => string | undefined;
+export declare const rename: (key: string, title: string, tabs: Tab[]) => Tab[];
+export declare const useStatic: ({ tabs, content, onSelect, }: UseStaticTabsProps) => TabsContextValue;
+export interface TabsContextValue {
+    tabs: Tab[];
+    emptyContent?: ReactElement | null;
+    closable?: boolean;
+    selected?: string;
+    onSelect?: (key: string) => void;
+    content?: TabRenderProp;
+    onClose?: (key: string) => void;
+    onDragStart?: (e: React.DragEvent<HTMLDivElement>, tab: TabSpec) => void;
+    onDragEnd?: (e: React.DragEvent<HTMLDivElement>, tab: TabSpec) => void;
+    onDrop?: (e: React.DragEvent<HTMLDivElement>) => void;
+    onRename?: (key: string, title: string) => void;
+    onCreate?: () => void;
+}
+export interface TabsProps extends Omit<Align.SpaceProps, "children" | "onSelect" | "size" | "onDragStart" | "onDragEnd" | "content">, TabsContextValue {
+    children?: TabRenderProp;
+    size?: ComponentSize;
+}
+export declare const TabsContext: React.Context<TabsContextValue>;
+export declare const useTabsContext: () => TabsContextValue;
+export declare const Tabs: ({ content, children, onSelect, selected, closable, tabs, onClose, onDragStart, onDragEnd, onCreate, onRename, emptyContent, className, onDragOver, onDrop, size, ...props }: TabsProps) => ReactElement;
+export declare const Provider: React.Provider<TabsContextValue>;
+export declare const Content: () => ReactElement | null;

package/dist/tabs/Tabs.spec.d.ts

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

package/dist/tabs/Tabs.stories.d.ts

@@ -0,0 +1,5 @@
+import type { Meta, StoryFn } from "@storybook/react";
+import { Tabs } from '../tabs';
+declare const story: Meta<typeof Tabs.Tabs>;
+export declare const Primary: StoryFn<typeof Tabs>;
+export default story;

package/dist/tabs/external.d.ts

@@ -0,0 +1,2 @@
+export * from '../tabs/Selector';
+export * from '../tabs/Tabs';

package/dist/tabs/index.d.ts

@@ -0,0 +1 @@
+export * as Tabs from '../tabs/external';

package/dist/tabs.cjs

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const external = require("./external-yiqRIIvW.cjs");
+require("./Selector-hQLSIYum.cjs");
+require("./jsx-runtime-N1ikfypN.cjs");
+require("react");
+require("./Toggle-eOKYw1OT.cjs");
+require("./css-V3VUT_Js.cjs");
+require("zod");
+require("./component-joFaJiQW.cjs");
+require("react-dom");
+require("./Center-ZAcURh-3.cjs");
+require("react-hook-form");
+exports.Tabs = external.external;
+//# sourceMappingURL=tabs.cjs.map

package/dist/tabs.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"tabs.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;"}

package/dist/tabs.js

@@ -0,0 +1,15 @@
+import { e } from "./external-_CtRDtih.js";
+import "./Selector-R3lL41_i.js";
+import "./jsx-runtime-rX5tAIG2.js";
+import "react";
+import "./Toggle-kLunfJtR.js";
+import "./css-NTD4Xm8x.js";
+import "zod";
+import "./component-k78Jq9I7.js";
+import "react-dom";
+import "./Center-gEKkAkdh.js";
+import "react-hook-form";
+export {
+  e as Tabs
+};
+//# sourceMappingURL=tabs.js.map

package/dist/tabs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tabs.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;"}

package/dist/tag/Tag.d.ts

@@ -0,0 +1,12 @@
+import { type ReactElement } from "react";
+import { Color } from '../color';
+import { Text } from '../text';
+import { type ComponentSize } from '../util/component';
+export interface TagProps extends Omit<Text.TextProps, "level" | "size" | "wrap"> {
+    icon?: ReactElement;
+    onClose?: () => void;
+    color?: Color.Crude;
+    size?: ComponentSize;
+    variant?: "filled" | "outlined";
+}
+export declare const Tag: ({ children, size, variant, color, icon, onClose, onDragStart, ...props }: TagProps) => ReactElement;

package/dist/tag/Tag.spec.d.ts

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

package/dist/tag/Tag.stories.d.ts

@@ -0,0 +1,5 @@
+import type { Meta, StoryFn } from "@storybook/react";
+import { Tag } from '../tag';
+declare const story: Meta<typeof Tag.Tag>;
+export declare const Primary: StoryFn<typeof Tag.Tag>;
+export default story;

package/dist/tag/index.d.ts

@@ -0,0 +1 @@
+export * as Tag from '../tag/Tag';

package/dist/telem/Pipeline.d.ts

@@ -0,0 +1,2 @@
+import { type ReactElement } from "react";
+export declare const PipelineAssembler: () => ReactElement;

package/dist/telem/Provider.d.ts

@@ -0,0 +1,6 @@
+import { type PropsWithChildren } from "react";
+export interface ProviderProps extends PropsWithChildren<any> {
+}
+export declare const Provider: import("react").FC<ProviderProps & {
+    aetherKey?: string | undefined;
+}>;

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

@@ -0,0 +1,16 @@
+import { type aether } from '../../aether/aether';
+import { type telem } from '../../telem/aether';
+import { type Factory } from "./factory";
+import { type Spec } from "./telem";
+export interface Provider {
+    key: string;
+    equals: (other: Provider) => boolean;
+    registerFactory: (f: Factory) => void;
+    create: <T>(props: Spec) => T;
+}
+export declare const useProvider: (ctx: aether.Context) => Provider;
+export declare const setProvider: (ctx: aether.Context, prov: Provider) => void;
+export declare const registerFactory: (ctx: aether.Context, f: Factory) => void;
+export declare const shouldUpdate: (ctx: aether.Context, prevProv: Provider, spec: Spec, prevSpec: Spec) => boolean;
+export declare const useSource: <V>(ctx: aether.Context, spec: Spec, prev: telem.Source<V>) => telem.Source<V>;
+export declare const useSink: <V>(ctx: aether.Context, spec: Spec, prev: telem.Sink<V>) => telem.Sink<V>;

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

@@ -0,0 +1,9 @@
+import { type Series, type SampleValue } from "@synnaxlabs/x";
+/**
+ * Converts the given serie
+ *
+ * @param series
+ * @param offset
+ * @returns
+ */
+export declare const convertSeriesFloat32: (series: Series, offset?: SampleValue) => Series;

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

@@ -0,0 +1,9 @@
+export * from '../../telem/aether/telem';
+export * from '../../telem/aether/context';
+export * from '../../telem/aether/factory';
+export * from '../../telem/aether/transformers';
+export * from '../../telem/aether/remote';
+export * from '../../telem/aether/provider';
+export * from '../../telem/aether/noop';
+export * from '../../telem/aether/static';
+export * from '../../telem/aether/pipeline';

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

@@ -0,0 +1,14 @@
+import { type telem } from '../../telem/aether';
+import { type client } from '../../telem/client';
+export interface Factory {
+    type: string;
+    create: (spec: telem.Spec) => telem.Telem | null;
+}
+export declare class CompoundTelemFactory {
+    factories: Factory[];
+    type: string;
+    constructor(factories: Factory[]);
+    add(factory: Factory): void;
+    create(props: telem.Spec): telem.Telem | null;
+}
+export declare const factory: (client?: client.Client | undefined) => CompoundTelemFactory;

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

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

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

@@ -0,0 +1,12 @@
+import { type telem } from '../../telem/aether';
+export declare const noopBooleanSinkSpec: telem.BooleanSinkSpec;
+export declare const noopNumericSinkSpec: telem.NumberSinkSPec;
+export declare const noopBooleanSourceSpec: telem.BooleanSourceSpec;
+export declare const noopNumericSourceSpec: telem.NumberSourceSpec;
+export declare const noopStringSourceSpec: telem.StringSourceSpec;
+export declare const noopStatusSourceSpec: telem.StatusSourceSpec;
+export declare const noopColorSourceSpec: telem.ColorSourceSpec;
+export declare class NoopFactory implements telem.Factory {
+    type: string;
+    create(spec: telem.Spec): telem.Telem | null;
+}

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

@@ -0,0 +1,263 @@
+import { type Destructor } from "@synnaxlabs/x";
+import { z } from "zod";
+import { type Factory } from '../../telem/aether/factory';
+import { AbstractSource, type Source, type SourceTransformer, type Telem, type Spec, type SourceSpec, type Sink, type SinkTransformer, AbstractSink, type SinkSpec } from '../../telem/aether/telem';
+export declare const sourcePipelinePropsZ: z.ZodObject<{
+    connections: z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        from: string;
+        to: string;
+    }, {
+        from: string;
+        to: string;
+    }>, "many">;
+    outlet: z.ZodString;
+    segments: z.ZodRecord<z.ZodString, z.ZodObject<{
+        type: z.ZodString;
+        props: z.ZodAny;
+        valueType: z.ZodString;
+        transfer: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodTypeAny, z.ZodTypeAny, ...z.ZodTypeAny[]]>, "many">>;
+        variant: z.ZodLiteral<"source">;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        valueType: string;
+        variant: "source";
+        props?: any;
+        transfer?: any[] | undefined;
+    }, {
+        type: string;
+        valueType: string;
+        variant: "source";
+        props?: any;
+        transfer?: any[] | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    connections: {
+        from: string;
+        to: string;
+    }[];
+    outlet: string;
+    segments: Record<string, {
+        type: string;
+        valueType: string;
+        variant: "source";
+        props?: any;
+        transfer?: any[] | undefined;
+    }>;
+}, {
+    connections: {
+        from: string;
+        to: string;
+    }[];
+    outlet: string;
+    segments: Record<string, {
+        type: string;
+        valueType: string;
+        variant: "source";
+        props?: any;
+        transfer?: any[] | undefined;
+    }>;
+}>;
+export type SourcePipelineProps = z.infer<typeof sourcePipelinePropsZ>;
+export declare class PipelineFactory implements Factory {
+    type: string;
+    factory: Factory;
+    constructor(factory: Factory);
+    create(spec: Spec): Telem | null;
+}
+export declare class SourcePipeline<V> extends AbstractSource<typeof sourcePipelinePropsZ> implements Source<V> {
+    static readonly TYPE = "source-pipeline";
+    schema: z.ZodObject<{
+        connections: z.ZodArray<z.ZodObject<{
+            from: z.ZodString;
+            to: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            from: string;
+            to: string;
+        }, {
+            from: string;
+            to: string;
+        }>, "many">;
+        outlet: z.ZodString;
+        segments: z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodString;
+            props: z.ZodAny;
+            valueType: z.ZodString;
+            transfer: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodTypeAny, z.ZodTypeAny, ...z.ZodTypeAny[]]>, "many">>;
+            variant: z.ZodLiteral<"source">;
+        }, "strip", z.ZodTypeAny, {
+            type: string;
+            valueType: string;
+            variant: "source";
+            props?: any;
+            transfer?: any[] | undefined;
+        }, {
+            type: string;
+            valueType: string;
+            variant: "source";
+            props?: any;
+            transfer?: any[] | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        connections: {
+            from: string;
+            to: string;
+        }[];
+        outlet: string;
+        segments: Record<string, {
+            type: string;
+            valueType: string;
+            variant: "source";
+            props?: any;
+            transfer?: any[] | undefined;
+        }>;
+    }, {
+        connections: {
+            from: string;
+            to: string;
+        }[];
+        outlet: string;
+        segments: Record<string, {
+            type: string;
+            valueType: string;
+            variant: "source";
+            props?: any;
+            transfer?: any[] | undefined;
+        }>;
+    }>;
+    sources: Record<string, Source<any> | SourceTransformer<any, any>>;
+    private get outlet();
+    constructor(props: unknown, factory: Factory);
+    value(): Promise<V>;
+    onChange(handler: () => void): Destructor;
+    cleanup(): void;
+}
+export declare const sourcePipeline: <V extends string>(valueType: V, props: SourcePipelineProps) => SourceSpec<V>;
+export declare const sinkPipelinePropsZ: z.ZodObject<{
+    connections: z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        from: string;
+        to: string;
+    }, {
+        from: string;
+        to: string;
+    }>, "many">;
+    inlet: z.ZodString;
+    segments: z.ZodRecord<z.ZodString, z.ZodObject<{
+        type: z.ZodString;
+        props: z.ZodAny;
+        valueType: z.ZodString;
+        transfer: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodTypeAny, z.ZodTypeAny, ...z.ZodTypeAny[]]>, "many">>;
+        variant: z.ZodLiteral<"sink">;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        valueType: string;
+        variant: "sink";
+        props?: any;
+        transfer?: any[] | undefined;
+    }, {
+        type: string;
+        valueType: string;
+        variant: "sink";
+        props?: any;
+        transfer?: any[] | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    connections: {
+        from: string;
+        to: string;
+    }[];
+    segments: Record<string, {
+        type: string;
+        valueType: string;
+        variant: "sink";
+        props?: any;
+        transfer?: any[] | undefined;
+    }>;
+    inlet: string;
+}, {
+    connections: {
+        from: string;
+        to: string;
+    }[];
+    segments: Record<string, {
+        type: string;
+        valueType: string;
+        variant: "sink";
+        props?: any;
+        transfer?: any[] | undefined;
+    }>;
+    inlet: string;
+}>;
+export type SinkPipelineProps = z.infer<typeof sinkPipelinePropsZ>;
+export declare class SinkPipeline<V> extends AbstractSink<typeof sinkPipelinePropsZ> implements Sink<V> {
+    static readonly TYPE = "sink-pipeline";
+    schema: z.ZodObject<{
+        connections: z.ZodArray<z.ZodObject<{
+            from: z.ZodString;
+            to: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            from: string;
+            to: string;
+        }, {
+            from: string;
+            to: string;
+        }>, "many">;
+        inlet: z.ZodString;
+        segments: z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodString;
+            props: z.ZodAny;
+            valueType: z.ZodString;
+            transfer: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodTypeAny, z.ZodTypeAny, ...z.ZodTypeAny[]]>, "many">>;
+            variant: z.ZodLiteral<"sink">;
+        }, "strip", z.ZodTypeAny, {
+            type: string;
+            valueType: string;
+            variant: "sink";
+            props?: any;
+            transfer?: any[] | undefined;
+        }, {
+            type: string;
+            valueType: string;
+            variant: "sink";
+            props?: any;
+            transfer?: any[] | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        connections: {
+            from: string;
+            to: string;
+        }[];
+        segments: Record<string, {
+            type: string;
+            valueType: string;
+            variant: "sink";
+            props?: any;
+            transfer?: any[] | undefined;
+        }>;
+        inlet: string;
+    }, {
+        connections: {
+            from: string;
+            to: string;
+        }[];
+        segments: Record<string, {
+            type: string;
+            valueType: string;
+            variant: "sink";
+            props?: any;
+            transfer?: any[] | undefined;
+        }>;
+        inlet: string;
+    }>;
+    sinks: Record<string, Sink<any> | SinkTransformer<any, any>>;
+    private get inlet();
+    constructor(props: unknown, factory: Factory);
+    set(value: V): Promise<void>;
+    cleanup(): void;
+}
+export declare const sinkPipeline: <V extends string>(valueType: V, props: SinkPipelineProps) => SinkSpec<V>;

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

@@ -0,0 +1,24 @@
+import { type Instrumentation } from "@synnaxlabs/alamos";
+import { z } from "zod";
+import { aether } from '../../aether/aether';
+import { telem } from '../../telem/aether';
+import { client } from '../../telem/client';
+import { type CompoundTelemFactory } from "./factory";
+export type ProviderState = z.input<typeof providerStateZ>;
+export declare const providerStateZ: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+interface InternalState {
+    instrumentation: Instrumentation;
+}
+export declare class BaseProvider extends aether.Composite<typeof providerStateZ, InternalState> implements telem.Provider {
+    client: client.Proxy;
+    factory: CompoundTelemFactory;
+    static readonly TYPE = "TelemProvider";
+    static readonly stateZ: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    schema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    create<T>(spec: telem.Spec): T;
+    registerFactory(f: telem.Factory): void;
+    equals(other: telem.Provider): boolean;
+    afterUpdate(): void;
+}
+export declare const REGISTRY: aether.ComponentRegistry;
+export {};