@synnaxlabs/pluto 0.12.0

package/dist/vis/diagram/types.d.ts

@@ -0,0 +1,71 @@
+import { xy } from "@synnaxlabs/x";
+import type * as rf from "reactflow";
+import { type Color } from '../../color';
+import { type connector } from '../../vis/diagram/edge/connector';
+/** The current viewport state of the diagram */
+export interface Viewport {
+    position: xy.XY;
+    /**
+     * A decimal of the current diagram zoom. Larger values represent magnification.
+     */
+    zoom: number;
+}
+/** Pluto specific info passed to the 'data' attribute on rf.Edge */
+export interface RFEdgeData {
+    /** The color of the edge. */
+    color: Color.Crude;
+    /** A list of segments representing the structure of the edge connector. */
+    segments: connector.Segment[];
+}
+/** The properties for an edge within a diagram. */
+export interface Edge extends RFEdgeData {
+    /** A unique key for identifying the edge within the diagram. */
+    key: string;
+    /** The key of the source node for the edge. */
+    source: string;
+    /** The key of the target node for the edge. */
+    target: string;
+    /** Whether the edge is currently selected. */
+    selected: boolean;
+    /**
+     * The id of handle on the source node that the edge is connected to. Note that this
+     * id is unique only within the source node.
+     */
+    sourceHandle?: string | null;
+    /**
+     * The id of the handle on the target node that the edge is connected to. Note that this id
+     * is unique only within the target node.
+     */
+    targetHandle?: string | null;
+}
+/** The properties for a node within a diagram. */
+export interface Node {
+    /** A unique key for identifying the node within the diagram. */
+    key: string;
+    /** The XY coordinate of the top left corner of the node. Unscaled by the viewport. */
+    position: xy.XY;
+    /** Whether the node is currently selected. */
+    selected?: boolean;
+    /** An optional z-index for the node. */
+    zIndex?: number;
+}
+/**
+ * Translates nodes from their pluto representation to their react-flow representation.
+ */
+export declare const translateNodesForward: (nodes: Node[]) => rf.Node[];
+/** Translates edges from their pluto representation to their react-flow representation. */
+export declare const translateEdgesForward: (edges: Edge[]) => Array<rf.Edge<RFEdgeData>>;
+/** Translates nodes from their react-flow representation to their pluto representation. */
+export declare const translateNodesBackward: (nodes: rf.Node[]) => Node[];
+/** Translates edges from their react-flow representation to their pluto representation */
+export declare const translateEdgesBackward: (edges: Array<rf.Edge<RFEdgeData>>, defaultData?: RFEdgeData) => Edge[];
+/** Translates the diagram viewport from its pluto representation to its react-flow representation */
+export declare const translateViewportForward: (viewport: Viewport) => rf.Viewport;
+/** Translates the diagram viewport from its react-flow representation to its pluto representation */
+export declare const translateViewportBackward: (viewport: rf.Viewport) => Viewport;
+/**
+ * Executes the provided callback against the react-flow representation of the given
+ * nodes, then converts
+ */
+export declare const nodeConverter: (nodes: Node[], f: (nodes: rf.Node[]) => rf.Node[]) => Node[];
+export declare const edgeConverter: (edges: Edge[], f: (edges: rf.Edge[]) => rf.Edge[]) => Edge[];

package/dist/vis/diagram/util.d.ts

@@ -0,0 +1,21 @@
+import { xy, box, location } from "@synnaxlabs/x";
+import { type ReactFlowInstance } from "reactflow";
+export declare const selectNode: (key: string) => HTMLDivElement;
+export declare const selectNodeBox: (flow: ReactFlowInstance, key: string) => box.Box;
+export declare const selectNodeLayout: (key: string, flow: ReactFlowInstance) => NodeLayout;
+export declare class HandleLayout {
+    node_: NodeLayout | null;
+    position: xy.XY;
+    orientation: location.Outer;
+    constructor(position: xy.XY, orientation: location.Outer);
+    set node(node: NodeLayout);
+    get node(): NodeLayout;
+    get absolutePosition(): xy.XY;
+}
+export declare class NodeLayout {
+    key: string;
+    box: box.Box;
+    handles: HandleLayout[];
+    constructor(key: string, box: box.Box, handles: HandleLayout[]);
+    static fromFlow(key: string, flow: ReactFlowInstance): NodeLayout;
+}

package/dist/vis/draw2d/canvas.d.ts

@@ -0,0 +1,106 @@
+import { scale } from "@synnaxlabs/x";
+export declare class SugaredOffscreenCanvasRenderingContext2D implements OffscreenCanvasRenderingContext2D {
+    readonly scale_: scale.XY;
+    readonly wrapped: OffscreenCanvasRenderingContext2D;
+    constructor(wrap: OffscreenCanvasRenderingContext2D, scale_?: scale.XY);
+    reset(): void;
+    applyScale(scale: scale.XY): SugaredOffscreenCanvasRenderingContext2D;
+    get canvas(): OffscreenCanvas;
+    get miterLimit(): number;
+    set miterLimit(value: number);
+    get globalAlpha(): number;
+    set globalAlpha(value: number);
+    get globalCompositeOperation(): GlobalCompositeOperation;
+    set globalCompositeOperation(value: GlobalCompositeOperation);
+    get fillStyle(): string | CanvasGradient | CanvasPattern;
+    set fillStyle(value: string | CanvasGradient | CanvasPattern);
+    get strokeStyle(): string | CanvasGradient | CanvasPattern;
+    set strokeStyle(value: string | CanvasGradient | CanvasPattern);
+    commit(): void;
+    drawImage(image: CanvasImageSource, dx: number, dy: number): void;
+    drawImage(image: CanvasImageSource, dx: number, dy: number, dw: number, dh: number): void;
+    drawImage(image: CanvasImageSource, sx: number, sy: number, sw: number, sh: number, dx: number, dy: number, dw: number, dh: number): void;
+    drawImage(image: CanvasImageSource, dx: number, dy: number): void;
+    drawImage(image: CanvasImageSource, dx: number, dy: number, dw: number, dh: number): void;
+    drawImage(image: CanvasImageSource, sx: number, sy: number, sw: number, sh: number, dx: number, dy: number, dw: number, dh: number): void;
+    beginPath(): void;
+    clip(fillRule?: CanvasFillRule | undefined): void;
+    clip(path: Path2D, fillRule?: CanvasFillRule | undefined): void;
+    fill(fillRule?: CanvasFillRule | undefined): void;
+    fill(path: Path2D, fillRule?: CanvasFillRule | undefined): void;
+    isPointInPath(x: number, y: number, fillRule?: CanvasFillRule | undefined): boolean;
+    isPointInPath(path: Path2D, x: number, y: number, fillRule?: CanvasFillRule | undefined): boolean;
+    isPointInStroke(x: number, y: number): boolean;
+    isPointInStroke(path: Path2D, x: number, y: number): boolean;
+    stroke(): void;
+    stroke(path: Path2D): void;
+    createConicGradient(startAngle: number, x: number, y: number): CanvasGradient;
+    createLinearGradient(x0: number, y0: number, x1: number, y1: number): CanvasGradient;
+    createPattern(image: CanvasImageSource, repetition: string | null): CanvasPattern | null;
+    createRadialGradient(x0: number, y0: number, r0: number, x1: number, y1: number, r1: number): CanvasGradient;
+    get filter(): string;
+    set filter(value: string);
+    createImageData(sw: number, sh: number, settings?: ImageDataSettings | undefined): ImageData;
+    createImageData(imagedata: ImageData): ImageData;
+    getImageData(sx: number, sy: number, sw: number, sh: number, settings?: ImageDataSettings | undefined): ImageData;
+    putImageData(imagedata: ImageData, dx: number, dy: number): void;
+    putImageData(imagedata: ImageData, dx: number, dy: number, dirtyX: number, dirtyY: number, dirtyWidth: number, dirtyHeight: number): void;
+    get imageSmoothingEnabled(): boolean;
+    set imageSmoothingEnabled(value: boolean);
+    get imageSmoothingQuality(): ImageSmoothingQuality;
+    set imageSmoothingQuality(value: ImageSmoothingQuality);
+    arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, counterclockwise?: boolean | undefined): void;
+    arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): void;
+    bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): void;
+    closePath(): void;
+    ellipse(x: number, y: number, radiusX: number, radiusY: number, rotation: number, startAngle: number, endAngle: number, counterclockwise?: boolean | undefined): void;
+    lineTo(x: number, y: number): void;
+    moveTo(x: number, y: number): void;
+    quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void;
+    rect(x: number, y: number, w: number, h: number): void;
+    roundRect(x: number, y: number, w: number, h: number, radii?: number | DOMPointInit | Array<number | DOMPointInit> | undefined): void;
+    get lineCap(): CanvasLineCap;
+    set lineCap(value: CanvasLineCap);
+    get lineDashOffset(): number;
+    set lineDashOffset(value: number);
+    get lineJoin(): CanvasLineJoin;
+    set lineJoin(value: CanvasLineJoin);
+    get lineWidth(): number;
+    set lineWidth(value: number);
+    getLineDash(): number[];
+    setLineDash(segments: number[]): void;
+    setLineDash(segments: Iterable<number>): void;
+    clearRect(x: number, y: number, w: number, h: number): void;
+    fillRect(x: number, y: number, w: number, h: number): void;
+    strokeRect(x: number, y: number, w: number, h: number): void;
+    get shadowBlur(): number;
+    set shadowBlur(value: number);
+    get shadowColor(): string;
+    set shadowColor(value: string);
+    get shadowOffsetX(): number;
+    set shadowOffsetX(value: number);
+    get shadowOffsetY(): number;
+    restore(): void;
+    save(): void;
+    fillText(text: string, x: number, y: number, maxWidth?: number | undefined): void;
+    measureText(text: string): TextMetrics;
+    strokeText(text: string, x: number, y: number, maxWidth?: number | undefined): void;
+    get direction(): CanvasDirection;
+    set direction(value: CanvasDirection);
+    get font(): string;
+    set font(value: string);
+    get fontKerning(): CanvasFontKerning;
+    set fontKerning(value: CanvasFontKerning);
+    get textAlign(): CanvasTextAlign;
+    set textAlign(value: CanvasTextAlign);
+    get textBaseline(): CanvasTextBaseline;
+    set textBaseline(value: CanvasTextBaseline);
+    getTransform(): DOMMatrix;
+    resetTransform(): void;
+    rotate(angle: number): void;
+    scale(x: number, y: number): void;
+    setTransform(a: number, b: number, c: number, d: number, e: number, f: number): void;
+    setTransform(transform?: DOMMatrix2DInit | undefined): void;
+    transform(a: number, b: number, c: number, d: number, e: number, f: number): void;
+    translate(x: number, y: number): void;
+}

package/dist/vis/draw2d/index.d.ts

@@ -0,0 +1,60 @@
+import { box, direction, xy, type dimensions } from "@synnaxlabs/x";
+import { type color } from '../../color/core';
+import { type Level } from '../../text/types';
+import { type theming } from '../../theming/aether';
+export interface Draw2DLineProps {
+    stroke: color.Color;
+    lineWidth: number;
+    lineDash: number;
+    start: xy.XY;
+    end: xy.XY;
+}
+export interface Draw2DRuleProps extends Omit<Draw2DLineProps, "start" | "end"> {
+    direction: direction.Direction;
+    region: box.Box;
+    position: number;
+}
+export interface Draw2DCircleProps {
+    fill: color.Color;
+    radius: number;
+    position: xy.XY;
+}
+export interface Draw2DContainerProps {
+    region: box.Box;
+    bordered?: boolean;
+    rounded?: boolean;
+    borderColor?: color.Color;
+    borderRadius?: number;
+    borderWidth?: number;
+    backgroundColor?: color.Color;
+}
+export interface DrawTextProps {
+    text: string;
+    position: xy.XY;
+    level: Level;
+    direction: direction.Direction;
+}
+export interface DrawTextInCenterProps extends Omit<DrawTextProps, "position" | "direction"> {
+    box: box.Box;
+}
+export interface Draw2DMeasureTextContainerProps {
+    text: string[];
+    direction: direction.Direction;
+    level: Level;
+    spacing?: number;
+}
+export interface Draw2DTextContainerProps extends Omit<Draw2DContainerProps, "region">, Draw2DMeasureTextContainerProps {
+    position: xy.XY;
+}
+export declare class Draw2D {
+    readonly canvas: OffscreenCanvasRenderingContext2D;
+    readonly theme: theming.Theme;
+    constructor(canvas: OffscreenCanvasRenderingContext2D, theme: theming.Theme);
+    rule({ direction, region, position, ...props }: Draw2DRuleProps): void;
+    line({ stroke, lineWidth, lineDash, start, end }: Draw2DLineProps): void;
+    circle({ fill, radius, position }: Draw2DCircleProps): void;
+    container({ region, bordered, rounded, borderColor, borderRadius, borderWidth, backgroundColor, }: Draw2DContainerProps): void;
+    textContainer(props: Draw2DTextContainerProps): void;
+    spacedTextDrawF({ text, direction: d, spacing, level, }: Draw2DMeasureTextContainerProps): [dimensions.Dimensions, (base: xy.XY) => void];
+    drawTextInCenter({ text, box: b, level }: DrawTextInCenterProps): void;
+}

package/dist/vis/eraser/aether/eraser.d.ts

@@ -0,0 +1,194 @@
+import { z } from "zod";
+import { aether } from '../../../aether/aether';
+import { render } from '../../../vis/render';
+export declare const eraserStateZ: z.ZodObject<{
+    region: z.ZodObject<{
+        one: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            x: number;
+            y: number;
+        }, {
+            x: number;
+            y: number;
+        }>;
+        two: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            x: number;
+            y: number;
+        }, {
+            x: number;
+            y: number;
+        }>;
+        root: z.ZodObject<{
+            x: z.ZodEnum<["left", "right"]>;
+            y: z.ZodEnum<["top", "bottom"]>;
+        }, "strip", z.ZodTypeAny, {
+            x: "left" | "right";
+            y: "bottom" | "top";
+        }, {
+            x: "left" | "right";
+            y: "bottom" | "top";
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        one: {
+            x: number;
+            y: number;
+        };
+        two: {
+            x: number;
+            y: number;
+        };
+        root: {
+            x: "left" | "right";
+            y: "bottom" | "top";
+        };
+    }, {
+        one: {
+            x: number;
+            y: number;
+        };
+        two: {
+            x: number;
+            y: number;
+        };
+        root: {
+            x: "left" | "right";
+            y: "bottom" | "top";
+        };
+    }>;
+}, "strip", z.ZodTypeAny, {
+    region: {
+        one: {
+            x: number;
+            y: number;
+        };
+        two: {
+            x: number;
+            y: number;
+        };
+        root: {
+            x: "left" | "right";
+            y: "bottom" | "top";
+        };
+    };
+}, {
+    region: {
+        one: {
+            x: number;
+            y: number;
+        };
+        two: {
+            x: number;
+            y: number;
+        };
+        root: {
+            x: "left" | "right";
+            y: "bottom" | "top";
+        };
+    };
+}>;
+interface InternalState {
+    render: render.Context;
+}
+export declare class Eraser extends aether.Leaf<typeof eraserStateZ, InternalState> {
+    static readonly TYPE = "eraser";
+    schema: z.ZodObject<{
+        region: z.ZodObject<{
+            one: z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                x: number;
+                y: number;
+            }, {
+                x: number;
+                y: number;
+            }>;
+            two: z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                x: number;
+                y: number;
+            }, {
+                x: number;
+                y: number;
+            }>;
+            root: z.ZodObject<{
+                x: z.ZodEnum<["left", "right"]>;
+                y: z.ZodEnum<["top", "bottom"]>;
+            }, "strip", z.ZodTypeAny, {
+                x: "left" | "right";
+                y: "bottom" | "top";
+            }, {
+                x: "left" | "right";
+                y: "bottom" | "top";
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            one: {
+                x: number;
+                y: number;
+            };
+            two: {
+                x: number;
+                y: number;
+            };
+            root: {
+                x: "left" | "right";
+                y: "bottom" | "top";
+            };
+        }, {
+            one: {
+                x: number;
+                y: number;
+            };
+            two: {
+                x: number;
+                y: number;
+            };
+            root: {
+                x: "left" | "right";
+                y: "bottom" | "top";
+            };
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        region: {
+            one: {
+                x: number;
+                y: number;
+            };
+            two: {
+                x: number;
+                y: number;
+            };
+            root: {
+                x: "left" | "right";
+                y: "bottom" | "top";
+            };
+        };
+    }, {
+        region: {
+            one: {
+                x: number;
+                y: number;
+            };
+            two: {
+                x: number;
+                y: number;
+            };
+            root: {
+                x: "left" | "right";
+                y: "bottom" | "top";
+            };
+        };
+    }>;
+    private readonly eraser;
+    afterUpdate(): void;
+    render(): Promise<render.Cleanup>;
+}
+export declare const REGISTRY: aether.ComponentRegistry;
+export {};

package/dist/vis/eraser/aether/index.d.ts

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

package/dist/vis/eraser/index.d.ts

@@ -0,0 +1 @@
+export * as Eraser from '../../vis/eraser/use';

package/dist/vis/eraser/use.d.ts

@@ -0,0 +1,11 @@
+import { type PropsWithChildren } from "react";
+import { box } from "@synnaxlabs/x";
+export interface UseProps {
+    aetherKey: string;
+}
+export declare const use: ({ aetherKey }: UseProps) => (region: box.Box) => void;
+export interface EraserProps extends PropsWithChildren {
+}
+export declare const Eraser: import("react").FC<EraserProps & {
+    aetherKey?: string | undefined;
+}>;

package/dist/vis/legend/Container.d.ts

@@ -0,0 +1,11 @@
+import { type CSSProperties, type ReactElement, type RefObject } from "react";
+import { xy } from "@synnaxlabs/x";
+import { Align } from '../../align';
+import { type OptionalControl } from '../../input/types';
+export interface ContainerProps extends Omit<Align.SpaceProps, "onChange">, Partial<OptionalControl<xy.XY>> {
+    dragEnabled?: boolean;
+}
+type CSSPosition = Partial<Pick<CSSProperties, "left" | "right" | "top" | "bottom" | "display">>;
+export declare const intelligentPosition: (pos: xy.XY, ref: RefObject<HTMLDivElement>) => CSSPosition;
+export declare const Container: import("react").MemoExoticComponent<({ className, value, onChange, style, draggable, ...props }: ContainerProps) => ReactElement | null>;
+export {};

package/dist/vis/legend/Simple.d.ts

@@ -0,0 +1,16 @@
+import { type ReactElement } from "react";
+import { Color } from '../../color';
+import { type ContainerProps } from '../../vis/legend/Container';
+interface SimpleEntry {
+    key: string;
+    label: string;
+    color: Color.Crude;
+}
+export interface SimpleProps extends Omit<ContainerProps, "value" | "onChange"> {
+    data?: SimpleEntry[];
+    onEntryChange?: (value: SimpleEntry) => void;
+    position?: ContainerProps["value"];
+    onPositionChange?: ContainerProps["onChange"];
+}
+export declare const Simple: ({ data, onEntryChange, position, onPositionChange, ...props }: SimpleProps) => ReactElement | null;
+export {};

package/dist/vis/legend/external.d.ts

@@ -0,0 +1,2 @@
+export * from '../../vis/legend/Container';
+export * from '../../vis/legend/Simple';

package/dist/vis/legend/index.d.ts

@@ -0,0 +1 @@
+export * as Legend from '../../vis/legend/external';

package/dist/vis/line/Line.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { type Optional } from "@synnaxlabs/x";
+import { line } from '../../vis/line/aether';
+export interface LineProps extends Optional<Omit<line.State, "key">, "strokeWidth"> {
+}
+export declare const Line: import("react").FC<LineProps & {
+    aetherKey?: string | undefined;
+}>;

package/dist/vis/line/aether/index.d.ts

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