@synnaxlabs/pluto 0.12.0

package/dist/menu/external.d.ts

@@ -0,0 +1,3 @@
+export * from '../menu/Item';
+export * from '../menu/Menu';
+export * from '../menu/ContextMenu';

package/dist/menu/index.d.ts

@@ -0,0 +1 @@
+export * as Menu from '../menu/external';

package/dist/menu.cjs

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const external = require("./external-uvx0b-Jw.cjs");
+require("./Item-HWzX7RK2.cjs");
+require("./jsx-runtime-N1ikfypN.cjs");
+require("react");
+require("./css-V3VUT_Js.cjs");
+require("zod");
+require("./Toggle-eOKYw1OT.cjs");
+require("./component-joFaJiQW.cjs");
+require("react-dom");
+require("./Center-ZAcURh-3.cjs");
+require("react-hook-form");
+require("./Link-xlTZan29.cjs");
+exports.Menu = external.external;
+//# sourceMappingURL=menu.cjs.map

package/dist/menu.cjs.map

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

package/dist/menu.js

@@ -0,0 +1,16 @@
+import { e } from "./external-oX1JmOFf.js";
+import "./Item-EDdYN2NK.js";
+import "./jsx-runtime-rX5tAIG2.js";
+import "react";
+import "./css-NTD4Xm8x.js";
+import "zod";
+import "./Toggle-kLunfJtR.js";
+import "./component-k78Jq9I7.js";
+import "react-dom";
+import "./Center-gEKkAkdh.js";
+import "react-hook-form";
+import "./Link-laNlv47N.js";
+export {
+  e as Menu
+};
+//# sourceMappingURL=menu.js.map

package/dist/menu.js.map

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

package/dist/mock/MockGLBufferController.d.ts

@@ -0,0 +1,20 @@
+import { type GLBufferController } from "@synnaxlabs/x";
+import { type Mock } from "vitest";
+export declare class MockGLBufferController implements GLBufferController {
+    ARRAY_BUFFER: number;
+    STATIC_DRAW: number;
+    DYNAMIC_DRAW: number;
+    targets: Record<number, number>;
+    counter: number;
+    buffers: Record<number, ArrayBuffer>;
+    createBufferMock: Mock<[], WebGLBuffer | null>;
+    bufferDataMock: Mock<[number, ArrayBufferLike | number, number]>;
+    bufferSubDataMock: Mock<[number, number, ArrayBufferLike]>;
+    bindBufferMock: Mock<[number, WebGLBuffer | null]>;
+    deleteBufferMock: Mock<[WebGLBuffer | null]>;
+    deleteBuffer(buffer: WebGLBuffer | null): void;
+    createBuffer(): WebGLBuffer | null;
+    bufferData(target: number, dataOrSize: ArrayBufferLike | number, usage: number): void;
+    bindBuffer(target: number, buffer: WebGLBuffer | null): void;
+    bufferSubData(target: number, offset: number, data: ArrayBufferLike): void;
+}

package/dist/mock/setuptests.d.ts

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

package/dist/mosaic/Mosaic.d.ts

@@ -0,0 +1,35 @@
+import { type ReactElement } from "react";
+import { type location } from "@synnaxlabs/x";
+import { type Node } from '../mosaic/types';
+import { Tabs } from '../tabs';
+/** Props for the {@link Mosaic} component */
+export interface MosaicProps extends Omit<Tabs.TabsProps, "onDrop" | "tabs" | "onResize" | "onCreate"> {
+    root: Node;
+    onDrop: (key: number, tabKey: string, loc: location.Location) => void;
+    onResize: (key: number, size: number) => void;
+    onCreate?: (key: number, loc: location.Location, tabKeys?: string[]) => void;
+}
+/***
+ * Mosaic renders a tree of tab panes, with the ability to drag and drop tabs to
+ * different locations in the tree as well as resize the panes (think of your typical
+ * code editor). This component should be used in conjuction with the Mosaic.use hook
+ * to implement the mosaic logic and maintain the state.
+ *
+ * @param props - The props for the Mosaic component. All props not listed below are
+ * passed to the Tabs component of each set of tabs in the mosaic.
+ * @param props.root - The root of the mosaic tree. This prop is provided by the
+ *  Mosaic.use hook.
+ * @param props.onDrop - The callback executed when a tab is dropped in a new location.
+ * This prop is provided by the Mosaic.use hook.
+ * @param props.onResize - The callback executed when a pane is resized. This prop is
+ *  provided by the Mosaic.use hook.
+ */
+export declare const Mosaic: import("react").MemoExoticComponent<(props: MosaicProps) => ReactElement | null>;
+/**
+ * This type should be used when the user wants to drop a tab in the mosaic.
+ * Dropping an item with this signature will call the {@link Mosaic} onDrop handler.
+ */
+export declare const HAUL_DROP_TYPE = "pluto-mosaic-tab-drop";
+/** This type should be used when the user wants to create a new tab in the mosaic.
+Dropping an item with this signature will call the {@link Mosaic} onCreate handler. */
+export declare const HAUL_CREATE_TYPE = "pluto-mosaic-tab-create";

package/dist/mosaic/Mosaic.spec.d.ts

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

package/dist/mosaic/Mosaic.stories.d.ts

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

package/dist/mosaic/external.d.ts

@@ -0,0 +1,4 @@
+export * from '../mosaic/Mosaic';
+export * from '../mosaic/tree';
+export * from '../mosaic/types';
+export * from '../mosaic/use';

package/dist/mosaic/index.d.ts

@@ -0,0 +1 @@
+export * as Mosaic from '../mosaic/external';

package/dist/mosaic/tree.d.ts

@@ -0,0 +1,70 @@
+import { type Node } from '../mosaic/types';
+import { Tabs } from '../tabs';
+import { location } from "@synnaxlabs/x";
+/**
+ * Inserts a tab into a node in the mosaic. If the given key is not found,
+ * the tab is inserted into the closest ancestor. This is to deal
+ * with mosaic garbage collection.
+ *
+ * @param key - The key of the node to insert the tab into.
+ * @param tab - The tab to insert.
+ * @param loc - The location where the tab was 'dropped' relative to the node.
+ */
+export declare const insertTab: (root: Node, tab: Tabs.Tab, loc?: location.Location, key?: number) => Node;
+/**
+ * Automatically selects tabs for all nodes in the mosaic if they don't already have
+ * a selection.
+ *
+ * @param root - The root of the mosaic.
+ * @returns A shallow copy of the root with all nodes having a selection.
+ */
+export declare const autoSelectTabs: (root: Node) => [Node, string[]];
+/**
+ * Removes a tab from the mosaic and performs any necessary garbage collection.
+ *
+ * @param root - The root of the mosaic.
+ * @param tabKey - The key of the tab to remove. This tab must exist in the mosaic.
+ */
+export declare const removeTab: (root: Node, tabKey: string) => [Node, string | null];
+export declare const findSelected: (root: Node) => string | null;
+/**
+ * Marks the given tab as selected.
+ *
+ * @param root - The root of the mosaic.
+ * @param tabKey - The key of the tab to select. This tab must exist in the mosaic.
+ * @returns A shallow copy of the root of the mosaic with the tab selected.
+ */
+export declare const selectTab: (root: Node, tabKey: string) => Node;
+/**
+ * Moves a tab from one node to another.
+ *
+ * @param root - The root of the mosaic.
+ * @param to - The key of the node to move the tab to.
+ * @param tabKey - The key of the tab to move. This tab must exist in the mosaic.
+ * @param loc - The location where the tab was 'dropped' relative to the node.
+ * @returns A shallow copy of the root of the mosaic with the tab moved.
+ */
+export declare const moveTab: (root: Node, tabKey: string, loc: location.Location, to: number) => [Node, string | null];
+/**
+ * Resizes the given mosaic leaf.
+ *
+ * @param root - The root of the mosaic.
+ * @param key  - The key of the leaf to resize.
+ * @param size - The new size distribution for the leaf. Expressed as either a percentage
+ * or a number of pixels of the first child.
+ * @returns A shallow copy of the root of the mosaic with the leaf resized.
+ */
+export declare const resizeNode: (root: Node, key: number, size: number) => Node;
+/**
+ * Sets the title of a tab.
+ *
+ * @param root - The root of the mosaic.
+ * @param tabKey  - The key of the tab to resize.
+ * @param name - The new title of the tab.
+ * @returns A shallow copy of the root of the mosaic with the tab title changed.
+ */
+export declare const renameTab: (root: Node, tabKey: string, name: string) => Node;
+/***
+ * @returns True if the given mosaic node is empty, false otherwise.
+ */
+export declare const isEmpty: (root: Node) => boolean;

package/dist/mosaic/types.d.ts

@@ -0,0 +1,50 @@
+import { type direction } from "@synnaxlabs/x";
+import { type Tabs } from '../tabs';
+/**
+ * Represents the data for a node in the Mosaic binary tree. Nodes can be either leaf
+ * or non-leaf nodes. Leaf nodes represent the edges of the tree, and render tabs in
+ * the mosaic. Non-leaf nodes represent the internal nodes of the tree, and manage
+ * the splitting/sizing of the tree.
+ */
+export interface Node {
+    /**
+     * Key assigns a unique identifier to the leaf. This key is used to identify the
+     * location of the leaf in the tree. Keys are organized in a structure resembling
+     * the following.
+     *                   1
+     *                 /   \
+     *                 2    3
+     *               /  \  / \
+     *              4  5  6  7
+     *
+     * The first child of a node is assigned the key 2 * key, the second child is assigned
+     * the key 2 * key + 1. The root node is assigned the key 1.
+     */
+    key: number;
+    /**
+     * A list of tabs for the node to render. If this value is defined, the node is
+     * considered a leaf, and the tabs will be rendered.
+     */
+    tabs?: Tabs.Tab[];
+    /** The key of the selected tab. This value only needs to be set for leaf nodes. */
+    selected?: string;
+    /** The direction of the split. This value only needs to be set for non-leaf nodes. */
+    direction?: direction.Direction;
+    /**
+     * The first child of the node. If the node is vertical, this is the top child.
+     * If the node is horizontal, this is the left child. This value only needs to be
+     * set for non-leaf nodes.
+     */
+    first?: Node;
+    /**
+     * The last child of the node. If the node is vertical, this is the bottom child.
+     * If the node is horizontal, this is the right child. This value only needs to be
+     * set for non-leaf nodes.
+     */
+    last?: Node;
+    /**
+     * The size of the node as a decimal between 0 and 1. This value only needs to be
+     * set for non-leaf nodes.
+     */
+    size?: number;
+}

package/dist/mosaic/use.d.ts

@@ -0,0 +1,24 @@
+import { type location } from "@synnaxlabs/x";
+import { type Node } from '../mosaic/types';
+export interface UseProps {
+    allowRename?: boolean;
+    initialTree: Node;
+}
+export interface UseReturn {
+    root: Node;
+    onDrop: (key: number, tabKey: string, loc: location.Location) => void;
+    onClose: (tabKey: string) => void;
+    onSelect: (tabKey: string) => void;
+    onResize: (key: number, sizes: number) => void;
+    onRename?: (tabKey: string, name: string) => void;
+}
+/**
+ * The Mosaic.use hook implements the state management and logic for the Mosaic
+ * component. This hook should be used in conjunction with the Mosaic component.
+ *
+ * @param props - The props for the Mosaic.use hook.
+ * @param props.initialValue - The initial root node of the mosaic tree. For
+ * information on what this node should look like, see the {@link Node}
+ * type.
+ */
+export declare const use: ({ allowRename, initialTree }: UseProps) => UseReturn;

package/dist/nav/Bar.d.ts

@@ -0,0 +1,25 @@
+import { type FunctionComponent, type ReactElement } from "react";
+import { location } from "@synnaxlabs/x";
+import { Align } from '../align';
+export interface BarProps extends Omit<Align.SpaceProps, "direction" | "size" | "ref"> {
+    location?: location.Crude;
+    size?: string | number;
+}
+declare const CoreBar: ({ location: location_, size, className, style, ...props }: BarProps) => ReactElement;
+export interface BarContentProps extends Omit<Align.SpaceProps<"div">, "ref"> {
+    bordered?: boolean;
+    className?: string;
+}
+type CoreBarType = typeof CoreBar;
+declare const Start: FunctionComponent<BarContentProps>;
+declare const End: FunctionComponent<BarContentProps>;
+declare const Center: FunctionComponent<BarContentProps>;
+declare const Content: FunctionComponent<BarContentProps>;
+export interface BarType extends CoreBarType {
+    Start: typeof Start;
+    Center: typeof Center;
+    End: typeof End;
+    Content: typeof Content;
+}
+export declare const Bar: BarType;
+export {};

package/dist/nav/Drawer.d.ts

@@ -0,0 +1,24 @@
+import { type ReactElement } from "react";
+import { type BarProps } from '../nav/Bar';
+import { Resize } from '../resize';
+export interface DrawerItem {
+    key: string;
+    content: ReactElement;
+    minSize?: number;
+    maxSize?: number;
+    initialSize?: number;
+}
+export interface UseDrawerProps {
+    initialKey?: string;
+    items: DrawerItem[];
+}
+export interface UseDrawerReturn {
+    activeItem?: DrawerItem;
+    onSelect?: (key: string) => void;
+}
+export interface DrawerProps extends Omit<BarProps, "onSelect" | "onResize">, UseDrawerReturn, Partial<Pick<Resize.SingleProps, "onResize" | "collapseThreshold">> {
+}
+export declare const useDrawer: ({ items, initialKey }: UseDrawerProps) => UseDrawerReturn;
+export declare const Drawer: import("react").FC<DrawerProps & {
+    aetherKey?: string | undefined;
+}>;

package/dist/nav/Nav.spec.d.ts

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

package/dist/nav/Nav.stories.d.ts

@@ -0,0 +1,6 @@
+import type { Meta, StoryFn } from "@storybook/react";
+import { Nav } from '../nav';
+declare const story: Meta<typeof Nav.Bar>;
+export declare const LeftBar: StoryFn<typeof Nav.Bar>;
+export declare const LeftDrawer: StoryFn<typeof Nav.Drawer>;
+export default story;

package/dist/nav/external.d.ts

@@ -0,0 +1,2 @@
+export * from '../nav/Drawer';
+export * from '../nav/Bar';

package/dist/nav/index.d.ts

@@ -0,0 +1 @@
+export * as Nav from '../nav/external';

package/dist/os/Controls/Controls.d.ts

@@ -0,0 +1,7 @@
+import { type ReactElement } from "react";
+import { type runtime } from "@synnaxlabs/x";
+import { type InternalControlsProps } from '../../os/Controls/types';
+export interface ControlsProps extends InternalControlsProps {
+    visibleIfOS?: runtime.OS;
+}
+export declare const Controls: ({ forceOS, visibleIfOS, ...props }: ControlsProps) => ReactElement | null;

package/dist/os/Controls/Controls.stories.d.ts

@@ -0,0 +1,6 @@
+import type { Meta, StoryFn } from "@storybook/react";
+import { OS } from '../../os';
+declare const story: Meta<typeof OS.Controls>;
+export declare const MacOS: StoryFn<typeof OS.Controls>;
+export declare const Windows: StoryFn<typeof OS.Controls>;
+export default story;

package/dist/os/Controls/Mac.d.ts

@@ -0,0 +1,8 @@
+import { type ReactElement } from "react";
+import { type InternalControlsProps } from '../../os/Controls/types';
+export declare const Icon: {
+    Close: import("react/jsx-runtime").JSX.Element;
+    Minimize: import("react/jsx-runtime").JSX.Element;
+    Maximize: import("react/jsx-runtime").JSX.Element;
+};
+export declare const MacOS: ({ disabled, className, focused, onMinimize, onMaximize, onFullscreen, onClose, ...props }: InternalControlsProps) => ReactElement;

package/dist/os/Controls/Windows.d.ts

@@ -0,0 +1,3 @@
+import { type ReactElement } from "react";
+import { type InternalControlsProps } from '../../os/Controls/types';
+export declare const Windows: ({ disabled, onMinimize, onMaximize, onClose, onFullscreen: _, ...props }: InternalControlsProps) => ReactElement;

package/dist/os/Controls/index.d.ts

@@ -0,0 +1,3 @@
+export { Controls } from '../../os/Controls/Controls';
+export type { ControlsProps } from '../../os/Controls/Controls';
+export type { ControlsAction } from '../../os/Controls/types';

package/dist/os/Controls/types.d.ts

@@ -0,0 +1,12 @@
+import { type runtime } from "@synnaxlabs/x";
+import { type Align } from '../../align';
+export type ControlsAction = "close" | "minimize" | "maximize";
+export interface InternalControlsProps extends Align.SpaceProps {
+    forceOS?: runtime.OS;
+    disabled?: ControlsAction[];
+    focused?: boolean;
+    onMinimize?: () => void;
+    onMaximize?: () => void;
+    onFullscreen?: () => void;
+    onClose?: () => void;
+}

package/dist/os/external.d.ts

@@ -0,0 +1,2 @@
+export * from '../os/Controls';
+export * from '../os/use';

package/dist/os/index.d.ts

@@ -0,0 +1 @@
+export * as OS from '../os/external';

package/dist/os/use.d.ts

@@ -0,0 +1,2 @@
+import { runtime } from "@synnaxlabs/x";
+export declare const use: (props?: runtime.GetOSProps) => runtime.OS | undefined;

package/dist/pluto/Pluto.d.ts

@@ -0,0 +1,18 @@
+import { type PropsWithChildren, type ReactElement } from "react";
+import { Alamos } from '../alamos';
+import { Channel } from '../channel';
+import { Haul } from '../haul';
+import { Synnax } from '../synnax';
+import { Theming } from '../theming';
+import { Tooltip } from '../tooltip';
+import { Triggers } from '../triggers';
+export interface ProviderProps extends PropsWithChildren, Partial<Theming.ProviderProps>, Synnax.ProviderProps {
+    workerEnabled?: boolean;
+    workerURL?: URL;
+    alamos?: Alamos.ProviderProps;
+    tooltip?: Tooltip.ConfigProps;
+    triggers?: Triggers.ProviderProps;
+    haul?: Haul.ProviderProps;
+    channelAlias?: Channel.AliasProviderProps;
+}
+export declare const Provider: ({ children, connParams, workerEnabled, workerURL, theme, toggleTheme, setTheme, tooltip, triggers, alamos, haul, channelAlias, }: ProviderProps) => ReactElement;

package/dist/pluto/aether/ pluto.d.ts

@@ -0,0 +1 @@
+export declare const render: () => void;

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

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

package/dist/pluto/defaultWorker.d.ts

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

package/dist/pluto/index.d.ts

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

package/dist/ranger/SelectLabel.d.ts

@@ -0,0 +1,6 @@
+import { type ReactElement } from "react";
+import { type label } from "@synnaxlabs/client";
+import { Select } from '../select';
+export interface SelectLabelsProps extends Omit<Select.MultipleProps<label.Key, label.Label>, "columns" | "searcher"> {
+}
+export declare const SelectLabels: (props: SelectLabelsProps) => ReactElement;

package/dist/ranger/TimeRangeChip.d.ts

@@ -0,0 +1,6 @@
+import { type ReactElement } from "react";
+import { type CrudeTimeRange } from "@synnaxlabs/x";
+export interface TimeRangeChipProps {
+    timeRange: CrudeTimeRange;
+}
+export declare const TimeRangeChip: ({ timeRange }: TimeRangeChipProps) => ReactElement;

package/dist/ranger/TimeRangeChip.stories.d.ts

@@ -0,0 +1,6 @@
+import { type ReactElement } from "react";
+import type { Meta } from "@storybook/react";
+import { TimeRangeChip } from '../ranger/TimeRangeChip';
+declare const story: Meta<typeof TimeRangeChip>;
+export declare const Default: () => ReactElement;
+export default story;

package/dist/ranger/external.d.ts

@@ -0,0 +1,2 @@
+export * from '../ranger/TimeRangeChip';
+export * from '../ranger/SelectLabel';

package/dist/ranger/index.d.ts

@@ -0,0 +1 @@
+export * as Ranger from '../ranger/external';

package/dist/resize/Core.d.ts

@@ -0,0 +1,10 @@
+import { type DetailedHTMLProps, type HTMLAttributes } from "react";
+import { location } from "@synnaxlabs/x";
+export interface CoreProps extends DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement> {
+    location: location.Crude;
+    size: number;
+    onDragStart: (e: React.DragEvent<HTMLDivElement>) => void;
+    sizeUnits?: "px" | "%";
+    showHandle?: boolean;
+}
+export declare const Core: import("react").ForwardRefExoticComponent<Omit<CoreProps, "ref"> & import("react").RefAttributes<unknown>>;

package/dist/resize/Multiple.d.ts

@@ -0,0 +1,63 @@
+import { type RefObject } from "react";
+import { direction, type xy } from "@synnaxlabs/x";
+import { Align } from '../align';
+/** Props for the {@link Resize.Multiple} component. */
+export interface MultipleProps extends Align.SpaceProps {
+    sizeDistribution: number[];
+    onDragHandle: (e: ResizeStartEvent, i: number) => void;
+}
+export type ResizeStartEvent = xy.Client & {
+    preventDefault: () => void;
+};
+/** Props for the {@link Resize.useMultiple} hook. */
+export interface UseMultipleProps {
+    count: number;
+    onResize?: (sizes: number[]) => void;
+    direction?: direction.Crude;
+    initialSizes?: number[];
+    minSize?: number;
+}
+/** Return value of the {@link Resize.useMultiple} hook. */
+export interface UseMultipleReturn {
+    setSize: (i: number, size?: number) => void;
+    props: Pick<MultipleProps, "sizeDistribution" | "onDragHandle" | "direction"> & {
+        ref: RefObject<HTMLDivElement>;
+    };
+}
+interface MultipleState {
+    sizeDistribution: number[];
+    root: number | null;
+}
+/**
+ * A hook that implements the control logic for {@link Resize.Multiple}. This hook
+ * should be used in conjunction with {@link Resize.Multiple}.
+ *
+ * @param props - The a component props.
+ * @param props.count - The number of panels to render. This should be the same as the
+ * number of children passed to {@link Resize.Multiple}.
+ * @param props.onResize - A callback executed when the panels are resized.
+ * @param props.initialSizes - The initial sizes of the panels. This should be an array of
+ * numbers, where each number is the initial size of the corresponding panel either in pixels
+ * or as a decimal percentage. If this array is not provided (or is shorter than the expected length),
+ *  the (remaining) panels will be evenly distributed across the container.
+ * @param props.direction - The direction in which the panels should be draggable. This should
+ * be Default: "x"
+ * @param props.minSize - The smallest size the panels can be resized to. Defaults to 100.
+ *
+ * @returns The props that should be passed to {@link Resize.Multiple} along with a few
+ * utility functions. setSize can be used to manually set the size of a particular panel.
+ */
+export declare const useMultiple: ({ onResize, count, initialSizes, minSize, direction, }: UseMultipleProps) => UseMultipleReturn;
+/**
+ * A set of panels that can be resized within their container. Resize.Multiple must be
+ * used in conjunction with {@link Resize.useMultiple}.
+ *
+ * @param props - The component props. All unused props will be passed to the div
+ * containing the div containing the panels. Generally these props should not be provided
+ * directly, and you should instead spread the props returned from {@link Resize.useMultiple}.
+ * The only exceptions to this are stylistic props (e.g. className, style, etc.) as well
+ * as the `children` prop.
+ */
+export declare const Multiple: import("react").ForwardRefExoticComponent<Omit<MultipleProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+export declare const calculateDiffPercentage: (prev: MultipleState, parentSize: number, dragging: number, clientPos?: number, targetSize?: number) => number;
+export {};

package/dist/resize/Single.d.ts

@@ -0,0 +1,23 @@
+import { type ReactElement } from "react";
+import { box } from "@synnaxlabs/x";
+import { type CoreProps } from '../resize/Core';
+/** Props for the {@link Single} component. */
+export interface SingleProps extends Omit<CoreProps, "showHandle" | "size" | "onResize" | "onDragStart" | "ref"> {
+    initialSize?: number;
+    minSize?: number;
+    maxSize?: number;
+    onResize?: (size: number, box: box.Box) => void;
+    collapseThreshold?: number;
+    onCollapse?: () => void;
+}
+/**
+ * A panel that can be resized in one direction by dragging its handle.
+ *
+ * @param props - The component props. All unused props will be passed to the div
+ * containing the content.
+ * @param props.location - The the location of the panel. The drag handle will be on the opposite side.
+ * @param props.minSize - The smallest size the panel can be resized to.
+ * @param props.maxSize - The largest size the panel can be resized to.
+ * @param props.onResize - A callback executed when the panel is resized.
+ */
+export declare const Single: ({ onCollapse, onResize, location: location_, minSize, maxSize, initialSize, collapseThreshold, className, ...props }: SingleProps) => ReactElement;

package/dist/resize/Single.spec.d.ts

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

package/dist/resize/Single.stories.d.ts

@@ -0,0 +1,6 @@
+import type { Meta, StoryFn } from "@storybook/react";
+import { Resize } from '../resize';
+declare const story: Meta<typeof Resize.Single>;
+export declare const Primary: StoryFn<typeof Resize.Single>;
+export declare const Multiple: StoryFn<typeof Resize.Multiple>;
+export default story;

package/dist/resize/external.d.ts

@@ -0,0 +1,3 @@
+export * from '../resize/Core';
+export * from '../resize/Multiple';
+export * from '../resize/Single';

package/dist/resize/index.d.ts

@@ -0,0 +1 @@
+export * as Resize from '../resize/external';

package/dist/select/Button.d.ts

@@ -0,0 +1,18 @@
+import { type Key, type KeyedRenderableRecord } from "@synnaxlabs/x";
+import { Align } from '../align';
+import { Button as CoreButton } from '../button';
+import { type UseSelectMultipleProps } from '../hooks/useSelectMultiple';
+import { type Input } from '../input';
+import { type RenderProp } from '../util/renderProp';
+export interface ButtonOptionProps<K extends Key = Key, E extends KeyedRenderableRecord<K, E> = KeyedRenderableRecord<K>> extends Pick<CoreButton.ButtonProps, "onClick"> {
+    key: K;
+    selected: boolean;
+    entry: E;
+    title: E[keyof E];
+}
+export interface ButtonProps<K extends Key = Key, E extends KeyedRenderableRecord<K, E> = KeyedRenderableRecord<K>> extends Input.Control<K>, Omit<Align.PackProps, "children" | "onChange">, Pick<UseSelectMultipleProps, "allowNone" | "allowMultiple"> {
+    children?: RenderProp<ButtonOptionProps<K, E>>;
+    entryRenderKey?: keyof E;
+    data: E[];
+}
+export declare const Button: <K extends Key = Key, E extends KeyedRenderableRecord<K, E> = KeyedRenderableRecord<K>>({ children, value, onChange, entryRenderKey, allowNone, allowMultiple, data, ...props }: ButtonProps<K, E>) => JSX.Element;

package/dist/select/ClearButton.d.ts

@@ -0,0 +1,3 @@
+import { type ReactElement } from "react";
+import { Button } from '../button';
+export declare const ClearButton: (props: Omit<Button.IconProps, "children">) => ReactElement;

package/dist/select/Direction.d.ts

@@ -0,0 +1,11 @@
+import { type ReactElement } from "react";
+import { type direction } from "@synnaxlabs/x";
+import { type ButtonProps } from '../select/Button';
+interface Entry {
+    key: direction.Direction;
+    icon: ReactElement;
+}
+export interface DirectionProps extends Omit<ButtonProps<direction.Direction, Entry>, "data" | "entryRenderKey"> {
+}
+export declare const Direction: ({ children, ...props }: DirectionProps) => ReactElement;
+export {};