microboard-temp 0.14.6 → 0.14.8

package/dist/types/Color/Color.schema.d.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+export declare const ColorValueSchema: 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>]>;
+export type ColorValueData = z.infer<typeof ColorValueSchema>;

package/dist/types/Events/BaseCommand.d.ts

@@ -1,17 +1,17 @@
 import type { Board } from "../Board";
-import { BaseOperation, Operation } from "./EventsOperations";
+import { Operation } from "./EventsOperations";
 import { Command } from "./Command";
 export declare class BaseCommand implements Command {
     private board;
     itemIds: string[];
-    operation: BaseOperation;
+    operation: Operation;
     private reverse;
-    constructor(board: Board, itemIds: string[], operation: BaseOperation);
+    constructor(board: Board, itemIds: string[], operation: Operation);
     merge(op: Operation): this;
     apply(): void;
     revert(): void;
     getReverse(): {
         itemId: string;
-        operation: BaseOperation;
+        operation: Operation;
     }[];
 }

package/dist/types/Events/EventsOperations.d.ts

@@ -31,7 +31,15 @@ export interface BaseOperation<T extends Record<string, unknown> = {}> {
     newData: T;
     prevData?: T;
 }
-export type ItemOperation = LinkToOperation | TransformationOperation | ShapeOperation | StickerOperation | RichTextOperation | ConnectorOperation | DrawingOperation | FrameOperation | PlaceholderOperation | GroupOperation | CommentOperation | ImageOperation | VideoOperation | AudioOperation;
+export interface SetPropertyOperation {
+    class: "Item";
+    item: string[];
+    method: "setProperty";
+    property: string;
+    value: unknown;
+    prevValues: unknown[];
+}
+export type ItemOperation = LinkToOperation | TransformationOperation | ShapeOperation | StickerOperation | RichTextOperation | ConnectorOperation | DrawingOperation | FrameOperation | PlaceholderOperation | GroupOperation | CommentOperation | ImageOperation | VideoOperation | AudioOperation | SetPropertyOperation;
 export type UndoableOperation = BoardOps | ItemOperation;
 export type Operation = UndoableOperation | EventsOperation;
 export type MethodType = Operation["method"];

package/dist/types/Events/MessageRouter/socketContract.d.ts

@@ -5345,9 +5345,9 @@ export declare const AiChatEventSchema: z.ZodUnion<readonly [z.ZodObject<{
 }, z.core.$loose>, z.ZodObject<{
     method: z.ZodLiteral<"GenerateImage">;
     status: z.ZodEnum<{
+        error: "error";
         generating: "generating";
         completed: "completed";
-        error: "error";
     }>;
     message: z.ZodOptional<z.ZodString>;
     base64: z.ZodNullable<z.ZodString>;
@@ -5361,9 +5361,9 @@ export declare const AiChatEventSchema: z.ZodUnion<readonly [z.ZodObject<{
 }, z.core.$loose>, z.ZodObject<{
     method: z.ZodLiteral<"GenerateAudio">;
     status: z.ZodEnum<{
+        error: "error";
         generating: "generating";
         completed: "completed";
-        error: "error";
     }>;
     message: z.ZodOptional<z.ZodString>;
     base64: z.ZodNullable<z.ZodString>;
@@ -9568,9 +9568,9 @@ export declare const AiChatMsgSchema: z.ZodObject<{
     }, z.core.$loose>, z.ZodObject<{
         method: z.ZodLiteral<"GenerateImage">;
         status: z.ZodEnum<{
+            error: "error";
             generating: "generating";
             completed: "completed";
-            error: "error";
         }>;
         message: z.ZodOptional<z.ZodString>;
         base64: z.ZodNullable<z.ZodString>;
@@ -9584,9 +9584,9 @@ export declare const AiChatMsgSchema: z.ZodObject<{
     }, z.core.$loose>, z.ZodObject<{
         method: z.ZodLiteral<"GenerateAudio">;
         status: z.ZodEnum<{
+            error: "error";
             generating: "generating";
             completed: "completed";
-            error: "error";
         }>;
         message: z.ZodOptional<z.ZodString>;
         base64: z.ZodNullable<z.ZodString>;
@@ -12161,9 +12161,9 @@ export declare const EventsMsgSchema: z.ZodUnion<readonly [z.ZodObject<{
     }, z.core.$loose>, z.ZodObject<{
         method: z.ZodLiteral<"GenerateImage">;
         status: z.ZodEnum<{
+            error: "error";
             generating: "generating";
             completed: "completed";
-            error: "error";
         }>;
         message: z.ZodOptional<z.ZodString>;
         base64: z.ZodNullable<z.ZodString>;
@@ -12177,9 +12177,9 @@ export declare const EventsMsgSchema: z.ZodUnion<readonly [z.ZodObject<{
     }, z.core.$loose>, z.ZodObject<{
         method: z.ZodLiteral<"GenerateAudio">;
         status: z.ZodEnum<{
+            error: "error";
             generating: "generating";
             completed: "completed";
-            error: "error";
         }>;
         message: z.ZodOptional<z.ZodString>;
         base64: z.ZodNullable<z.ZodString>;
@@ -13502,9 +13502,9 @@ export declare const SocketMsgSchema: z.ZodUnion<readonly [z.ZodUnion<readonly [
     }, z.core.$loose>, z.ZodObject<{
         method: z.ZodLiteral<"GenerateImage">;
         status: z.ZodEnum<{
+            error: "error";
             generating: "generating";
             completed: "completed";
-            error: "error";
         }>;
         message: z.ZodOptional<z.ZodString>;
         base64: z.ZodNullable<z.ZodString>;
@@ -13518,9 +13518,9 @@ export declare const SocketMsgSchema: z.ZodUnion<readonly [z.ZodUnion<readonly [
     }, z.core.$loose>, z.ZodObject<{
         method: z.ZodLiteral<"GenerateAudio">;
         status: z.ZodEnum<{
+            error: "error";
             generating: "generating";
             completed: "completed";
-            error: "error";
         }>;
         message: z.ZodOptional<z.ZodString>;
         base64: z.ZodNullable<z.ZodString>;
@@ -13681,7 +13681,7 @@ export declare function safeParseSocketMsg(data: unknown): z.ZodSafeParseResult<
     } | {
         [x: string]: unknown;
         method: "GenerateImage";
-        status: "generating" | "completed" | "error";
+        status: "error" | "generating" | "completed";
         base64: string | null;
         imageUrl: string | null;
         itemId: string;
@@ -13695,7 +13695,7 @@ export declare function safeParseSocketMsg(data: unknown): z.ZodSafeParseResult<
     } | {
         [x: string]: unknown;
         method: "GenerateAudio";
-        status: "generating" | "completed" | "error";
+        status: "error" | "generating" | "completed";
         base64: string | null;
         audioUrl: string | null;
         message?: string | undefined;
@@ -13774,11 +13774,12 @@ export declare function safeParseSocketMsg(data: unknown): z.ZodSafeParseResult<
     event: {
         [x: string]: unknown;
         order: number;
+        lastKnownOrder: number;
         body: {
             [x: string]: unknown;
             eventId: string;
             boardId: string;
-            operations: ({
+            operation: {
                 [x: string]: unknown;
                 class: "Events";
                 method: "undo";
@@ -13944,6 +13945,25 @@ export declare function safeParseSocketMsg(data: unknown): z.ZodSafeParseResult<
                 };
                 timeStamp?: number | undefined;
                 timestamp?: number | undefined;
+            } | {
+                [x: string]: unknown;
+                class: "Transformation";
+                method: "applyMatrix";
+                items: {
+                    [x: string]: unknown;
+                    id: string;
+                    matrix: {
+                        [x: string]: unknown;
+                        translateX: number;
+                        translateY: number;
+                        scaleX: number;
+                        scaleY: number;
+                        shearX: number;
+                        shearY: number;
+                    };
+                }[];
+                timeStamp?: number | undefined;
+                timestamp?: number | undefined;
             } | {
                 [x: string]: unknown;
                 class: "Transformation";
@@ -13968,25 +13988,6 @@ export declare function safeParseSocketMsg(data: unknown): z.ZodSafeParseResult<
                 locked: boolean;
                 timeStamp?: number | undefined;
                 timestamp?: number | undefined;
-            } | {
-                [x: string]: unknown;
-                class: "Transformation";
-                method: "applyMatrix";
-                items: {
-                    [x: string]: unknown;
-                    id: string;
-                    matrix: {
-                        [x: string]: unknown;
-                        translateX: number;
-                        translateY: number;
-                        scaleX: number;
-                        scaleY: number;
-                        shearX: number;
-                        shearY: number;
-                    };
-                }[];
-                timeStamp?: number | undefined;
-                timestamp?: number | undefined;
             } | {
                 [x: string]: unknown;
                 class: "Transformation";
@@ -14423,8 +14424,7 @@ export declare function safeParseSocketMsg(data: unknown): z.ZodSafeParseResult<
                 method: "setUrl";
                 item: string[];
                 url: string;
-            })[];
-            lastKnownOrder: number;
+            };
             userId?: string | number | undefined;
             authorUserId?: string | undefined;
             sessionId?: string | undefined;
@@ -14432,12 +14432,11 @@ export declare function safeParseSocketMsg(data: unknown): z.ZodSafeParseResult<
     } | {
         [x: string]: unknown;
         order: number;
-        lastKnownOrder: number;
         body: {
             [x: string]: unknown;
             eventId: string;
             boardId: string;
-            operation: {
+            operations: ({
                 [x: string]: unknown;
                 class: "Events";
                 method: "undo";
@@ -14603,6 +14602,25 @@ export declare function safeParseSocketMsg(data: unknown): z.ZodSafeParseResult<
                 };
                 timeStamp?: number | undefined;
                 timestamp?: number | undefined;
+            } | {
+                [x: string]: unknown;
+                class: "Transformation";
+                method: "applyMatrix";
+                items: {
+                    [x: string]: unknown;
+                    id: string;
+                    matrix: {
+                        [x: string]: unknown;
+                        translateX: number;
+                        translateY: number;
+                        scaleX: number;
+                        scaleY: number;
+                        shearX: number;
+                        shearY: number;
+                    };
+                }[];
+                timeStamp?: number | undefined;
+                timestamp?: number | undefined;
             } | {
                 [x: string]: unknown;
                 class: "Transformation";
@@ -14627,25 +14645,6 @@ export declare function safeParseSocketMsg(data: unknown): z.ZodSafeParseResult<
                 locked: boolean;
                 timeStamp?: number | undefined;
                 timestamp?: number | undefined;
-            } | {
-                [x: string]: unknown;
-                class: "Transformation";
-                method: "applyMatrix";
-                items: {
-                    [x: string]: unknown;
-                    id: string;
-                    matrix: {
-                        [x: string]: unknown;
-                        translateX: number;
-                        translateY: number;
-                        scaleX: number;
-                        scaleY: number;
-                        shearX: number;
-                        shearY: number;
-                    };
-                }[];
-                timeStamp?: number | undefined;
-                timestamp?: number | undefined;
             } | {
                 [x: string]: unknown;
                 class: "Transformation";
@@ -15082,7 +15081,8 @@ export declare function safeParseSocketMsg(data: unknown): z.ZodSafeParseResult<
                 method: "setUrl";
                 item: string[];
                 url: string;
-            };
+            })[];
+            lastKnownOrder: number;
             userId?: string | number | undefined;
             authorUserId?: string | undefined;
             sessionId?: string | undefined;

package/dist/types/Events/index.d.ts

@@ -1,6 +1,6 @@
 export { Events, createEvents } from "./Events";
 export type { BoardEventBody, BoardEvent, SyncBoardEvent, SyncEvent, } from "./Events";
-export type { ItemOperation, EventsOperation, Operation, BaseOperation, } from "./EventsOperations";
+export type { ItemOperation, EventsOperation, Operation, BaseOperation, SetPropertyOperation, } from "./EventsOperations";
 export { isTransformation, isBoardOp, isRichTextOp, isShapeOp, isConnectorOp, isDrawingOp, isEventsOp, isItemOp } from "./EventsOperations";
 export type { Command } from "./Command";
 export type { SyncLog } from "./SyncLog";

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

@@ -11,6 +11,7 @@ import { Point } from "../Point/Point";
 import { RichText } from "../RichText/RichText";
 import { Subject } from "../../Subject";
 import { BaseItem, SerializedItemData } from "../BaseItem/BaseItem";
+import { TransformParams, TransformResult } from "../BaseItem/TransformContext";
 export declare const CONTEXT_NODE_HIGHLIGHT_COLOR = "rgba(183, 138, 240, 1)";
 export declare const threadDirections: readonly [0, 1, 2, 3];
 export type ThreadDirection = typeof threadDirections[number];
@@ -29,7 +30,7 @@ export declare class AINode extends BaseItem<AINode> {
     private buttonMbr;
     private buttonIcon;
     prevMbr: Mbr | null;
-    constructor(board: Board, isUserRequest?: boolean, parentNodeId?: string, contextItems?: string[], threadDirection?: ThreadDirection, id?: string);
+    constructor(board: Board, id?: string);
     transformPath(): void;
     serialize(): SerializedItemData<AINodeData>;
     deserialize(data: SerializedItemData<AINodeData> | AINodeData): this;
@@ -61,4 +62,9 @@ export declare class AINode extends BaseItem<AINode> {
     renderButton(context: DrawingContext): void;
     render(context: DrawingContext): void;
     getPrevMbr(): Mbr | null;
+    getPointOnEdge(point: Point, edge?: string): Point;
+    handleTransform(params: TransformParams): TransformResult;
+    isBusy(): boolean;
+    canBeInteractedWithWhileLocked(isAiGenerating: boolean): boolean;
 }
+export declare const DefaultAINodeData: AINodeData;

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

@@ -0,0 +1,47 @@
+import { z } from "zod";
+export declare const AINodeDataSchema: z.ZodObject<{
+    itemType: z.ZodLiteral<"AINode">;
+    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>;
+    parentNodeId: z.ZodOptional<z.ZodString>;
+    isUserRequest: z.ZodBoolean;
+    contextItems: z.ZodArray<z.ZodString>;
+    threadDirection: z.ZodEnum<{
+        left: "left";
+        right: "right";
+        up: "up";
+        down: "down";
+    }>;
+}, z.core.$strip>;
+export type AINodeData = z.infer<typeof AINodeDataSchema>;

package/dist/types/Items/Audio/Audio.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 { TransformationData } from "../Transformation/TransformationData";
@@ -14,8 +14,6 @@ export interface AudioItemData {
     [key: string]: unknown;
 }
 export declare class AudioItem extends BaseItem<AudioItem> {
-    private events?;
-    private extension?;
     readonly itemType = "Audio";
     parent: string;
     readonly subject: Subject<AudioItem>;
@@ -25,7 +23,8 @@ export declare class AudioItem extends BaseItem<AudioItem> {
     private url;
     private isPlaying;
     private currentTime;
-    constructor(board: Board, url?: string, events?: Events | undefined, id?: string, extension?: string | undefined);
+    private extension?;
+    constructor(board: Board, id?: string);
     setCurrentTime(time: number): void;
     getCurrentTime(): number;
     doOnceBeforeOnLoad: (callback: (audio: AudioItem) => void) => void;
@@ -55,3 +54,4 @@ export declare class AudioItem extends BaseItem<AudioItem> {
     download(): void;
     onRemove(): void;
 }
+export declare const DefaultAudioItemData: AudioItemData;

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

@@ -0,0 +1,15 @@
+import { z } from "zod";
+export declare const AudioItemDataSchema: z.ZodObject<{
+    itemType: z.ZodLiteral<"Audio">;
+    url: 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>;
+    extension: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type AudioItemData = z.infer<typeof AudioItemDataSchema>;

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

@@ -1,20 +1,25 @@
 import { Mbr } from "../Mbr/Mbr";
+import { Line } from "../Line/Line";
+import { Item } from "../Item";
 import { Geometry } from "../Geometry";
 import type { RichText } from "../RichText/RichText";
 import { LinkTo } from "../LinkTo/LinkTo";
 import { Transformation } from "../Transformation/Transformation";
 import { Board } from "../../Board";
 import { DrawingContext } from "../DrawingContext";
-import type { Operation } from "../../Events/EventsOperations";
-import type { Command } from "../../Events/Command";
+import { BaseOperation, Operation } from "../../Events/EventsOperations";
+import { Command } from "../../Events/Command";
 import { TransformationData } from "../Transformation/TransformationData";
-import { BaseOperation } from "../../Events/EventsOperations";
 import { Subject } from "../../Subject";
 import { Path, Paths } from "../Path/index";
 import { BaseItemOperation } from "./BaseItemOperation";
 import { SimpleSpatialIndex } from "../../SpatialIndex/SimpleSpatialIndex";
 import { Point } from "../Point";
 import { Matrix } from "../Transformation/Matrix";
+import { TransformParams, TransformResult } from "./TransformContext";
+import { GeometricNormal } from "../GeometricNormal";
+import { ResizeType } from "../../Selection/Transformer/TransformerHelpers/getResizeType";
+import type { ItemType } from "../Item";
 export interface BaseItemData {
     itemType: string;
     transformation?: TransformationData;
@@ -26,15 +31,15 @@ export type SerializedItemData<T extends BaseItemData = BaseItemData> = T & {
     id: string;
     transformation: TransformationData;
 };
-export declare class BaseItem<T extends BaseItem<any> = any> extends Mbr implements Geometry {
-    private defaultItemData?;
+export declare class BaseItem<T extends BaseItem<any> = any> implements Geometry {
     static createCommand?: (board: Board, operation: Operation) => Command;
-    readonly transformation: Transformation;
-    readonly linkTo: LinkTo;
+    protected mbr: Mbr;
+    transformation: Transformation;
+    linkTo: LinkTo;
     parent: string;
     canBeNested: boolean;
     transformationRenderBlock?: boolean;
-    readonly index: SimpleSpatialIndex | null;
+    index: SimpleSpatialIndex | null;
     board: Board;
     id: string;
     subject: Subject<T>;
@@ -44,7 +49,7 @@ export declare class BaseItem<T extends BaseItem<any> = any> extends Mbr impleme
     shouldUseRelativeAlignment: boolean;
     resizeEnabled: boolean;
     onlyProportionalResize: boolean;
-    itemType: string;
+    itemType: ItemType;
     childIds: string[];
     isHoverHighlighted: boolean;
     static readonly HOVER_HIGHLIGHT_COLOR = "rgba(71, 120, 245, 0.7)";
@@ -53,7 +58,7 @@ export declare class BaseItem<T extends BaseItem<any> = any> extends Mbr impleme
      *  entire simulation once computed. Invalidated on resize/scale only. */
     private _physicsHalfExtent;
     get physicsHalfExtent(): number;
-    constructor(board: Board, id?: string, defaultItemData?: BaseItemData | undefined, isGroupItem?: boolean);
+    constructor(board: Board, id?: string);
     updateChildrenIds(): void;
     /**
      * Called when this item's parent changes. Subclasses override this to
@@ -89,6 +94,11 @@ export declare class BaseItem<T extends BaseItem<any> = any> extends Mbr impleme
         cancelIfChild?: boolean;
     }): boolean;
     getMbr(): Mbr;
+    setMbr(rect: Mbr): void;
+    addMbr(rect: Mbr): void;
+    getWidth(): number;
+    getHeight(): number;
+    getCenter(): Point;
     /**
      * Returns the world-space axis-aligned bounding box.
      * For top-level items this is identical to getMbr().
@@ -96,6 +106,10 @@ export declare class BaseItem<T extends BaseItem<any> = any> extends Mbr impleme
      * through the world matrix to produce the correct world-space bounds.
      */
     getWorldMbr(): Mbr;
+    getIntersectionPoints(segment: Line): Point[];
+    getNearestEdgePointTo(point: Point): Point;
+    isInView(rect: Mbr): boolean;
+    getNormal(point: Point): GeometricNormal;
     private hasAncestor;
     applyAddChildren(childIds: string[]): void;
     applyRemoveChildren(childIds: string[]): void;
@@ -110,12 +124,15 @@ export declare class BaseItem<T extends BaseItem<any> = any> extends Mbr impleme
     disableResize(items: BaseItem[]): void;
     enableResize(items: BaseItem[]): void;
     apply(op: Operation | BaseItemOperation | BaseOperation): void;
+    protected onPropertyUpdated(property: string, value: any, prevValue: any): void;
     addOnRemoveCallback(cb: () => void): void;
     onRemove(): void;
     getPathMbr(): Mbr;
     isEnclosedBy(rect: Mbr): boolean;
     isUnderPoint(point: Point): boolean;
     isNearPoint(point: Point, distance: number): boolean;
+    getDistanceToPoint(point: Point): number;
+    intersectsWithLines(lines: Line[]): boolean;
     isEnclosedOrCrossedBy(rect: Mbr): boolean;
     getMbrWithChildren(): Mbr;
     getPath(): Path | Paths;
@@ -123,4 +140,15 @@ export declare class BaseItem<T extends BaseItem<any> = any> extends Mbr impleme
     clearHighlightMbr(): void;
     renderHoverHighlight(context: DrawingContext): void;
     render(context: DrawingContext): void;
+    getIsScalingContainer(): boolean;
+    getSnapAnchorPoints(): Point[];
+    getPointOnEdge(point: Point, _edge?: string): Point;
+    handleTransform(params: TransformParams): TransformResult;
+    getResizeType(point: Point, cameraScale: number, mbr: Mbr, anchorDistance?: number): ResizeType | undefined;
+    isBusy(): boolean;
+    shouldFollowItems(): boolean;
+    isAlignmentSource(): boolean;
+    isReady(): boolean;
+    onSelectEnd(_topItem?: Item): void;
+    canBeInteractedWithWhileLocked(_isAiGenerating: boolean): boolean;
 }

package/dist/types/Items/BaseItem/TransformContext.d.ts

@@ -0,0 +1,40 @@
+import { Board } from "../../Board";
+import { Mbr, Point } from "../../Items";
+import { ResizeType } from "../../Selection/Transformer/TransformerHelpers/getResizeType";
+import { Comment } from "../Comment/Comment";
+import { ApplyMatrixItem } from "../Transformation/TransformationOperations";
+/** Minimal interface for BoardSelection to avoid circular dependencies */
+export interface ISelection {
+    items: {
+        list(): any[];
+    };
+    transformMany(translations: ApplyMatrixItem[], timeStamp: number): void;
+    shouldRenderItemsMbr: boolean;
+}
+/** Minimal interface for tools used during transformation */
+export interface ITransformTools {
+    canvasDrawer: any;
+    alignmentHelper: any;
+    debounceUpd: any;
+}
+export type TransformParams = {
+    board: Board;
+    selection: ISelection;
+    tools: ITransformTools;
+    resizeType: ResizeType;
+    mbr: Mbr;
+    oppositePoint: Point;
+    isWidth: boolean;
+    isHeight: boolean;
+    isShiftPressed: boolean;
+    beginTimeStamp: number;
+    followingComments?: Comment[];
+    startMbr?: Mbr;
+    snapCursorPos: Point | null;
+    setSnapCursorPos: (pos: Point | null) => void;
+};
+export type TransformResult = {
+    resizedMbr: Mbr | null;
+    translation?: ApplyMatrixItem[] | null;
+    onPointerUpCb?: () => void;
+};

package/dist/types/Items/BaseItem/toLocalTransformOp.d.ts

@@ -0,0 +1,10 @@
+import { TransformationOperation, Matrix } from "../../browser";
+/**
+ * Converts a world-space Transformation operation into an equivalent local-space
+ * operation relative to `containerMatrix`. Used when replaying ops (including old
+ * log events) against items that now store local transforms.
+ *
+ * Scale ratios in `applyMatrix` are coordinate-space invariant — only translation
+ * deltas need to be rotated/scaled by the inverse of the container's linear transform.
+ */
+export declare function toLocalTransformOp(op: TransformationOperation, containerMatrix: Matrix, itemId?: string): TransformationOperation;

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

@@ -1,5 +1,5 @@
 import { Subject } from "../../Subject";
-import { Events, Operation } from "../../Events";
+import type { Operation } from "../../Events";
 import { Point } from "../Point";
 import { TransformationData } from "../Transformation";
 import { CommentOperation } from "./CommentOperation";
@@ -11,6 +11,7 @@ import { SerializedItemData } from "../BaseItem";
 import { Line } from "../Line";
 import { BaseItem } from "../BaseItem/BaseItem";
 import { Board } from "../../Board";
+import { Item } from "../Item";
 export interface Commentator {
     username: string;
     id: number;
@@ -35,18 +36,17 @@ export interface CommentData {
     [key: string]: unknown;
 }
 export declare class Comment extends BaseItem<Comment> {
-    private anchor;
-    private events?;
     parent: string;
     private commentators;
     private thread;
     private usersUnreadMarks;
     private resolved;
     private itemToFollow?;
+    private anchor;
     readonly subject: Subject<Comment>;
     transformationRenderBlock?: boolean;
     resizeEnabled: boolean;
-    constructor(board: Board, anchor?: Point, events?: Events | undefined, id?: string);
+    constructor(board: Board, id?: string);
     serialize(): SerializedItemData<CommentData>;
     deserialize(data: SerializedItemData<CommentData> | CommentData): this;
     emit(operation: CommentOperation): void;
@@ -99,5 +99,8 @@ export declare class Comment extends BaseItem<Comment> {
     highlightMbr(): void;
     clearHighlightMbr(): void;
     renderHoverHighlight(_context: DrawingContext): void;
+    shouldFollowItems(): boolean;
+    onSelectEnd(topItem?: Item): void;
     render(context: DrawingContext): void;
 }
+export declare const DefaultCommentData: CommentData;