@synnaxlabs/pluto 0.12.0

package/dist/select/List.d.ts

@@ -0,0 +1,7 @@
+import { type ReactElement } from "react";
+import { type Key, type KeyedRenderableRecord } from "@synnaxlabs/x";
+import { type Dropdown } from '../dropdown';
+import { List as CoreList } from '../list';
+export interface SelectListProps<K extends Key, E extends KeyedRenderableRecord<K, E>> extends CoreList.SelectorProps<K, E>, CoreList.ColumnHeaderProps<K, E>, Pick<Dropdown.DialogProps, "visible"> {
+}
+export declare const List: <K extends Key, E extends KeyedRenderableRecord<K, E>>({ value, onChange, allowMultiple, visible, ...props }: SelectListProps<K, E>) => ReactElement;

package/dist/select/Multiple.d.ts

@@ -0,0 +1,45 @@
+import { type ReactElement } from "react";
+import { type Key, type KeyedRenderableRecord, type AsyncTermSearcher } from "@synnaxlabs/x";
+import { type Color } from '../color';
+import { Dropdown } from '../dropdown';
+import { Input } from '../input';
+import { List as CoreList } from '../list';
+import { type RenderProp } from '../util/renderProp';
+export interface MultipleProps<K extends Key = Key, E extends KeyedRenderableRecord<K, E> = KeyedRenderableRecord<K>> extends Omit<Dropdown.DialogProps, "visible" | "onChange" | "children">, Input.Control<K[]>, Omit<CoreList.ListProps<K, E>, "children">, Pick<Input.TextProps, "placeholder"> {
+    columns?: Array<CoreList.ColumnSpec<K, E>>;
+    searcher?: AsyncTermSearcher<string, K, E>;
+    tagKey?: keyof E | ((e: E) => string | number);
+    renderTag?: RenderProp<SelectMultipleTagProps<K, E>>;
+    onTagDragStart?: (e: React.DragEvent<HTMLDivElement>, key: K) => void;
+    onTagDragEnd?: (e: React.DragEvent<HTMLDivElement>, key: K) => void;
+}
+/**
+ * Allows a user to browse, search for, and select multiple values from a list of
+ * options. It's important to note that Select maintains no internal selection state.
+ * The caller must provide the selected value via the `value` prop and handle any
+ * changes via the `onChange` prop.
+ *
+ * @param props - The props for the component. Any additional props will be passed to
+ * the input group containing the selection input and the selected tags.
+ * @param props.data - The data to be used to populate the select options.
+ * @param props.columns - The columns to be used to render the select options in the
+ * dropdown. See the {@link ListColumn} type for more details on how to configure
+ * columns.
+ * @param props.tagKey - The option field rendered for each tag when selected in the
+ * input group. Defaults to "key".
+ * @param props.location - Whether to render the dropdown above or below the select
+ * component. Defaults to "below".
+ * @param props.onChange - The callback to be invoked when the selected value changes.
+ * @param props.value - The currently selected value.
+ */
+export declare const Multiple: <K extends Key = Key, E extends KeyedRenderableRecord<K, E> = KeyedRenderableRecord<K>>({ onChange, value, location, className, data, columns, tagKey, emptyContent, searcher, renderTag, placeholder, onTagDragStart, onTagDragEnd, style, ...props }: MultipleProps<K, E>) => ReactElement;
+interface SelectMultipleTagProps<K extends Key, E extends KeyedRenderableRecord<K, E>> {
+    key: K;
+    tagKey: keyof E | ((e: E) => string | number);
+    entry: E;
+    color?: Color.Crude;
+    onClose?: () => void;
+    onDragStart: (e: React.DragEvent<HTMLDivElement>) => void;
+    onDragEnd?: (e: React.DragEvent<HTMLDivElement>) => void;
+}
+export {};

package/dist/select/Select.spec.d.ts

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

package/dist/select/Select.stories.d.ts

@@ -0,0 +1,14 @@
+import { ReactElement } from "react";
+import type { Meta, StoryFn } from "@storybook/react";
+import { Select } from '../select';
+declare const story: Meta<typeof Select.Multiple>;
+interface SampleRecord {
+    key: string;
+    sampleRate: number;
+    name: string;
+    dataType: string;
+}
+export declare const Multiple: () => ReactElement;
+declare const Template: (props: Omit<Select.SingleProps<string, SampleRecord>, "value" | "onChange">) => ReactElement;
+export declare const Default: StoryFn<typeof Template>;
+export default story;

package/dist/select/Single.d.ts

@@ -0,0 +1,37 @@
+import { type ReactElement } from "react";
+import { type AsyncTermSearcher, type Key, type KeyedRenderableRecord } from "@synnaxlabs/x";
+import { Dropdown } from '../dropdown';
+import { Input } from '../input';
+import { List as CoreList } from '../list';
+export interface SingleProps<K extends Key = Key, E extends KeyedRenderableRecord<K, E> = KeyedRenderableRecord<K>> extends Omit<Dropdown.DialogProps, "onChange" | "visible" | "children">, Input.Control<K>, Omit<CoreList.ListProps<K, E>, "children">, Pick<Input.TextProps, "variant"> {
+    tagKey?: keyof E | ((e: E) => string | number);
+    columns?: Array<CoreList.ColumnSpec<K, E>>;
+    inputProps?: Omit<Input.TextProps, "onChange">;
+    searcher?: AsyncTermSearcher<string, K, E>;
+    allowClear?: boolean;
+}
+/**
+ * Allows a user to browse, search for, and select a value from a list of options.
+ * It's important to note that Select maintains no internal selection state. The caller
+ * must provide the selected value via the `value` prop and handle any changes via the
+ * `onChange` prop.
+ *
+ * @param props - The props for the component. Any additional props will be passed to the
+ * underlying input element.
+ * @param props.data - The data to be used to populate the select options.
+ * @param props.columns - The columns to be used to render the select options in the
+ * dropdown. See the {@link ListColumn} type for more details on available options.
+ * @param props.tagKey - The option field rendered when selected. Defaults to "key".
+ * @param props.location - Whether to render the dropdown above or below the select
+ * component. Defaults to "below".
+ * @param props.onChange - The callback to be invoked when the selected value changes.
+ * @param props.value - The currently selected value.
+ */
+export declare const Single: <K extends Key = Key, E extends KeyedRenderableRecord<K, E> = KeyedRenderableRecord<K>>({ onChange, value, tagKey, columns, data, emptyContent, inputProps, allowClear, searcher, className, variant, ...props }: SingleProps<K, E>) => ReactElement;
+export interface SelectInputProps<K extends Key, E extends KeyedRenderableRecord<K, E>> extends Omit<Input.TextProps, "value"> {
+    tagKey: keyof E | ((e: E) => string | number);
+    selected: E | null;
+    visible: boolean;
+    debounceSearch?: number;
+    allowClear?: boolean;
+}

package/dist/select/external.d.ts

@@ -0,0 +1,4 @@
+export * from '../select/Multiple';
+export * from '../select/Single';
+export * from '../select/Button';
+export * from '../select/Direction';

package/dist/select/index.d.ts

@@ -0,0 +1 @@
+export * as Select from '../select/external';

package/dist/state/index.d.ts

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

package/dist/state/state.d.ts

@@ -0,0 +1,27 @@
+import { type Primitive, type UnknownRecord } from "@synnaxlabs/x";
+export type State = Primitive | UnknownRecord;
+export type SetFunc<S, PS = S> = (prev: PS) => S;
+export declare const isSetter: <S extends State>(arg: SetArg<S, S>) => arg is SetFunc<S, S>;
+export type SetArg<S extends State, PS = S> = S | SetFunc<S, PS>;
+export type Set<S extends State> = (value: SetArg<S>) => void;
+export type PureSet<S extends State> = (value: S) => void;
+export type Initial<S extends State> = S | (() => S);
+export declare const executeSetter: <S extends State>(setter: SetArg<S, S>, prev: S) => S;
+export declare const executeInitialSetter: <S extends State>(setter: Initial<S>) => S;
+export declare const isInitialSetter: <S extends State>(arg: Initial<S>) => arg is () => S;
+export type UseReturn<S extends State> = [S, Set<S>];
+export type Use = <S extends State>(initial: Initial<S>) => UseReturn<S>;
+export type PureUseReturn<S extends State> = [S, PureSet<S>];
+export type PureUse<S extends State> = (initial: S) => PureUseReturn<S>;
+export interface UsePassthroughProps<S extends State> {
+    initial: Initial<S>;
+    value?: S;
+    onChange?: Set<S>;
+}
+export declare const usePassthrough: <S extends State>({ initial, value, onChange, }: UsePassthroughProps<S>) => UseReturn<S>;
+export interface UsePurePassthroughProps<S extends State> {
+    initial: Initial<S>;
+    value?: S;
+    onChange?: PureSet<S>;
+}
+export declare const usePurePassthrough: <S extends State>({ initial, value, onChange, }: UsePurePassthroughProps<S>) => PureUseReturn<S>;

package/dist/status/Aggregator.d.ts

@@ -0,0 +1,27 @@
+import { type PropsWithChildren, useContext as reactUseContext } from "react";
+import { TimeSpan } from "@synnaxlabs/x";
+import { type z } from "zod";
+import { status } from '../status/aether';
+interface ContextValue extends z.infer<typeof status.aggregatorStateZ> {
+    add: (status: status.CrudeSpec) => void;
+}
+export declare const useContext: typeof reactUseContext;
+export interface AggregatorProps extends PropsWithChildren {
+    maxHistory?: number;
+}
+export declare const Aggregator: import("react").FC<AggregatorProps & {
+    aetherKey?: string | undefined;
+}>;
+export declare const useAggregator: () => ContextValue["add"];
+export interface UseNotificationsProps {
+    expiration?: TimeSpan;
+}
+interface Notification extends status.Spec {
+    count: number;
+}
+export interface UseNotificationsReturn {
+    statuses: Notification[];
+    silence: (key: string) => void;
+}
+export declare const useNotifications: (props?: UseNotificationsProps) => UseNotificationsReturn;
+export {};

package/dist/status/Circle.d.ts

@@ -0,0 +1,6 @@
+import { type ReactElement } from "react";
+import { type status } from '../status/aether';
+export interface CircleProps {
+    variant: status.Variant;
+}
+export declare const Circle: ({ variant }: CircleProps) => ReactElement;

package/dist/status/Text.d.ts

@@ -0,0 +1,21 @@
+import { type ReactElement } from "react";
+import { type Variant } from '../status/aether/types';
+import { Text as BaseText } from '../text';
+export interface TextDigest {
+    variant: Variant;
+    children?: string | number;
+}
+export interface TextProps extends Omit<BaseText.TextProps, "level" | "wrap">, TextDigest {
+    level?: BaseText.Level;
+    hideIcon?: boolean;
+}
+declare const CoreText: ({ variant, level, hideIcon, className, ...props }: TextProps) => ReactElement;
+export interface TextCenteredProps extends TextProps {
+}
+declare const TextCentered: ({ style, ...props }: TextCenteredProps) => ReactElement;
+type CoreTextType = typeof CoreText;
+export interface TextType extends CoreTextType {
+    Centered: typeof TextCentered;
+}
+export declare const Text: TextType;
+export {};

package/dist/status/aether/aggregator.d.ts

@@ -0,0 +1,86 @@
+import { TimeStamp } from "@synnaxlabs/x";
+import { z } from "zod";
+import { aether } from '../../aether/aether';
+import { type CrudeSpec } from '../../status/aether/types';
+export declare const aggregatorStateZ: z.ZodObject<{
+    statuses: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        variant: z.ZodEnum<["success", "error", "warning", "info", "loading", "disabled"]>;
+        message: z.ZodString;
+        time: z.ZodUnion<[z.ZodEffects<z.ZodType<Number, z.ZodTypeDef, Number>, TimeStamp, Number>, z.ZodEffects<z.ZodNumber, TimeStamp, number>, z.ZodType<TimeStamp, z.ZodTypeDef, TimeStamp>]>;
+        data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        key: string;
+        time: TimeStamp;
+        variant: "disabled" | "loading" | "error" | "success" | "warning" | "info";
+        data?: Record<string, unknown> | undefined;
+    }, {
+        message: string;
+        key: string;
+        time: (number | Number | TimeStamp) & (number | Number | TimeStamp | undefined);
+        variant: "disabled" | "loading" | "error" | "success" | "warning" | "info";
+        data?: Record<string, unknown> | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    statuses: {
+        message: string;
+        key: string;
+        time: TimeStamp;
+        variant: "disabled" | "loading" | "error" | "success" | "warning" | "info";
+        data?: Record<string, unknown> | undefined;
+    }[];
+}, {
+    statuses: {
+        message: string;
+        key: string;
+        time: (number | Number | TimeStamp) & (number | Number | TimeStamp | undefined);
+        variant: "disabled" | "loading" | "error" | "success" | "warning" | "info";
+        data?: Record<string, unknown> | undefined;
+    }[];
+}>;
+export type Aggregate = (spec: CrudeSpec) => void;
+export declare class Aggregator extends aether.Composite<typeof aggregatorStateZ> {
+    static readonly TYPE: string;
+    schema: z.ZodObject<{
+        statuses: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            variant: z.ZodEnum<["success", "error", "warning", "info", "loading", "disabled"]>;
+            message: z.ZodString;
+            time: z.ZodUnion<[z.ZodEffects<z.ZodType<Number, z.ZodTypeDef, Number>, TimeStamp, Number>, z.ZodEffects<z.ZodNumber, TimeStamp, number>, z.ZodType<TimeStamp, z.ZodTypeDef, TimeStamp>]>;
+            data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "strip", z.ZodTypeAny, {
+            message: string;
+            key: string;
+            time: TimeStamp;
+            variant: "disabled" | "loading" | "error" | "success" | "warning" | "info";
+            data?: Record<string, unknown> | undefined;
+        }, {
+            message: string;
+            key: string;
+            time: (number | Number | TimeStamp) & (number | Number | TimeStamp | undefined);
+            variant: "disabled" | "loading" | "error" | "success" | "warning" | "info";
+            data?: Record<string, unknown> | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        statuses: {
+            message: string;
+            key: string;
+            time: TimeStamp;
+            variant: "disabled" | "loading" | "error" | "success" | "warning" | "info";
+            data?: Record<string, unknown> | undefined;
+        }[];
+    }, {
+        statuses: {
+            message: string;
+            key: string;
+            time: (number | Number | TimeStamp) & (number | Number | TimeStamp | undefined);
+            variant: "disabled" | "loading" | "error" | "success" | "warning" | "info";
+            data?: Record<string, unknown> | undefined;
+        }[];
+    }>;
+    afterUpdate(): void;
+    add(spec: CrudeSpec): void;
+}
+export declare const useAggregate: (ctx: aether.Context) => Aggregate;
+export declare const REGISTRY: aether.ComponentRegistry;

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

@@ -0,0 +1,2 @@
+export * from '../../status/aether/types';
+export * from '../../status/aether/aggregator';

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

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

package/dist/status/aether/types.d.ts

@@ -0,0 +1,26 @@
+import { type Optional, TimeStamp } from "@synnaxlabs/x";
+import { z } from "zod";
+export declare const VARIANTS: readonly ["success", "error", "warning", "info", "loading", "disabled"];
+export declare const variantZ: z.ZodEnum<["success", "error", "warning", "info", "loading", "disabled"]>;
+export type Variant = z.infer<typeof variantZ>;
+export declare const specZ: z.ZodObject<{
+    key: z.ZodString;
+    variant: z.ZodEnum<["success", "error", "warning", "info", "loading", "disabled"]>;
+    message: z.ZodString;
+    time: z.ZodUnion<[z.ZodEffects<z.ZodType<Number, z.ZodTypeDef, Number>, TimeStamp, Number>, z.ZodEffects<z.ZodNumber, TimeStamp, number>, z.ZodType<TimeStamp, z.ZodTypeDef, TimeStamp>]>;
+    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    key: string;
+    time: TimeStamp;
+    variant: "disabled" | "loading" | "error" | "success" | "warning" | "info";
+    data?: Record<string, unknown> | undefined;
+}, {
+    message: string;
+    key: string;
+    time: (number | Number | TimeStamp) & (number | Number | TimeStamp | undefined);
+    variant: "disabled" | "loading" | "error" | "success" | "warning" | "info";
+    data?: Record<string, unknown> | undefined;
+}>;
+export type Spec = z.infer<typeof specZ>;
+export type CrudeSpec = Optional<Spec, "time" | "key">;

package/dist/status/colors.d.ts

@@ -0,0 +1,2 @@
+import { type status } from '../status/aether';
+export declare const variantColors: Record<status.Variant, string>;

package/dist/status/external.d.ts

@@ -0,0 +1,4 @@
+export * from '../status/Text';
+export * from '../status/aether/types';
+export * from '../status/Aggregator';
+export * from '../status/Circle';

package/dist/status/index.d.ts

@@ -0,0 +1 @@
+export * as Status from '../status/external';