@inditextech/weave-renderer-konva-base 3.0.0-SNAPSHOT.18.1

package/dist/renderer-konva-base.d.ts

@@ -0,0 +1,1175 @@
+import { DeepPartial, MappedTypeDescription, WeaveActionBase, WeaveConfig, WeaveElementAttributes, WeaveElementInstance, WeaveExportNodesOptions, WeaveFont, WeaveLoggerConfig, WeaveMousePointInfo, WeaveMousePointInfoSimple, WeaveNodeBase, WeaveNodeChangeType, WeaveNodeConfiguration, WeaveNodeFound, WeaveNodeMutexLock, WeavePluginBase, WeavePosition, WeaveRendererBase, WeaveSelection, WeaveSerializedGroup, WeaveState, WeaveStateElement, WeaveStatus, WeaveStoreBase, WeaveStoreConnectionStatus, WeaveStoreOptions, WeaveUser, WeaveUserMutexLock } from "@inditextech/weave-types";
+import Konva from "konva";
+import pino, { Logger } from "pino";
+import * as Y$1 from "yjs";
+import * as konva_lib_Node18 from "konva/lib/Node";
+import * as konva_lib_Node19 from "konva/lib/Node";
+import * as konva_lib_Node20 from "konva/lib/Node";
+import * as konva_lib_Node21 from "konva/lib/Node";
+import * as konva_lib_Node22 from "konva/lib/Node";
+import * as konva_lib_Node23 from "konva/lib/Node";
+import * as konva_lib_Node12 from "konva/lib/Node";
+import * as konva_lib_Node13 from "konva/lib/Node";
+import { KonvaEventObject } from "konva/lib/Node";
+import * as konva_lib_Group7 from "konva/lib/Group";
+import * as konva_lib_Shape8 from "konva/lib/Shape";
+import * as konva_lib_Shape9 from "konva/lib/Shape";
+import { Stage, StageConfig } from "konva/lib/Stage";
+import { TransformerConfig } from "konva/lib/shapes/Transformer";
+import * as konva_lib_types6 from "konva/lib/types";
+import * as konva_lib_shapes_Rect10 from "konva/lib/shapes/Rect";
+import "konva/lib/shapes/Line";
+import "konva/lib/Layer";
+
+//#region ../sdk/dist/sdk.d.ts
+
+//#region src/stores/store.d.ts
+declare abstract class WeaveStore implements WeaveStoreBase {
+  protected instance: Weave;
+  protected name: string;
+  protected supportsUndoManager: boolean;
+  protected config: WeaveStoreOptions;
+  private state;
+  private latestState;
+  private document;
+  private logger;
+  private undoManager;
+  private isRoomLoaded;
+  constructor(config: WeaveStoreOptions);
+  getName(): string;
+  getLogger(): Logger;
+  register(instance: Weave): WeaveStore;
+  getUser(): WeaveUser;
+  setState(state: WeaveState): void;
+  setLatestState(newState: WeaveState): void;
+  getLatestState(): WeaveState;
+  getDocument(): Y$1.Doc;
+  loadDocument(roomData: Uint8Array): void;
+  loadDefaultDocument(setupDefaultDocument?: (doc: Y$1.Doc) => void): void;
+  getState(): MappedTypeDescription<WeaveState>;
+  getStateJson(): WeaveState;
+  getStateSnapshot(): Uint8Array;
+  private emitOnRoomLoadedEvent;
+  setup(): void;
+  canUndoStateStep(): boolean;
+  canRedoStateStep(): boolean;
+  undoStateStep(): void;
+  redoStateStep(): void;
+  handleConnectionStatusChange(status: WeaveStoreConnectionStatus): void;
+  abstract connect(extraParams?: any): void;
+  abstract disconnect(): void;
+  abstract handleAwarenessChange(emit: boolean): void;
+  abstract setAwarenessInfo(field: string, value: unknown): void;
+}
+
+//#endregion
+//#region src/plugins/plugin.d.ts
+//# sourceMappingURL=store.d.ts.map
+declare abstract class WeavePlugin implements WeavePluginBase {
+  protected instance: Weave;
+  protected name: string;
+  protected enabled: boolean;
+  private logger;
+  register(instance: Weave): WeavePlugin;
+  getName(): string;
+  getLogger(): Logger;
+  isEnabled(): boolean;
+  abstract onInit?(): void;
+  abstract onRender?(): void;
+  abstract enable(): void;
+  abstract disable(): void;
+}
+
+//#endregion
+//#region src/plugins/nodes-selection/types.d.ts
+//# sourceMappingURL=plugin.d.ts.map
+
+type WeaveNodesSelectionOnSelectionParams = {
+  resizeEnabled: boolean;
+  rotateEnabled: boolean;
+  enabledAnchors: string[];
+};
+type WeaveNodesSelectionBehaviorsConfig = {
+  singleSelection: {
+    enabled: boolean;
+  };
+  multipleSelection: {
+    enabled: boolean;
+  };
+  onMultipleSelection?: (selectedNodes: Konva.Node[]) => Partial<WeaveNodesSelectionOnSelectionParams>;
+};
+type WeaveNodesSelectionPanningOnSelectionConfig = {
+  edgeThreshold: number;
+  minScrollSpeed: number;
+  maxScrollSpeed: number;
+};
+type WeaveNodesSelectionConfig = {
+  selection: Konva.TransformerConfig;
+  hover: Konva.TransformerConfig;
+  selectionArea: Konva.RectConfig;
+  panningWhenSelection: WeaveNodesSelectionPanningOnSelectionConfig;
+  behaviors: WeaveNodesSelectionBehaviorsConfig;
+  style: WeaveNodesSelectionStyleConfig;
+};
+type WeaveNodesSelectionStyleConfig = {
+  dragOpacity: number;
+};
+type WeaveNodesSelectionPluginConfig = Partial<WeaveNodesSelectionConfig>;
+type WeaveNodesSelectionPluginParams = {
+  config?: WeaveNodesSelectionPluginConfig;
+};
+
+//#endregion
+//#region src/plugins/context-menu/types.d.ts
+//# sourceMappingURL=types.d.ts.map
+type WeaveStageContextMenuPluginParams = {
+  config?: WeaveStageContextMenuPluginConfig;
+};
+type WeaveStageContextMenuPluginConfig = {
+  xOffset?: number;
+  yOffset?: number;
+};
+//#endregion
+//#region src/plugins/context-menu/context-menu.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveContextMenuPlugin extends WeavePlugin {
+  private config;
+  private contextMenuVisible;
+  private tapHold;
+  private tapHoldTimeout;
+  private pointers;
+  private timer;
+  protected tapStart: {
+    x: number;
+    y: number;
+    time: number;
+  } | null;
+  getLayerName: undefined;
+  initLayer: undefined;
+  onRender: undefined;
+  constructor(params: WeaveStageContextMenuPluginParams);
+  getName(): string;
+  onInit(): void;
+  isPressed(e: KonvaEventObject<PointerEvent, Stage>): boolean;
+  setTapStart(e: KonvaEventObject<PointerEvent, Stage>): void;
+  triggerContextMenu(eventTarget: Konva.Node, target: Konva.Node | undefined): void;
+  closeContextMenu(): void;
+  private getSelectionPlugin;
+  cancelLongPressTimer(): void;
+  private initEvents;
+  private getStageClickPoint;
+  isContextMenuVisible(): boolean;
+  isTapHold(): boolean;
+  enable(): void;
+  disable(): void;
+}
+
+//#endregion
+//#region src/plugins/nodes-edge-snapping/constants.d.ts
+//# sourceMappingURL=context-menu.d.ts.map
+
+declare const GUIDE_ORIENTATION: {
+  readonly HORIZONTAL: "H";
+  readonly VERTICAL: "V";
+};
+declare const NODE_SNAP: {
+  readonly START: "start";
+  readonly CENTER: "center";
+  readonly END: "end";
+};
+
+//#endregion
+//#region src/plugins/nodes-edge-snapping/types.d.ts
+//# sourceMappingURL=constants.d.ts.map
+type NodeSnapKeys = keyof typeof NODE_SNAP;
+type NodeSnap = (typeof NODE_SNAP)[NodeSnapKeys];
+type NodeSnappingEdge = {
+  nodeId: string;
+  guide: number;
+  offset: number;
+  snap: NodeSnap;
+};
+type NodeSnappingEdges = {
+  vertical: NodeSnappingEdge[];
+  horizontal: NodeSnappingEdge[];
+};
+type LineGuideStop = {
+  vertical: number[];
+  horizontal: number[];
+};
+type GuideOrientationKeys = keyof typeof GUIDE_ORIENTATION;
+type GuideOrientation = (typeof GUIDE_ORIENTATION)[GuideOrientationKeys];
+type Guide = {
+  lineGuide: number;
+  offset: number;
+  orientation: GuideOrientation;
+  snap: NodeSnap;
+};
+type WeaveNodesEdgeSnappingPluginConfig = {
+  guideLine: Konva.LineConfig;
+  dragSnappingThreshold: number;
+  transformSnappingThreshold: number;
+};
+type WeaveNodesEdgeSnappingPluginParams = {
+  config?: WeaveNodesEdgeSnappingPluginConfig;
+};
+
+//#endregion
+//#region src/plugins/nodes-edge-snapping/nodes-edge-snapping.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveNodesEdgeSnappingPlugin extends WeavePlugin {
+  private readonly guideLineConfig;
+  private readonly dragSnappingThreshold;
+  private readonly transformSnappingThreshold;
+  onRender: undefined;
+  constructor(params?: Partial<WeaveNodesEdgeSnappingPluginParams>);
+  getName(): string;
+  onInit(): void;
+  setEnabled(enabled: boolean): void;
+  deleteGuides(): void;
+  evaluateGuidelines(e: KonvaEventObject<any>): void;
+  private getSelectionParentNode;
+  cleanupGuidelines(): void;
+  private initEvents;
+  getLineGuideStops(parent: Konva.Node, nodes: Konva.Node[]): LineGuideStop;
+  getObjectSnappingEdges(node: Konva.Node): NodeSnappingEdges;
+  getGuides(lineGuideStops: LineGuideStop, itemBounds: NodeSnappingEdges, type: string): Guide[];
+  private sortedGuides;
+  drawGuides(guides: Guide[]): void;
+  enable(): void;
+  disable(): void;
+}
+
+//#endregion
+//#region src/plugins/nodes-distance-snapping/constants.d.ts
+//# sourceMappingURL=nodes-edge-snapping.d.ts.map
+
+type WeaveNodesDistanceSnappingPluginConfig = {
+  enterSnappingTolerance: number;
+  exitSnappingTolerance: number;
+  ui: WeaveNodesDistanceSnappingUIConfig;
+};
+type WeaveNodesDistanceSnappingPluginParams = {
+  config?: DeepPartial<WeaveNodesDistanceSnappingPluginConfig>;
+};
+type WeaveNodesDistanceSnappingUIConfig = {
+  line: {
+    stroke: string;
+    strokeWidth: number;
+  };
+  label: {
+    height: number;
+    cornerRadius: number;
+    fill: string;
+    fontSize: number;
+    fontFamily: string;
+    fontStyle: string;
+    linePadding: number;
+    paddingX: number;
+  };
+};
+
+//#endregion
+//#region src/plugins/nodes-distance-snapping/nodes-distance-snapping.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveNodesDistanceSnappingPlugin extends WeavePlugin {
+  private readonly uiConfig;
+  private readonly enterSnappingTolerance;
+  private readonly exitSnappingTolerance;
+  private peerDistanceX;
+  private peerDistanceY;
+  private snapPositionX;
+  private snapPositionY;
+  private currentSizeSnapHorizontal;
+  private currentSizeSnapVertical;
+  private referenceLayer;
+  onRender: undefined;
+  constructor(params?: Partial<WeaveNodesDistanceSnappingPluginParams>);
+  getName(): string;
+  onInit(): void;
+  setEnabled(enabled: boolean): void;
+  deleteGuides(): void;
+  evaluateGuidelines(e: KonvaEventObject<any>): void;
+  private getBoxClientRect;
+  private getSelectionParentNode;
+  private getPeers;
+  private validateHorizontalSnapping;
+  private validateVerticalSnapping;
+  private setNodeClientRectX;
+  private setNodeClientRectY;
+  cleanupGuidelines(): void;
+  private initEvents;
+  private isOverlapping;
+  private getVerticallyIntersectingNodes;
+  private getHorizontallyIntersectingNodes;
+  private drawSizeGuidesHorizontally;
+  private drawSizeGuidesVertically;
+  private renderDistanceLabel;
+  private renderHorizontalLineWithDistanceBetweenNodes;
+  private renderVerticalLineWithDistanceBetweenNodes;
+  enable(): void;
+  disable(): void;
+}
+
+//#endregion
+//#region src/plugins/stage-grid/constants.d.ts
+//# sourceMappingURL=nodes-distance-snapping.d.ts.map
+
+declare const WEAVE_GRID_TYPES: {
+  readonly LINES: "lines";
+  readonly DOTS: "dots";
+};
+//#endregion
+//#region src/plugins/stage-grid/types.d.ts
+//# sourceMappingURL=constants.d.ts.map
+type WeaveStageGridPluginConfig = {
+  type: WeaveStageGridType;
+  gridColor: string;
+  gridOriginColor: string;
+  gridSize: number;
+  gridMajorEvery?: number;
+  gridMajorRatio?: number;
+  gridStroke?: number;
+  gridDotRadius?: number;
+  gridDotMaxDotsPerAxis: number;
+};
+type WeaveStageGridPluginParams = {
+  config?: Partial<WeaveStageGridPluginConfig>;
+};
+type WeaveStageGridTypeKeys = keyof typeof WEAVE_GRID_TYPES;
+type WeaveStageGridType = (typeof WEAVE_GRID_TYPES)[WeaveStageGridTypeKeys];
+
+//#endregion
+//#region src/plugins/stage-grid/stage-grid.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveStageGridPlugin extends WeavePlugin {
+  private moveToolActive;
+  private isMouseMiddleButtonPressed;
+  private isSpaceKeyPressed;
+  private actStageZoomX;
+  private actStageZoomY;
+  private actStagePosX;
+  private actStagePosY;
+  private config;
+  constructor(params?: Partial<WeaveStageGridPluginParams>);
+  getName(): string;
+  getLayerName(): string;
+  initLayer(): void;
+  onInit(): void;
+  private initEvents;
+  getLayer(): Konva.Layer | undefined;
+  getAdaptiveSpacing(scale: number): number;
+  private getAdjustedSpacing;
+  private renderGridLines;
+  private renderGridDots;
+  private hasStageChanged;
+  renderGrid(): void;
+  onRender(): void;
+  enable(): void;
+  disable(): void;
+  getType(): WeaveStageGridType;
+  setType(type: WeaveStageGridType): void;
+}
+
+//#endregion
+//#region src/plugins/stage-zoom/constants.d.ts
+//# sourceMappingURL=stage-grid.d.ts.map
+
+type WeaveStageZoomPluginConfig = {
+  zoomSteps: number[];
+  defaultZoom: number;
+  fitToScreen: {
+    padding: number;
+  };
+  fitToSelection: {
+    padding: number;
+  };
+  zoomInertia: {
+    friction: number;
+    mouseWheelStep: number;
+    trackpadStep: number;
+  };
+};
+type WeaveStageZoomPluginParams = {
+  config?: DeepPartial<WeaveStageZoomPluginConfig>;
+};
+
+//#endregion
+//#region src/plugins/stage-zoom/stage-zoom.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveStageZoomPlugin extends WeavePlugin {
+  private isCtrlOrMetaPressed;
+  protected previousPointer: string | null;
+  getLayerName: undefined;
+  initLayer: undefined;
+  onRender: undefined;
+  private config;
+  private actualScale;
+  private actualStep;
+  private updatedMinimumZoom;
+  private pinching;
+  private zooming;
+  private isTrackpad;
+  private zoomVelocity;
+  private zoomInertiaType;
+  defaultStep: number;
+  constructor(params?: WeaveStageZoomPluginParams);
+  getName(): string;
+  onInit(): void;
+  setZoom(scale: number, centered?: boolean, pointer?: Konva.Vector2d): void;
+  canZoomOut(): boolean;
+  canZoomIn(): boolean;
+  zoomToStep(step: number): void;
+  private findClosestStepIndex;
+  zoomIn(pointer?: Konva.Vector2d): void;
+  zoomOut(pointer?: Konva.Vector2d): void;
+  minimumZoom(): number;
+  fitToScreen(options?: {
+    overrideZoom: boolean;
+  }): void;
+  private fitToElements;
+  fitToNodes(nodes: string[], options?: {
+    smartZoom?: boolean;
+    overrideZoom?: boolean;
+  }): void;
+  fitToSelection(options?: {
+    smartZoom?: boolean;
+    overrideZoom?: boolean;
+  }): void;
+  enable(): void;
+  disable(): void;
+  getDistance(p1: Konva.Vector2d, p2: Konva.Vector2d): number;
+  getCenter(p1: Konva.Vector2d, p2: Konva.Vector2d): {
+    x: number;
+    y: number;
+  };
+  private initEvents;
+  getInertiaScale(): number;
+  zoomTick(): void;
+  isPinching(): boolean;
+  getStageGridPlugin(): WeaveStageGridPlugin | undefined;
+  getNodesSelectionPlugin(): WeaveNodesSelectionPlugin | undefined;
+  getContextMenuPlugin(): WeaveContextMenuPlugin | undefined;
+  getZoomSteps(): number[];
+  private clamp;
+}
+
+//#endregion
+//#region src/plugins/stage-panning/types.d.ts
+//# sourceMappingURL=stage-zoom.d.ts.map
+type WeaveStagePanningPluginParams = {
+  config?: Partial<WeaveStagePanningPluginConfig>;
+};
+type WeaveStagePanningPluginConfig = {
+  edgePanOffset: number;
+  edgePanMinSpeed: number;
+  edgePanSpeed: number;
+  edgePanMaxSpeed: number;
+};
+
+//#endregion
+//#region src/plugins/stage-panning/stage-panning.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveStagePanningPlugin extends WeavePlugin {
+  private readonly config;
+  private moveToolActive;
+  private isMouseLeftButtonPressed;
+  private isMouseMiddleButtonPressed;
+  private isCtrlOrMetaPressed;
+  private isDragging;
+  private enableMove;
+  private isSpaceKeyPressed;
+  private pointers;
+  private panning;
+  protected previousPointer: string | null;
+  protected currentPointer: Konva.Vector2d | null;
+  protected stageScrollInterval: NodeJS.Timeout | undefined;
+  protected panEdgeTargets: Record<string, Konva.Node | undefined>;
+  getLayerName: undefined;
+  initLayer: undefined;
+  onRender: undefined;
+  constructor(params?: WeaveStagePanningPluginParams);
+  getName(): string;
+  onInit(): void;
+  private setCursor;
+  private disableMove;
+  private initEvents;
+  isPanning(): boolean;
+  getDistance(p1: Konva.Vector2d, p2: Konva.Vector2d): number;
+  getTouchCenter(): {
+    x: number;
+    y: number;
+  } | null;
+  getZoomPlugin(): WeaveStageZoomPlugin | undefined;
+  getContextMenuPlugin(): WeaveContextMenuPlugin | undefined;
+  getNodesSelectionPlugin(): WeaveNodesSelectionPlugin | undefined;
+  getNodesEdgeSnappingPlugin(): WeaveNodesEdgeSnappingPlugin | undefined;
+  getNodesDistanceSnappingPlugin(): WeaveNodesDistanceSnappingPlugin | undefined;
+  getStageGridPlugin(): WeaveStageGridPlugin | undefined;
+  getCurrentPointer(): konva_lib_types6.Vector2d | null;
+  cleanupEdgeMoveIntervals(): void;
+  enable(): void;
+  disable(): void;
+}
+
+//#endregion
+//#region src/plugins/nodes-multi-selection-feedback/types.d.ts
+//# sourceMappingURL=stage-panning.d.ts.map
+type WeaveNodesMultiSelectionFeedbackStyle = {
+  stroke: string;
+  strokeWidth: number;
+  fill: string;
+};
+type WeaveNodesMultiSelectionFeedbackConfig = {
+  style: WeaveNodesMultiSelectionFeedbackStyle;
+};
+type WeaveNodesMultiSelectionFeedbackPluginConfig = DeepPartial<WeaveNodesMultiSelectionFeedbackConfig>;
+type WeaveNodesMultiSelectionFeedbackPluginParams = {
+  config?: WeaveNodesMultiSelectionFeedbackPluginConfig;
+};
+
+//#endregion
+//#region src/plugins/nodes-multi-selection-feedback/nodes-multi-selection-feedback.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveNodesMultiSelectionFeedbackPlugin extends WeavePlugin {
+  private config;
+  protected selectedHalos: Record<string, Konva.Rect>;
+  onRender: undefined;
+  onInit: undefined;
+  constructor(params?: WeaveNodesMultiSelectionFeedbackPluginParams);
+  getName(): string;
+  getLayerName(): string;
+  initLayer(): void;
+  getSelectedHalos(): Record<string, konva_lib_shapes_Rect10.Rect>;
+  cleanupSelectedHalos(): void;
+  private getNodeRectInfo;
+  private getNodeInfo;
+  createSelectionHalo(node: Konva.Node): void;
+  destroySelectionHalo(node: Konva.Node): void;
+  updateSelectionHalo(node: Konva.Node): void;
+  showSelectionHalo(node: Konva.Node): void;
+  hideSelectionHalo(node: Konva.Node): void;
+  private getLayer;
+  enable(): void;
+  disable(): void;
+}
+
+//#endregion
+//#region src/plugins/users-presence/constants.d.ts
+//# sourceMappingURL=nodes-multi-selection-feedback.d.ts.map
+
+//#endregion
+//#region src/plugins/users-presence/types.d.ts
+//# sourceMappingURL=constants.d.ts.map
+type WeaveUsersPresencePluginConfig = {
+  getUser: () => WeaveUser;
+};
+type WeaveUsersPresencePluginParams = {
+  config: Pick<WeaveUsersPresencePluginConfig, 'getUser'> & Partial<Omit<WeaveUsersPresencePluginConfig, 'getUser'>>;
+};
+//#endregion
+//#region src/plugins/users-presence/users-presence.d.ts
+//# sourceMappingURL=types.d.ts.map
+declare class WeaveUsersPresencePlugin extends WeavePlugin {
+  private readonly config;
+  private userPresence;
+  onRender: undefined;
+  constructor(params: WeaveUsersPresencePluginParams);
+  getName(): string;
+  onInit(): void;
+  sendPresence(): void;
+  setPresence<T>(nodeId: string, attrs: T, forceUpdate?: boolean): void;
+  forceSendPresence(): void;
+  enable(): void;
+  disable(): void;
+}
+
+//#endregion
+//#region src/plugins/nodes-selection/nodes-selection.d.ts
+//# sourceMappingURL=users-presence.d.ts.map
+declare class WeaveNodesSelectionPlugin extends WeavePlugin {
+  private tr;
+  private trHover;
+  private config;
+  private selectionRectangle;
+  private active;
+  private defaultEnabledAnchors;
+  private selecting;
+  private didMove;
+  private initialized;
+  private isCtrlMetaPressed;
+  private isSpaceKeyPressed;
+  protected taps: number;
+  protected isDoubleTap: boolean;
+  protected previousTap: {
+    x: number;
+    y: number;
+    time: number;
+  } | null;
+  protected tapStart: {
+    x: number;
+    y: number;
+    time: number;
+  } | null;
+  protected tapTimeoutId: NodeJS.Timeout | null;
+  private x1;
+  private y1;
+  private x2;
+  private y2;
+  private selectionStart;
+  private panSpeed;
+  private readonly panDirection;
+  private pointers;
+  private panLoopId;
+  private prevSelectedNodes;
+  private handledClickOrTap;
+  private dragInProcess;
+  private dragSelectedNodes;
+  private transformInProcess;
+  onRender: undefined;
+  constructor(params?: WeaveNodesSelectionPluginParams);
+  getName(): string;
+  getLayerName(): string;
+  getConfiguration(): WeaveNodesSelectionConfig;
+  initLayer(): void;
+  isPasting(): boolean;
+  isAreaSelecting(): boolean;
+  isSelecting(): boolean;
+  isNodeSelected(ele: Konva.Node): boolean;
+  onInit(): void;
+  private handleUndoRedoSelectionChange;
+  private getLayer;
+  triggerSelectedNodesEvent(): void;
+  removeSelectedNodes(): void;
+  private updateSelectionRect;
+  private getSpeedFromEdge;
+  private updatePanDirection;
+  private stopPanLoop;
+  private panLoop;
+  private setTapStart;
+  private checkMovedDrag;
+  private checkMoved;
+  private checkDoubleTap;
+  private hideSelectorArea;
+  private initEvents;
+  private handleMultipleSelectionBehavior;
+  protected syncSelection(): void;
+  protected getSelectionPlugin(): WeaveNodesSelectionPlugin | undefined;
+  protected hideHoverState(): void;
+  handleClickOrTap(e: KonvaEventObject<PointerEvent, Stage>): void;
+  getTransformer(): Konva.Transformer;
+  getHoverTransformer(): Konva.Transformer;
+  handleBehaviors(): void;
+  setSelectedNodes(nodes: Konva.Node[]): void;
+  getSelectedNodes(): (konva_lib_Group7.Group | konva_lib_Shape9.Shape<konva_lib_Shape8.ShapeConfig>)[];
+  getSelectedNodesExtended(): WeaveSelection[];
+  selectAll(): void;
+  selectNone(): void;
+  enable(): void;
+  disable(): void;
+  getNodesSelectionFeedbackPlugin(): WeaveNodesMultiSelectionFeedbackPlugin | undefined;
+  getContextMenuPlugin(): WeaveContextMenuPlugin | undefined;
+  getStageGridPlugin(): WeaveStageGridPlugin | undefined;
+  getNodesEdgeSnappingPlugin(): WeaveNodesEdgeSnappingPlugin | undefined;
+  getNodesDistanceSnappingPlugin(): WeaveNodesDistanceSnappingPlugin | undefined;
+  getStagePanningPlugin(): WeaveStagePanningPlugin | undefined;
+  getUsersPresencePlugin(): WeaveUsersPresencePlugin | undefined;
+  isTransforming(): boolean;
+  isDragging(): boolean;
+  getSelectorConfig(): TransformerConfig;
+  saveDragSelectedNodes(): void;
+  getDragSelectedNodes(): Konva.Node[];
+  setNodesOpacityOnDrag(): void;
+  restoreNodesOpacityOnDrag(): void;
+  getDragOpacity(): number;
+}
+
+//#endregion
+//#region src/nodes/node.d.ts
+//# sourceMappingURL=nodes-selection.d.ts.map
+declare abstract class WeaveNode implements WeaveNodeBase {
+  protected instance: Weave;
+  protected nodeType: string;
+  protected didMove: boolean;
+  protected logger: Logger;
+  protected previousPointer: string | null;
+  register(instance: Weave): WeaveNode;
+  getNodeType(): string;
+  getLogger(): Logger;
+  getSelectionPlugin(): WeaveNodesSelectionPlugin | undefined;
+  isSelecting(): boolean;
+  isPasting(): boolean;
+  setupDefaultNodeAugmentation(node: Konva.Node): void;
+  isNodeSelected(ele: Konva.Node): boolean;
+  scaleReset(node: Konva.Node): void;
+  protected setHoverState(node: Konva.Node): void;
+  protected hideHoverState(): void;
+  setupDefaultNodeEvents(node: Konva.Node): void;
+  handleMouseOver(node: Konva.Node): boolean;
+  handleMouseout(node: Konva.Node): void;
+  create(key: string, props: WeaveElementAttributes): WeaveStateElement;
+  onRegister(): void;
+  onAdd(nodeInstance: WeaveElementInstance): void;
+  abstract onRender(props: WeaveElementAttributes): WeaveElementInstance;
+  abstract onUpdate(nodeInstance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
+  onDestroy(nodeInstance: WeaveElementInstance): void;
+  onDestroyInstance(): void;
+  serialize(instance: WeaveElementInstance): WeaveStateElement;
+  show(instance: Konva.Node): void;
+  hide(instance: Konva.Node): void;
+  isVisible(instance: Konva.Node): boolean;
+  lock(instance: Konva.Node): void;
+  unlock(instance: Konva.Node): void;
+  isLocked(instance: Konva.Node): boolean;
+  protected defaultGetTransformerProperties(nodeTransformConfig?: any): any;
+  protected getNodesSelectionPlugin(): WeaveNodesSelectionPlugin | undefined;
+  protected getNodesEdgeSnappingPlugin(): WeaveNodesEdgeSnappingPlugin | undefined;
+  protected getNodesDistanceSnappingPlugin(): WeaveNodesDistanceSnappingPlugin | undefined;
+  realOffset(instance: WeaveStateElement): Konva.Vector2d;
+  private getRealSelectedNode;
+  getNodesSelectionFeedbackPlugin(): WeaveNodesMultiSelectionFeedbackPlugin | undefined;
+  getUsersPresencePlugin(): WeaveUsersPresencePlugin | undefined;
+  getIsAsync(): boolean;
+}
+
+//#endregion
+//#region src/actions/action.d.ts
+//# sourceMappingURL=node.d.ts.map
+declare abstract class WeaveAction implements WeaveActionBase {
+  protected instance: Weave;
+  protected name: string;
+  protected tapStart: {
+    x: number;
+    y: number;
+    time: number;
+  } | null;
+  props: WeaveElementAttributes;
+  private logger;
+  constructor();
+  getName(): string;
+  hasAliases(): boolean;
+  getAliases(): string[];
+  getLogger(): Logger;
+  register(instance: Weave): WeaveAction;
+  updateProps(props: WeaveElementAttributes): void;
+  getProps(): WeaveElementAttributes;
+  isPressed(e: KonvaEventObject<PointerEvent, Konva.Stage>): boolean;
+  setTapStart(e: KonvaEventObject<PointerEvent, Konva.Stage>): void;
+  isTap(e: KonvaEventObject<PointerEvent, Konva.Stage>): boolean;
+  abstract onInit?(): void;
+  abstract trigger(cancelAction: () => void, params?: unknown): unknown;
+  abstract onPropsChange?(): void;
+  abstract cleanup?(): void;
+}
+
+//#endregion
+//#region src/renderer/renderer.d.ts
+//# sourceMappingURL=action.d.ts.map
+declare abstract class WeaveRenderer extends WeaveRendererBase {
+  protected instance: Weave;
+  protected logger: Logger;
+  getLogger(): Logger;
+  register(instance: Weave): this;
+}
+
+//#endregion
+//#region src/logger/logger.d.ts
+//# sourceMappingURL=renderer.d.ts.map
+declare class WeaveLogger {
+  private readonly instance;
+  private config;
+  private disabled;
+  private logger;
+  constructor(instance: Weave, config: WeaveLoggerConfig);
+  private log;
+  getDisabled(): boolean;
+  getLevel(): pino.LevelWithSilentOrString;
+  getLogger(): Logger;
+  getChildLogger(name: string): pino.Logger<never, boolean>;
+}
+
+//#endregion
+//#region src/managers/targeting.d.ts
+//# sourceMappingURL=logger.d.ts.map
+declare class WeaveTargetingManager {
+  private instance;
+  private logger;
+  constructor(instance: Weave);
+  resolveNode(node: Konva.Node): Konva.Node | undefined;
+  pointIntersectsElement(point?: Konva.Vector2d): Konva.Node | null;
+  isBoundingBoxIntersecting(nodeA: Konva.Node, nodeB: Konva.Node): boolean;
+  isNodesBoundingBoxIntersecting(nodes: Konva.Node[], nodeB: Konva.Node): boolean;
+  nodeIntersectsContainerElement(node: Konva.Node | Konva.Transformer, actualLayer?: Konva.Layer | Konva.Group): Konva.Node | undefined;
+  getMousePointer(point?: Konva.Vector2d): WeaveMousePointInfo;
+  getMousePointerRelativeToContainer(container: Konva.Node | Konva.Layer): WeaveMousePointInfoSimple;
+  getRealSelectedNode: (nodeTarget: Konva.Node) => konva_lib_Node19.Node<konva_lib_Node18.NodeConfig>;
+}
+
+//#endregion
+//#region src/managers/cloning.d.ts
+//# sourceMappingURL=targeting.d.ts.map
+declare class WeaveCloningManager {
+  private instance;
+  private logger;
+  private clones;
+  constructor(instance: Weave);
+  nodesToGroupSerialized(instancesToClone: Konva.Node[]): {
+    serializedNodes: WeaveStateElement[];
+    minPoint: Konva.Vector2d;
+  } | undefined;
+  private recursivelyUpdateKeys;
+  cloneNode(targetNode: Konva.Node): Konva.Node | undefined;
+  addClone(node: Konva.Node): void;
+  removeClone(node: Konva.Node): void;
+  getClones(): konva_lib_Node21.Node<konva_lib_Node20.NodeConfig>[];
+  isClone(node: Konva.Node): konva_lib_Node23.Node<konva_lib_Node22.NodeConfig> | undefined;
+  cleanupClones(): void;
+}
+
+//#endregion
+//#region src/managers/register.d.ts
+//# sourceMappingURL=cloning.d.ts.map
+declare class WeaveRegisterManager {
+  private instance;
+  private nodesHandlers;
+  private actionsHandlers;
+  private plugins;
+  private logger;
+  constructor(instance: Weave);
+  getPlugins(): Record<string, WeavePlugin>;
+  getNodesHandlers(): Record<string, WeaveNode>;
+  getActionsHandlers(): Record<string, WeaveAction>;
+  getPlugin<T>(pluginName: string): T | undefined;
+  getActionHandler<T>(actionName: string): T | undefined;
+  getNodeHandler<T>(nodeType: string): T | undefined;
+  registerPlugins(): void;
+  registerPlugin(plugin: WeavePlugin): void;
+  registerNodesHandlers(): void;
+  registerNodeHandler(node: WeaveNode): void;
+  registerActionsHandlers(): void;
+  registerActionHandler(action: WeaveAction): void;
+}
+
+//#endregion
+//#region src/managers/stage.d.ts
+//# sourceMappingURL=register.d.ts.map
+declare class WeaveStageManager {
+  private instance;
+  private logger;
+  private stage;
+  private config;
+  constructor(instance: Weave, config: Konva.StageConfig);
+  getConfiguration(): StageConfig;
+  setStage(stage: Konva.Stage): void;
+  getStage(): Konva.Stage;
+  getMainLayer(): Konva.Layer | undefined;
+  getSelectionLayer(): Konva.Layer | undefined;
+  getCommentsLayer(): Konva.Layer | undefined;
+  getGridLayer(): Konva.Layer | undefined;
+  getUtilityLayer(): Konva.Layer | undefined;
+  getInstanceRecursive(instance: Konva.Node, filterInstanceType?: string[]): Konva.Node;
+  initStage(): void;
+  getContainerNodes(): WeaveElementInstance[];
+}
+
+//#endregion
+//#region src/types.d.ts
+//# sourceMappingURL=stage.d.ts.map
+type DOMElement = HTMLElement | Element | null;
+
+//#endregion
+//#region src/weave.d.ts
+//# sourceMappingURL=types.d.ts.map
+
+declare class Weave {
+  private id;
+  private emitter;
+  private config;
+  private logger;
+  private moduleLogger;
+  private renderer;
+  private initialized;
+  private status;
+  private setupManager;
+  private registerManager;
+  private stateManager;
+  private storeManager;
+  private stageManager;
+  private groupsManager;
+  private targetingManager;
+  private cloningManager;
+  private fontsManager;
+  private zIndexManager;
+  private pluginsManager;
+  private actionsManager;
+  private exportManager;
+  private readonly usersManager;
+  private readonly mutexManager;
+  private readonly asyncManager;
+  private readonly hooksManager;
+  private readonly dragAndDropManager;
+  constructor(weaveConfig: Pick<WeaveConfig, 'store' | 'renderer'> & DeepPartial<Omit<WeaveConfig, 'store' | 'renderer'>>, stageConfig: Konva.StageConfig);
+  getRenderer(): WeaveRenderer;
+  setupRenderer(): void;
+  setStatus(status: WeaveStatus): void;
+  getStatus(): WeaveStatus;
+  setStore(store: WeaveStore): void;
+  private handleStoreConnectionStatusChange;
+  start(): Promise<void>;
+  destroy(): void;
+  getId(): string;
+  getConfiguration(): WeaveConfig;
+  augmentKonvaStageClass(): void;
+  augmentKonvaNodeClass(config?: WeaveNodeConfiguration): void;
+  emitEvent<T>(event: string, payload?: T): void;
+  addEventListener<T>(event: string, callback: (payload: T) => void): void;
+  addOnceEventListener<T>(event: string, callback: (payload: T) => void): void;
+  removeEventListener<T>(event: string, callback: (payload: T) => void): void;
+  emitUserChangeEvent(data: {
+    node: WeaveStateElement;
+    parentId?: string;
+  }, changeType: WeaveNodeChangeType): void;
+  private setTransactionIdToInstance;
+  private cleanupTransactionIdToInstance;
+  private decorateWithZIndex;
+  getLogger(): WeaveLogger;
+  getMainLogger(): Logger;
+  getChildLogger(name: string): pino.Logger<never, boolean>;
+  getStageManager(): WeaveStageManager;
+  getStage(): Konva.Stage;
+  getMainLayer(): Konva.Layer | undefined;
+  getSelectionLayer(): Konva.Layer | undefined;
+  getCommentsLayer(): Konva.Layer | undefined;
+  getGridLayer(): Konva.Layer | undefined;
+  getUtilityLayer(): Konva.Layer | undefined;
+  setStage(stage: Konva.Stage): void;
+  getStageConfiguration(): StageConfig;
+  getInstanceRecursive(instance: Konva.Node, filterInstanceType?: string[]): Konva.Node;
+  getContainerNodes(): WeaveElementInstance[];
+  getClosestParentWithWeaveId(el: DOMElement): DOMElement;
+  getRegisterManager(): WeaveRegisterManager;
+  getPlugins(): Record<string, WeavePlugin>;
+  getPlugin<T>(pluginName: string): T | undefined;
+  getNodesHandlers(): Record<string, WeaveNode>;
+  getNodeHandler<T>(nodeType: string): T | undefined;
+  getActionsHandlers(): Record<string, WeaveAction>;
+  getActionHandler<T>(actionName: string): T | undefined;
+  getStore<T extends WeaveStore>(): T;
+  registerPlugin(plugin: WeavePlugin): void;
+  registerNodeHandler(node: WeaveNode): void;
+  registerActionHandler(action: WeaveAction): void;
+  registerStore(store: WeaveStore): void;
+  isPluginEnabled(pluginName: string): boolean;
+  enablePlugin(pluginName: string): void;
+  disablePlugin(pluginName: string): void;
+  getActiveAction(): string | undefined;
+  triggerAction<T, P>(actionName: string, params?: T): P;
+  getPropsAction(actionName: string): WeaveElementAttributes;
+  updatePropsAction(actionName: string, params: WeaveElementAttributes): void;
+  cancelAction(actionName: string): void;
+  update(newState: WeaveState): void;
+  render(): void;
+  findNodeById(tree: WeaveStateElement, key: string, parent?: WeaveStateElement | null, index?: number): WeaveNodeFound;
+  findNodesByType(tree: WeaveStateElement, nodeType: string): WeaveStateElement[];
+  getNode(nodeKey: string): {
+    node: WeaveStateElement | null;
+    parent: WeaveStateElement | null;
+    index: number;
+  };
+  addNode(node: WeaveStateElement, parentId?: string, options?: {
+    index?: number;
+    emitUserChangeEvent?: boolean;
+    overrideUserChangeType?: WeaveNodeChangeType;
+  }): void;
+  addNodeNT(node: WeaveStateElement, parentId?: string, options?: {
+    index?: number;
+    emitUserChangeEvent?: boolean;
+    overrideUserChangeType?: WeaveNodeChangeType;
+  }): void;
+  updateNode(node: WeaveStateElement, options?: {
+    emitUserChangeEvent?: boolean;
+  }): void;
+  updateNodeNT(node: WeaveStateElement, options?: {
+    emitUserChangeEvent?: boolean;
+  }): void;
+  updateNodes(nodes: WeaveStateElement[], options?: {
+    emitUserChangeEvent?: boolean;
+  }): void;
+  updateNodesNT(nodes: WeaveStateElement[], options?: {
+    emitUserChangeEvent?: boolean;
+  }): void;
+  removeNode(node: WeaveStateElement, options?: {
+    emitUserChangeEvent?: boolean;
+  }): void;
+  removeNodeNT(node: WeaveStateElement, options?: {
+    emitUserChangeEvent?: boolean;
+  }): void;
+  removeNodes(nodes: WeaveStateElement[], options?: {
+    emitUserChangeEvent?: boolean;
+  }): void;
+  removeNodesNT(nodes: WeaveStateElement[], options?: {
+    emitUserChangeEvent?: boolean;
+  }): void;
+  zMoveNode(node: WeaveStateElement, position: WeavePosition, options?: {
+    emitUserChangeEvent?: boolean;
+  }): void;
+  zMoveNodeNT(node: WeaveStateElement, position: WeavePosition, options?: {
+    emitUserChangeEvent?: boolean;
+  }): void;
+  getElementsTree(): WeaveStateElement[];
+  isEmpty(): boolean;
+  getContainerByNodeId(nodeId: string): string | undefined;
+  getNodeContainerId(node: WeaveElementInstance | Konva.Node): string;
+  getNodeContainer(node: WeaveElementInstance | Konva.Node): Konva.Node | null;
+  getBoundingBox(nodes: Konva.Node[], config?: {
+    skipTransform?: boolean;
+    skipShadow?: boolean;
+    skipStroke?: boolean;
+    relativeTo?: Konva.Container;
+  } | undefined): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  };
+  stateTransactional(callback: () => void): void;
+  moveUp(node: WeaveElementInstance): void;
+  moveDown(node: WeaveElementInstance): void;
+  sendToBack(nodes: WeaveElementInstance | WeaveElementInstance[]): void;
+  bringToFront(nodes: WeaveElementInstance | WeaveElementInstance[]): void;
+  group(nodes: WeaveStateElement[]): void;
+  unGroup(group: WeaveStateElement): void;
+  getTargetingManager(): WeaveTargetingManager;
+  resolveNode(node: Konva.Node): WeaveElementInstance | undefined;
+  pointIntersectsElement(point?: Konva.Vector2d): Konva.Node | null;
+  nodeIntersectsContainerElement(node: Konva.Node | Konva.Transformer, actualLayer?: Konva.Layer | Konva.Group): Konva.Node | undefined;
+  getMousePointer(point?: Konva.Vector2d): WeaveMousePointInfo;
+  getMousePointerRelativeToContainer(container: Konva.Node | Konva.Layer): WeaveMousePointInfoSimple;
+  selectNodesByKey(nodesIds: string[]): void;
+  getRealSelectedNode: (nodeTarget: Konva.Node) => konva_lib_Node13.Node<konva_lib_Node12.NodeConfig>;
+  getCloningManager(): WeaveCloningManager;
+  nodesToGroupSerialized(instancesToClone: Konva.Node[]): WeaveSerializedGroup;
+  getFonts(): WeaveFont[];
+  imageToBase64(img: HTMLImageElement, mimeType: string): string;
+  exportNodes(nodes: WeaveElementInstance[], boundingNodes: (nodes: Konva.Node[]) => Konva.Node[], options: WeaveExportNodesOptions): Promise<HTMLImageElement>;
+  exportNodesServerSide(nodes: string[], boundingNodes: (nodes: Konva.Node[]) => Konva.Node[], options: WeaveExportNodesOptions): Promise<{
+    composites: {
+      input: Buffer;
+      left: number;
+      top: number;
+    }[];
+    width: number;
+    height: number;
+  }>;
+  getExportBoundingBox(nodesIds: string[]): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  };
+  allNodesLocked(nodes: Konva.Node[]): boolean;
+  allNodesUnlocked(nodes: Konva.Node[]): boolean;
+  lockNode(node: Konva.Node): void;
+  lockNodes(nodes: Konva.Node[]): void;
+  unlockNode(node: Konva.Node): void;
+  unlockNodes(nodes: Konva.Node[]): void;
+  allNodesVisible(nodes: Konva.Node[]): boolean;
+  allNodesHidden(nodes: Konva.Node[]): boolean;
+  hideNode(node: Konva.Node): void;
+  hideNodes(nodes: Konva.Node[]): void;
+  showNode(node: Konva.Node): void;
+  showNodes(nodes: Konva.Node[]): void;
+  asyncElementsLoaded(): boolean;
+  loadAsyncElement(nodeId: string, type: string): void;
+  resolveAsyncElement(nodeId: string, type: string): void;
+  isServerSide(): boolean;
+  registerHook<T>(hookName: string, hook: (params: T) => void): void;
+  runPhaseHooks<T>(phaseName: string, execution: (hook: (params: T) => void) => void): void;
+  getHook<T>(hookName: string): T | undefined;
+  unregisterHook(hookName: string): void;
+  acquireMutexLock({
+    nodeIds,
+    operation
+  }: {
+    nodeIds: string[];
+    operation: string;
+  }, action: () => void | Promise<void>): Promise<void>;
+  setMutexLock<T>({
+    nodeIds,
+    operation,
+    metadata
+  }: {
+    nodeIds: string[];
+    operation: string;
+    metadata?: T;
+  }): boolean;
+  releaseMutexLock(): void;
+  getLockDetails<T>(lockId: string): WeaveUserMutexLock<T> | undefined;
+  getNodeMutexLock<T>(nodeId: string): WeaveNodeMutexLock<T> | undefined;
+  getUsers(): WeaveUser[];
+  getDragStartedId(): string | null;
+  isDragStarted(): boolean;
+  startDrag(id: string): void;
+  endDrag(id: string): void;
+  setDragProperties<T>(properties: T): void;
+  getDragProperties<T>(): T | null;
+} //#endregion
+//#region src/renderer.d.ts
+
+//#endregion
+//#region src/nodes/types.d.ts
+//# sourceMappingURL=weave.d.ts.map
+declare class WeaveKonvaBaseRenderer extends WeaveRenderer {
+  protected name: string;
+  private actualState;
+  private readonly reconciler;
+  constructor();
+  init(): void;
+  render(callback?: () => void): void;
+  getReconciler(): {
+    createInstance(instance: Weave, type: string, props: WeaveElementAttributes): WeaveElementInstance | undefined;
+    createRoot(instance: Weave, child: WeaveElementInstance): void;
+    appendChildToContainer(instance: Weave, parent: WeaveElementInstance, child: WeaveElementInstance, index: number): void;
+    removeChild(instance: Weave, parent: WeaveElementInstance | undefined, child: WeaveElementInstance): void;
+    commitUpdate(instance: Weave, node: WeaveElementInstance, type: string, prevProps: WeaveElementAttributes, nextProps: WeaveElementAttributes): void;
+  };
+  deriveRendererInstructions(prevState: WeaveState, nextState: WeaveState): void;
+  private reconcileNode;
+  private reconcileChildren;
+  findElementByKey(state: WeaveState, key: string): WeaveStateElement;
+  stripChildren(props: WeaveElementAttributes): {
+    [key: string]: any;
+    id?: string;
+    nodeType?: string;
+  };
+  buildSubtree(parentInstance: WeaveElementInstance | undefined, element: WeaveStateElement, index: number): void;
+  private createSubtree;
+  private remove;
+  private updateProps;
+}
+
+//#endregion
+//#region src/types.d.ts
+//# sourceMappingURL=renderer.d.ts.map
+type RendererInstruction = {
+  kind: 'CREATE_SUBTREE';
+  element: WeaveStateElement;
+  parentKey: string;
+  index: number;
+} | {
+  kind: 'REMOVE';
+  parentKey: string;
+  key: string;
+} | {
+  kind: 'UPDATE_PROPS';
+  key: string;
+  type: string;
+  prevProps: WeaveElementAttributes;
+  nextProps: WeaveElementAttributes;
+};
+
+//#endregion
+//# sourceMappingURL=types.d.ts.map
+
+export { RendererInstruction, WeaveKonvaBaseRenderer };
+//# sourceMappingURL=renderer-konva-base.d.ts.map