microboard-temp 0.14.6 → 0.14.8

package/dist/types/Items/Comment/Comment.schema.d.ts

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+export declare const CommentatorSchema: z.ZodObject<{
+    username: z.ZodString;
+    id: z.ZodNumber;
+    avatar: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const MessageSchema: z.ZodObject<{
+    date: z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>;
+    text: z.ZodString;
+    id: z.ZodString;
+    commentator: z.ZodObject<{
+        username: z.ZodString;
+        id: z.ZodNumber;
+        avatar: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readers: z.ZodArray<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const CommentDataSchema: z.ZodObject<{
+    itemType: z.ZodLiteral<"Comment">;
+    anchor: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>;
+    thread: z.ZodArray<z.ZodObject<{
+        date: z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>;
+        text: z.ZodString;
+        id: z.ZodString;
+        commentator: z.ZodObject<{
+            username: z.ZodString;
+            id: z.ZodNumber;
+            avatar: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        readers: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strip>>;
+    commentators: z.ZodArray<z.ZodObject<{
+        username: z.ZodString;
+        id: z.ZodNumber;
+        avatar: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    transformation: z.ZodObject<{
+        translateX: z.ZodNumber;
+        translateY: z.ZodNumber;
+        scaleX: z.ZodNumber;
+        scaleY: z.ZodNumber;
+        rotate: z.ZodNumber;
+        isLocked: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+    usersUnreadMarks: z.ZodArray<z.ZodNumber>;
+    resolved: z.ZodBoolean;
+    itemToFollow: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;

package/dist/types/Items/Connector/Connector.d.ts

@@ -21,11 +21,6 @@ import { ConnectionLineWidth, ConnectorLineStyle } from './ConnectorTypes';
 export declare const CONNECTOR_ANCHOR_COLOR: ConnectorAnchorColors;
 export declare const CONNECTOR_ANCHOR_TYPE = "rect";
 export declare class Connector extends BaseItem<Connector> {
-    private startPoint;
-    private endPoint;
-    private lineStyle;
-    private startPointerStyle;
-    private endPointerStyle;
     readonly itemType = "Connector";
     parent: string;
     private middlePoint;
@@ -42,10 +37,16 @@ export declare class Connector extends BaseItem<Connector> {
     transformationRenderBlock?: boolean;
     private _updatingTitle;
     private optionalFindItemFn?;
-    constructor(board: Board, startPoint?: ControlPoint, endPoint?: ControlPoint, lineStyle?: ConnectorLineStyle, startPointerStyle?: ConnectorPointerStyle, endPointerStyle?: ConnectorPointerStyle, lineColor?: ColorValue, lineWidth?: ConnectionLineWidth, strokeStyle?: BorderStyle, id?: string);
+    private startPoint;
+    private endPoint;
+    private lineStyle;
+    private startPointerStyle;
+    private endPointerStyle;
+    constructor(board: Board, id?: string);
     private initText;
     observerStartPointItem: () => void;
     observerEndPointItem: () => void;
+    private handleItemGeometryChange;
     /**
      * If the start point is attached to one of the 4 edge-center anchors, re-evaluate
      * which edge best faces the current end position and jump there to avoid sharp bends.
@@ -64,18 +65,13 @@ export declare class Connector extends BaseItem<Connector> {
     setId(id: string): this;
     getId(): string;
     apply(operation: Operation): void;
+    protected onPropertyUpdated(property: string, value: unknown, prevValue: unknown): void;
     complete(id: string): void;
     protected applyStartPoint(pointData: ControlPointData, updatePath?: boolean): void;
     protected applyEndPoint(pointData: ControlPointData, updatePath?: boolean): void;
     protected applyMiddlePoint(pointData: ControlPointData | null, updatePath?: boolean): void;
     private applySwitchPointers;
     addMiddlePoint(point: BoardPoint): void;
-    private applyStartPointerStyle;
-    private applyEndPointerStyle;
-    private applyLineColor;
-    private applyLineStyle;
-    private applyBorderStyle;
-    private applyLineWidth;
     getStartPoint(): ControlPoint;
     getEndPoint(): ControlPoint;
     getMiddlePoint(): ControlPoint | null;
@@ -92,6 +88,7 @@ export declare class Connector extends BaseItem<Connector> {
     getIntersectionPoints(segment: Line): Point[];
     getMbr(): Mbr;
     getNearestEdgePointTo(point: Point): Point;
+    isAlignmentSource(): boolean;
     isEnclosedOrCrossedBy(bounds: Mbr): boolean;
     isUnderPoint(point: Point): boolean;
     isNearPoint(point: Point, distance: number): boolean;

package/dist/types/Items/Connector/Connector.schema.d.ts

@@ -0,0 +1,172 @@
+import { z } from "zod";
+export declare const BoardPointDataSchema: z.ZodObject<{
+    pointType: z.ZodLiteral<"Board">;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+}, z.core.$strip>;
+export declare const FloatingPointDataSchema: z.ZodObject<{
+    pointType: z.ZodLiteral<"Floating">;
+    itemId: z.ZodString;
+    relativeX: z.ZodNumber;
+    relativeY: z.ZodNumber;
+}, z.core.$strip>;
+export declare const FixedPointDataSchema: z.ZodObject<{
+    pointType: z.ZodLiteral<"Fixed">;
+    itemId: z.ZodString;
+    relativeX: z.ZodNumber;
+    relativeY: z.ZodNumber;
+}, z.core.$strip>;
+export declare const FixedConnectorPointDataSchema: z.ZodObject<{
+    pointType: z.ZodLiteral<"FixedConnector">;
+    itemId: z.ZodString;
+    tangent: z.ZodNumber;
+    segment: z.ZodNumber;
+}, z.core.$strip>;
+export declare const ControlPointDataSchema: z.ZodUnion<readonly [z.ZodObject<{
+    pointType: z.ZodLiteral<"Board">;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    pointType: z.ZodLiteral<"Floating">;
+    itemId: z.ZodString;
+    relativeX: z.ZodNumber;
+    relativeY: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    pointType: z.ZodLiteral<"Fixed">;
+    itemId: z.ZodString;
+    relativeX: z.ZodNumber;
+    relativeY: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    pointType: z.ZodLiteral<"FixedConnector">;
+    itemId: z.ZodString;
+    tangent: z.ZodNumber;
+    segment: z.ZodNumber;
+}, z.core.$strip>]>;
+export declare const ConnectorDataSchema: z.ZodObject<{
+    itemType: z.ZodLiteral<"Connector">;
+    startPoint: z.ZodUnion<readonly [z.ZodObject<{
+        pointType: z.ZodLiteral<"Board">;
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        pointType: z.ZodLiteral<"Floating">;
+        itemId: z.ZodString;
+        relativeX: z.ZodNumber;
+        relativeY: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        pointType: z.ZodLiteral<"Fixed">;
+        itemId: z.ZodString;
+        relativeX: z.ZodNumber;
+        relativeY: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        pointType: z.ZodLiteral<"FixedConnector">;
+        itemId: z.ZodString;
+        tangent: z.ZodNumber;
+        segment: z.ZodNumber;
+    }, z.core.$strip>]>;
+    endPoint: z.ZodUnion<readonly [z.ZodObject<{
+        pointType: z.ZodLiteral<"Board">;
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        pointType: z.ZodLiteral<"Floating">;
+        itemId: z.ZodString;
+        relativeX: z.ZodNumber;
+        relativeY: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        pointType: z.ZodLiteral<"Fixed">;
+        itemId: z.ZodString;
+        relativeX: z.ZodNumber;
+        relativeY: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        pointType: z.ZodLiteral<"FixedConnector">;
+        itemId: z.ZodString;
+        tangent: z.ZodNumber;
+        segment: z.ZodNumber;
+    }, z.core.$strip>]>;
+    middlePoint: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodObject<{
+        pointType: z.ZodLiteral<"Board">;
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        pointType: z.ZodLiteral<"Floating">;
+        itemId: z.ZodString;
+        relativeX: z.ZodNumber;
+        relativeY: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        pointType: z.ZodLiteral<"Fixed">;
+        itemId: z.ZodString;
+        relativeX: z.ZodNumber;
+        relativeY: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        pointType: z.ZodLiteral<"FixedConnector">;
+        itemId: z.ZodString;
+        tangent: z.ZodNumber;
+        segment: z.ZodNumber;
+    }, z.core.$strip>]>>>;
+    startPointerStyle: z.ZodString;
+    endPointerStyle: z.ZodString;
+    lineStyle: z.ZodEnum<{
+        straight: "straight";
+        curved: "curved";
+        orthogonal: "orthogonal";
+    }>;
+    lineColor: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        type: z.ZodLiteral<"semantic">;
+        id: z.ZodEnum<{
+            contrastNeutral: "contrastNeutral";
+            contrastGray: "contrastGray";
+            contrastRed: "contrastRed";
+            contrastOrange: "contrastOrange";
+            contrastYellow: "contrastYellow";
+            contrastGreen: "contrastGreen";
+            contrastTeal: "contrastTeal";
+            contrastBlue: "contrastBlue";
+            contrastPurple: "contrastPurple";
+            contrastPink: "contrastPink";
+            contrastBrown: "contrastBrown";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"fixed">;
+        value: z.ZodString;
+    }, z.core.$strip>]>;
+    lineWidth: z.ZodUnion<readonly [z.ZodEnum<{
+        [x: string]: any;
+    }>, z.ZodNumber]>;
+    borderStyle: z.ZodOptional<z.ZodString>;
+    smartJump: z.ZodOptional<z.ZodBoolean>;
+    transformation: z.ZodObject<{
+        translateX: z.ZodNumber;
+        translateY: z.ZodNumber;
+        scaleX: z.ZodNumber;
+        scaleY: z.ZodNumber;
+        rotate: z.ZodNumber;
+        isLocked: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+    text: z.ZodObject<{
+        itemType: z.ZodOptional<z.ZodLiteral<"RichText">>;
+        children: z.ZodArray<z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>>;
+        verticalAlignment: z.ZodOptional<z.ZodEnum<{
+            center: "center";
+            top: "top";
+            bottom: "bottom";
+        }>>;
+        maxWidth: z.ZodOptional<z.ZodNumber>;
+        transformation: z.ZodOptional<z.ZodObject<{
+            translateX: z.ZodNumber;
+            translateY: z.ZodNumber;
+            scaleX: z.ZodNumber;
+            scaleY: z.ZodNumber;
+            rotate: z.ZodNumber;
+            isLocked: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        containerMaxWidth: z.ZodOptional<z.ZodNumber>;
+        insideOf: z.ZodOptional<z.ZodString>;
+        color: z.ZodOptional<z.ZodString>;
+        placeholderText: z.ZodOptional<z.ZodString>;
+        realSize: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"auto">, z.ZodNumber]>>;
+        linkTo: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    linkTo: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ConnectorData = z.infer<typeof ConnectorDataSchema>;

package/dist/types/Items/Connector/connectorOps.d.ts

@@ -1,20 +1,9 @@
-import { ColorValue } from "../../..";
-import { BorderStyle } from "../Path";
 import { Connector } from "./Connector";
 import { ControlPoint, ControlPointData } from "./ControlPoint";
 import { ConnectorOperation } from "./ConnectorOperations";
-import { ConnectionLineWidth, ConnectorLineStyle } from "./ConnectorTypes";
-import { ConnectorPointerStyle } from "./Pointers/Pointers";
 export declare const connectorOps: {
     setStartPoint: (items: Connector[], point: ControlPoint | ControlPointData, timestamp?: number) => ConnectorOperation;
     setEndPoint: (items: Connector[], point: ControlPoint | ControlPointData, timestamp?: number) => ConnectorOperation;
     setMiddlePoint: (items: Connector[], point: ControlPoint | ControlPointData | null, timestamp?: number) => ConnectorOperation;
-    setStartPointerStyle: (items: Connector[], style: ConnectorPointerStyle) => ConnectorOperation;
-    setEndPointerStyle: (items: Connector[], style: ConnectorPointerStyle) => ConnectorOperation;
-    setLineStyle: (items: Connector[], style: ConnectorLineStyle) => ConnectorOperation;
-    setBorderStyle: (items: Connector[], borderStyle: BorderStyle) => ConnectorOperation;
-    setLineColor: (items: Connector[], color: ColorValue) => ConnectorOperation;
-    setLineWidth: (items: Connector[], width: ConnectionLineWidth) => ConnectorOperation;
     switchPointers: (items: Connector[]) => ConnectorOperation;
-    setSmartJump: (items: Connector[], smartJump: boolean) => ConnectorOperation;
 };

package/dist/types/Items/Drawing/Drawing.d.ts

@@ -1,4 +1,4 @@
-import { Events, Operation } from "../../Events";
+import type { Operation } from "../../Events";
 import { Subject } from "../../Subject";
 import { DrawingContext } from "../DrawingContext";
 import { Line } from "../Line/Line";
@@ -25,8 +25,6 @@ export interface DrawingData {
     [key: string]: unknown;
 }
 export declare class Drawing extends BaseItem<Drawing> {
-    points: Point[];
-    private events?;
     readonly itemType = "Drawing";
     parent: string;
     private path2d;
@@ -40,9 +38,10 @@ export declare class Drawing extends BaseItem<Drawing> {
     private linePattern;
     private borderOpacity;
     transformationRenderBlock?: boolean;
-    constructor(board: Board, points: Point[], events?: Events | undefined, id?: string);
+    points: Point[];
+    constructor(board: Board, id?: string);
     serialize(): SerializedItemData<DrawingData>;
-    deserialize(data: SerializedItemData<DrawingData>): this;
+    deserialize(data: SerializedItemData<DrawingData> | DrawingData): this;
     updateGeometry(): void;
     updateMbr(): void;
     updatePath2d(): void;
@@ -57,9 +56,13 @@ export declare class Drawing extends BaseItem<Drawing> {
     getSnapAnchorPoints(): Point[];
     getLines(): Line[];
     isClosed(): boolean;
+    isNearPoint(point: Point, distance: number): boolean;
+    getDistanceToPoint(point: Point): number;
+    intersectsWithLines(lines: Line[]): boolean;
     isEnclosedOrCrossedBy(rect: Mbr): boolean;
     emit(operation: DrawingOperation): void;
     apply(op: Operation): void;
+    protected onPropertyUpdated(property: string, value: unknown, prevValue: unknown): void;
     getStrokeOpacity(): number;
     getBorderStyle(): BorderStyle;
     getStrokeColor(): ColorValue;

package/dist/types/Items/Drawing/Drawing.schema.d.ts

@@ -0,0 +1,42 @@
+import { z } from "zod";
+export declare const DrawingDataSchema: z.ZodObject<{
+    itemType: z.ZodLiteral<"Drawing">;
+    points: z.ZodArray<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+    transformation: z.ZodObject<{
+        translateX: z.ZodNumber;
+        translateY: z.ZodNumber;
+        scaleX: z.ZodNumber;
+        scaleY: z.ZodNumber;
+        rotate: z.ZodNumber;
+        isLocked: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+    strokeStyle: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        type: z.ZodLiteral<"semantic">;
+        id: z.ZodEnum<{
+            contrastNeutral: "contrastNeutral";
+            contrastGray: "contrastGray";
+            contrastRed: "contrastRed";
+            contrastOrange: "contrastOrange";
+            contrastYellow: "contrastYellow";
+            contrastGreen: "contrastGreen";
+            contrastTeal: "contrastTeal";
+            contrastBlue: "contrastBlue";
+            contrastPurple: "contrastPurple";
+            contrastPink: "contrastPink";
+            contrastBrown: "contrastBrown";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"fixed">;
+        value: z.ZodString;
+    }, z.core.$strip>]>;
+    strokeWidth: z.ZodNumber;
+    colorRole: z.ZodOptional<z.ZodEnum<{
+        background: "background";
+        foreground: "foreground";
+    }>>;
+    linkTo: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type DrawingData = z.infer<typeof DrawingDataSchema>;

package/dist/types/Items/Drawing/index.d.ts

@@ -1,3 +1,2 @@
 export * from "./Drawing";
-export * from "./drawingOps";
 export * from "./DrawingOperation";

package/dist/types/Items/Examples/CardGame/Card/Card.d.ts

@@ -29,7 +29,7 @@ export declare class Card extends BaseItem<Card> {
         width: number;
         height: number;
     };
-    constructor(board: Board, id?: string, defaultData?: CardData);
+    constructor(board: Board, id?: string);
     getDimensions(): {
         width: number;
         height: number;

package/dist/types/Items/Examples/CardGame/Deck/Deck.d.ts

@@ -36,4 +36,3 @@ export declare class Deck extends BaseItem<Deck> {
     private updateCache;
     getFirstCard(): Card | undefined;
 }
-export declare function createDeck(event?: KeyboardEvent, board?: Board): void;

package/dist/types/Items/Examples/CardGame/Dice/Dice.d.ts

@@ -26,7 +26,7 @@ export declare class Dice extends BaseItem<Dice> {
     private valueIndex;
     private renderValues;
     private animationFrameId;
-    constructor(board: Board, id?: string, defaultItemData?: BaseItemData, isGroupItem?: boolean);
+    constructor(board: Board, id?: string);
     private transformPath;
     updateRenderValues(): Promise<void>;
     render(context: DrawingContext): void;

package/dist/types/Items/Examples/CardGame/Screen/Screen.d.ts

@@ -18,7 +18,7 @@ export declare class Screen extends BaseItem<Screen> {
     backgroundUrl: string;
     backgroundImage: HTMLImageElement | null;
     ownerId: string;
-    constructor(board: Board, id?: string, defaultItemData?: BaseItemData, isGroupItem?: boolean);
+    constructor(board: Board, id?: string);
     apply(op: any): void;
     getOwnerId(): string;
     getBackgroundColor(): string;

package/dist/types/Items/Examples/Star/Star.d.ts

@@ -22,6 +22,9 @@ export declare class Star extends BaseItem<Star> {
     private path;
     readonly subject: Subject<Star>;
     private borderWidth;
+    backgroundColor: string;
+    borderColor: string;
+    borderStyle: BorderStyle;
     isShining: boolean;
     constructor(board: Board, id?: string);
     private transformPath;

package/dist/types/Items/Frame/Frame.d.ts

@@ -3,10 +3,10 @@ import { Line } from "../Line/Line";
 import { Point } from "../Point/Point";
 import { Path } from "../Path/Path";
 import { Paths } from "../Path/Paths";
-import type { Item } from "../Item";
 import { RichText } from "../RichText/RichText";
 import { Matrix } from "../Transformation/Matrix";
 import { BaseItem, SerializedItemData } from "../BaseItem/BaseItem";
+import { TransformParams, TransformResult } from "../BaseItem/TransformContext";
 import { Subject } from "../../Subject";
 import { DrawingContext } from "../DrawingContext";
 import { Operation } from "../../Events";
@@ -19,27 +19,25 @@ import { FrameData } from "./FrameData";
 import { ResizeType } from "../../Selection/Transformer/TransformerHelpers/getResizeType";
 import { ColorValue } from "../../..";
 export declare class Frame extends BaseItem<Frame> {
-    private getItemById;
-    private name;
-    private shapeType;
-    backgroundColor: ColorValue;
-    backgroundOpacity: number;
-    borderColor: ColorValue;
-    borderOpacity: number;
-    borderStyle: "solid" | "dot" | "dash" | "longDash" | "dotDash" | "tripleDotDash" | "looseDoubleDotDash";
-    borderWidth: number;
     readonly itemType = "Frame";
     parent: string;
     readonly subject: Subject<Frame>;
     private textContainer;
     private path;
-    private mbr;
     readonly text: RichText;
     private canChangeRatio;
     canBeNested: boolean;
     newShape: FrameType | null;
     transformationRenderBlock?: boolean;
-    constructor(board: Board, getItemById: (id: string) => Item | undefined, id?: string, name?: string, shapeType?: "Custom" | "A4" | "Letter" | "Frame16x9" | "Frame4x3" | "Frame1x1" | "Frame3x2" | "Frame9x18", backgroundColor?: ColorValue, backgroundOpacity?: number, borderColor?: ColorValue, borderOpacity?: number, borderStyle?: "solid" | "dot" | "dash" | "longDash" | "dotDash" | "tripleDotDash" | "looseDoubleDotDash", borderWidth?: number);
+    private name;
+    private shapeType;
+    backgroundColor: ColorValue;
+    backgroundOpacity: number;
+    borderColor: ColorValue;
+    borderOpacity: number;
+    borderStyle: "solid" | "dot" | "dash" | "longDash" | "dotDash" | "tripleDotDash" | "looseDoubleDotDash";
+    borderWidth: number;
+    constructor(board: Board, id?: string);
     setBoard(board: Board): this;
     addChildItems(children: BaseItem[]): void;
     removeChildItems(children: BaseItem[] | BaseItem): void;
@@ -56,7 +54,6 @@ export declare class Frame extends BaseItem<Frame> {
     getId(): string;
     getChildrenIds(): string[];
     updateMbr(): void;
-    getMbr(): Mbr;
     doResize(resizeType: ResizeType, pointer: Point, mbr: Mbr, opposite: Point, startMbr: Mbr, timeStamp: number): {
         matrix: Matrix;
         mbr: Mbr;
@@ -99,4 +96,6 @@ export declare class Frame extends BaseItem<Frame> {
     renderPath(context: DrawingContext): void;
     renderNewShape(context: DrawingContext): void;
     getRichText(): RichText;
+    getIsScalingContainer(): boolean;
+    handleTransform(params: TransformParams): TransformResult;
 }

package/dist/types/Items/Frame/Frame.schema.d.ts

@@ -0,0 +1,84 @@
+import { z } from "zod";
+export declare const FrameDataSchema: z.ZodObject<{
+    itemType: z.ZodLiteral<"Frame">;
+    shapeType: z.ZodString;
+    backgroundColor: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        type: z.ZodLiteral<"semantic">;
+        id: z.ZodEnum<{
+            contrastNeutral: "contrastNeutral";
+            contrastGray: "contrastGray";
+            contrastRed: "contrastRed";
+            contrastOrange: "contrastOrange";
+            contrastYellow: "contrastYellow";
+            contrastGreen: "contrastGreen";
+            contrastTeal: "contrastTeal";
+            contrastBlue: "contrastBlue";
+            contrastPurple: "contrastPurple";
+            contrastPink: "contrastPink";
+            contrastBrown: "contrastBrown";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"fixed">;
+        value: z.ZodString;
+    }, z.core.$strip>]>;
+    backgroundOpacity: z.ZodNumber;
+    borderColor: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        type: z.ZodLiteral<"semantic">;
+        id: z.ZodEnum<{
+            contrastNeutral: "contrastNeutral";
+            contrastGray: "contrastGray";
+            contrastRed: "contrastRed";
+            contrastOrange: "contrastOrange";
+            contrastYellow: "contrastYellow";
+            contrastGreen: "contrastGreen";
+            contrastTeal: "contrastTeal";
+            contrastBlue: "contrastBlue";
+            contrastPurple: "contrastPurple";
+            contrastPink: "contrastPink";
+            contrastBrown: "contrastBrown";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"fixed">;
+        value: z.ZodString;
+    }, z.core.$strip>]>;
+    borderOpacity: z.ZodNumber;
+    borderStyle: z.ZodString;
+    borderWidth: z.ZodNumber;
+    childIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    children: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    transformation: z.ZodObject<{
+        translateX: z.ZodNumber;
+        translateY: z.ZodNumber;
+        scaleX: z.ZodNumber;
+        scaleY: z.ZodNumber;
+        rotate: z.ZodNumber;
+        isLocked: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+    text: z.ZodObject<{
+        itemType: z.ZodOptional<z.ZodLiteral<"RichText">>;
+        children: z.ZodArray<z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>>;
+        verticalAlignment: z.ZodOptional<z.ZodEnum<{
+            center: "center";
+            top: "top";
+            bottom: "bottom";
+        }>>;
+        maxWidth: z.ZodOptional<z.ZodNumber>;
+        transformation: z.ZodOptional<z.ZodObject<{
+            translateX: z.ZodNumber;
+            translateY: z.ZodNumber;
+            scaleX: z.ZodNumber;
+            scaleY: z.ZodNumber;
+            rotate: z.ZodNumber;
+            isLocked: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        containerMaxWidth: z.ZodOptional<z.ZodNumber>;
+        insideOf: z.ZodOptional<z.ZodString>;
+        color: z.ZodOptional<z.ZodString>;
+        placeholderText: z.ZodOptional<z.ZodString>;
+        realSize: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"auto">, z.ZodNumber]>>;
+        linkTo: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    canChangeRatio: z.ZodOptional<z.ZodBoolean>;
+    linkTo: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type FrameData = z.infer<typeof FrameDataSchema>;

package/dist/types/Items/Geometry.d.ts

@@ -32,4 +32,8 @@ export interface Geometry {
     render(context: DrawingContext): void;
     /** Get RichText handle if exists */
     getRichText(): RichText | null;
+    /** Get anchor points for snapping (e.g. connectors) */
+    getSnapAnchorPoints?(): Point[];
+    /** Get a point on the edge of the item for connection (handles special alignment for text items) */
+    getPointOnEdge?(point: Point, edge?: string): Point;
 }

package/dist/types/Items/Group/Group.d.ts

@@ -2,7 +2,7 @@ import { Subject } from "../../Subject";
 import { DrawingContext } from "../DrawingContext";
 import { TransformationData } from "../Transformation/TransformationData";
 import { GroupOperation } from "./GroupOperation";
-import { Events, Operation } from "../../Events";
+import type { Operation } from "../../Events";
 import { Mbr } from "../Mbr/Mbr";
 import { Line } from "../Line/Line";
 import { Point } from "../Point/Point";
@@ -17,7 +17,6 @@ export interface GroupData {
     [key: string]: unknown;
 }
 export declare class Group extends BaseItem<Group> {
-    private events?;
     readonly itemType = "Group";
     parent: string;
     readonly subject: Subject<Group>;
@@ -29,7 +28,7 @@ export declare class Group extends BaseItem<Group> {
      * via recalculatePoint) and avoid persisting spurious setStartPoint/setEndPoint ops.
      */
     static movingGroupId: string | null;
-    constructor(board: Board, events?: Events | undefined, childIds?: string[], id?: string);
+    constructor(board: Board, id?: string);
     isClosed(): boolean;
     getRichText(): null;
     apply(op: Operation): void;
@@ -41,8 +40,9 @@ export declare class Group extends BaseItem<Group> {
     getChildren(): Item[];
     getLinkTo(): string | undefined;
     serialize(): SerializedItemData<GroupData>;
-    deserialize(data: SerializedItemData<GroupData>): this;
+    deserialize(data: SerializedItemData<GroupData> | GroupData): this;
     getId(): string;
     getIntersectionPoints(segment: Line): Point[];
     render(context: DrawingContext): void;
 }
+export declare const DefaultGroupData: GroupData;

package/dist/types/Items/Group/Group.schema.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+export declare const GroupDataSchema: z.ZodObject<{
+    itemType: z.ZodLiteral<"Group">;
+    childIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    children: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    transformation: z.ZodObject<{
+        translateX: z.ZodNumber;
+        translateY: z.ZodNumber;
+        scaleX: z.ZodNumber;
+        scaleY: z.ZodNumber;
+        rotate: z.ZodNumber;
+        isLocked: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+    isLockedGroup: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type GroupData = z.infer<typeof GroupDataSchema>;