@inditextech/weave-store-websockets 0.77.0 → 1.0.1

package/dist/client.d.ts

@@ -1,12 +1,1070 @@
-import { WeaveStore } from "@inditextech/weave-sdk";
-import "konva";
+import Konva from "konva";
+import * as Y$1 from "yjs";
+import * as Y$2 from "yjs";
 import * as Y from "yjs";
 import { IncomingMessage } from "http";
 import { WebsocketProvider } from "y-websocket";
-import "konva/lib/types";
+import pino, { Logger } from "pino";
+import * as konva_lib_Node8 from "konva/lib/Node";
+import * as konva_lib_Node9 from "konva/lib/Node";
+import * as konva_lib_Node10 from "konva/lib/Node";
+import * as konva_lib_Node11 from "konva/lib/Node";
+import { KonvaEventObject } from "konva/lib/Node";
+import { Stage, StageConfig } from "konva/lib/Stage";
+import { TransformerConfig } from "konva/lib/shapes/Transformer";
+import * as konva_lib_types6 from "konva/lib/types";
+import "konva/lib/Group";
+import "konva/lib/Layer";
 
+//#region ../sdk/dist/sdk.d.ts
+
+//#region ../types/dist/types.d.ts
+//#region src/base/node.d.ts
+interface WeaveNodeBase {
+  getNodeType(): string;
+  create(id: string, props: WeaveElementAttributes): WeaveStateElement;
+  onAdd?(nodeInstance: WeaveElementInstance): void;
+  onRender(props: WeaveElementAttributes): WeaveElementInstance;
+  onUpdate(instance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
+  onDestroy(instance: WeaveElementInstance): void;
+  serialize(instance: WeaveElementInstance): WeaveStateElement;
+  setupDefaultNodeAugmentation(node: Konva.Node): void;
+  setupDefaultNodeEvents(node: Konva.Node): void;
+  isNodeSelected(ele: Konva.Node): boolean;
+  lock(instance: Konva.Node): void;
+  unlock(instance: Konva.Node): void;
+  isLocked(instance: Konva.Node): boolean;
+  isSelecting(): boolean;
+  isPasting(): boolean;
+}
+
+//#endregion
+//#region src/base/action.d.ts
+interface WeaveActionBase {
+  onInit?(): void;
+  trigger(cancelAction: () => void, params?: unknown): unknown;
+  internalUpdate?(): void;
+  cleanup?(): void;
+}
+
+//#endregion
+//#region src/base/plugin.d.ts
+interface WeavePluginBase {
+  onInit?(): void;
+  onRender?(): void;
+  enable(): void;
+  disable(): void;
+  isEnabled(): boolean;
+}
+
+//#endregion
+//#region src/base/store.d.ts
+type WeaveStoreOptions$1 = {
+  getUser: () => WeaveUser$1;
+  undoManagerOptions?: WeaveUndoManagerOptions$1;
+};
+interface WeaveStoreBase {
+  connect(): void;
+  disconnect(): void;
+  handleAwarenessChange(emit: boolean): void;
+  setAwarenessInfo(field: string, value: unknown): void;
+}
+
+//#endregion
+//#region src/types.d.ts
+type WeaveFontsPreloadFunction = () => Promise<WeaveFont[]>;
+type WeaveConfig = {
+  store: WeaveStoreBase;
+  nodes?: WeaveNodeBase[];
+  actions?: WeaveActionBase[];
+  plugins?: WeavePluginBase[];
+  fonts?: WeaveFont[] | WeaveFontsPreloadFunction;
+  logger?: WeaveLoggerConfig;
+  serverSide?: boolean;
+};
+type WeaveStatusKeys = keyof typeof WEAVE_INSTANCE_STATUS;
+type WeaveStatus = (typeof WEAVE_INSTANCE_STATUS)[WeaveStatusKeys];
+type WeaveElementAttributes = {
+  [key: string]: any;
+  id?: string;
+  nodeType?: string;
+  children?: WeaveStateElement[];
+};
+type WeaveStateElement = {
+  key: string;
+  type: string;
+  props: WeaveElementAttributes;
+};
+type WeaveState = {
+  weave: {
+    key: "stage";
+    type: "stage";
+    props: {
+      [key: string]: unknown;
+      id: "stage";
+      children: WeaveStateElement[];
+    };
+  } | Record<string, WeaveStateElement>;
+};
+type WeaveSelection = {
+  instance: Konva.Shape | Konva.Group;
+  node: WeaveStateElement | undefined;
+};
+type WeaveMousePointInfoSimple = {
+  mousePoint: Konva.Vector2d;
+  container: Konva.Layer | Konva.Node | undefined;
+};
+type WeaveMousePointInfo = WeaveMousePointInfoSimple & {
+  measureContainer: Konva.Layer | Konva.Group | undefined;
+};
+type WeaveSerializedGroup = {
+  serializedNodes: WeaveStateElement[];
+  minPoint: Konva.Vector2d;
+} | undefined;
+type WeaveNodeFound = {
+  node: WeaveStateElement | null;
+  parent: WeaveStateElement | null;
+  index: number;
+};
+type WeaveElementInstance = Konva.Layer | Konva.Group | Konva.Shape;
+type WeaveLoggerConfig = {
+  disabled?: boolean;
+  level?: "debug" | "info" | "warn" | "error";
+};
+type WeavePositionKeys = keyof typeof WEAVE_NODE_POSITION;
+type WeavePosition = (typeof WEAVE_NODE_POSITION)[WeavePositionKeys];
+type WeaveExportFormatsKeys = keyof typeof WEAVE_EXPORT_FORMATS;
+type WeaveExportFormats = (typeof WEAVE_EXPORT_FORMATS)[WeaveExportFormatsKeys];
+type WeaveExportNodesOptions = {
+  format?: WeaveExportFormats;
+  padding?: number;
+  pixelRatio?: number;
+  backgroundColor?: string;
+  quality?: number;
+  backend?: WeaveKonvaBackend;
+};
+type WeaveUser$1 = {
+  id: string;
+  name: string;
+  email: string;
+  [key: string]: any;
+};
+type WeaveFont = {
+  id: string;
+  name: string;
+  offsetX?: number;
+  offsetY?: number;
+};
+type WeaveUndoManagerOptions$1 = {
+  captureTimeout?: number;
+  trackedOrigins?: Set<any>;
+};
+type WeaveStoreConnectionStatusKeys = keyof typeof WEAVE_STORE_CONNECTION_STATUS;
+type WeaveStoreConnectionStatus = (typeof WEAVE_STORE_CONNECTION_STATUS)[WeaveStoreConnectionStatusKeys];
+declare type docElementTypeDescription = "xml" | "text" | Array<any> | object;
+declare type DocTypeDescription = {
+  [key: string]: docElementTypeDescription;
+};
+declare type MappedTypeDescription<T extends DocTypeDescription> = { readonly [P in keyof T]: T[P] extends "xml" ? Y$1.XmlFragment : T[P] extends "text" ? Y$1.Text : T[P] extends Array<any> ? T[P] : T[P] extends object ? Partial<T[P]> : never };
+type WeaveNodeTransformerProperties = Konva.TransformerConfig;
+type WeaveNodeConfiguration = {
+  transform: Partial<WeaveNodeTransformerProperties>;
+};
+type DeepPartial<T> = { [P in keyof T]?: T[P] extends object ? T[P] extends Function ? T[P] : DeepPartial<T[P]> : T[P] };
+type WeaveKonvaBackendKeys = keyof typeof WEAVE_KONVA_BACKEND;
+type WeaveKonvaBackend = (typeof WEAVE_KONVA_BACKEND)[WeaveKonvaBackendKeys];
+
+//#endregion
+//#region src/constants.d.ts
+
+declare const WEAVE_INSTANCE_STATUS: {
+  readonly "IDLE": "idle";
+  readonly "STARTING": "starting";
+  readonly "LOADING_FONTS": "loadingFonts";
+  readonly "CONNECTING_TO_ROOM": "connectingToRoom";
+  readonly "CONNECTING_ERROR": "connectingError";
+  readonly "LOADING_ROOM": "loadingRoom";
+  readonly "RUNNING": "running";
+};
+declare const WEAVE_NODE_POSITION: {
+  readonly "UP": "up";
+  readonly "DOWN": "down";
+  readonly "FRONT": "front";
+  readonly "BACK": "back";
+};
+declare const WEAVE_EXPORT_FORMATS: {
+  readonly "PNG": "image/png";
+  readonly "JPEG": "image/jpeg";
+};
+declare const WEAVE_STORE_CONNECTION_STATUS: {
+  readonly "ERROR": "error";
+  readonly "CONNECTING": "connecting";
+  readonly "CONNECTED": "connected";
+  readonly "DISCONNECTED": "disconnected";
+};
+declare const WEAVE_KONVA_BACKEND: {
+  readonly "CANVAS": "canvas";
+  readonly "SKIA": "skia";
+}; //#endregion
+//#region src/stores/store.d.ts
+
+//#endregion
+declare abstract class WeaveStore implements WeaveStoreBase {
+  protected instance: Weave;
+  protected name: string;
+  protected supportsUndoManager: boolean;
+  protected config: WeaveStoreOptions$1;
+  private state;
+  private latestState;
+  private document;
+  private logger;
+  private undoManager;
+  private isRoomLoaded;
+  constructor(config: WeaveStoreOptions$1);
+  getName(): string;
+  getLogger(): Logger;
+  register(instance: Weave): WeaveStore;
+  getUser(): WeaveUser$1;
+  setState(state: WeaveState): void;
+  setLatestState(newState: WeaveState): void;
+  getLatestState(): WeaveState;
+  getDocument(): Y$2.Doc;
+  getState(): MappedTypeDescription<WeaveState>;
+  getStateJson(): WeaveState;
+  getStateSnapshot(): Uint8Array;
+  setup(): void;
+  canUndoStateStep(): boolean;
+  canRedoStateStep(): boolean;
+  undoStateStep(): void;
+  redoStateStep(): void;
+  handleConnectionStatusChange(status: WeaveStoreConnectionStatus): void;
+  abstract connect(): 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;
+};
+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(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 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;
+  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;
+  private setZoom;
+  canZoomOut(): boolean;
+  canZoomIn(): boolean;
+  zoomToStep(step: number): void;
+  private findClosestStepIndex;
+  zoomIn(pointer?: Konva.Vector2d): void;
+  zoomOut(pointer?: Konva.Vector2d): void;
+  minimumZoom(): number;
+  fitToScreen(): void;
+  fitToSelection(smartZoom?: 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;
+}
+
+//#endregion
+//#region src/plugins/stage-panning/types.d.ts
+//# sourceMappingURL=stage-zoom.d.ts.map
+type WeaveStagePanningPluginParams = {
+  config?: Partial<WeaveStagePanningPluginConfig>;
+};
+type WeaveStagePanningPluginConfig = {
+  edgePanOffset: number;
+  edgePanSpeed: 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 targetScrollIntervals: Record<string, NodeJS.Timeout | 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-selection/nodes-selection.d.ts
+//# sourceMappingURL=stage-panning.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 isSpaceKeyPressed;
+  protected taps: number;
+  protected isDoubleTap: boolean;
+  protected tapStart: {
+    x: number;
+    y: number;
+    time: number;
+  } | null;
+  protected lastTapTime: number;
+  private x1;
+  private y1;
+  private x2;
+  private y2;
+  private selectionStart;
+  private panSpeed;
+  private readonly panDirection;
+  private pointers;
+  private panLoopId;
+  onRender: undefined;
+  constructor(params?: WeaveNodesSelectionPluginParams);
+  getName(): string;
+  getLayerName(): string;
+  initLayer(): void;
+  isPasting(): boolean;
+  isAreaSelecting(): boolean;
+  isSelecting(): boolean;
+  isNodeSelected(ele: Konva.Node): boolean;
+  onInit(): void;
+  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.Group | Konva.Shape)[];
+  getSelectedNodesExtended(): WeaveSelection[];
+  selectAll(): void;
+  selectNone(): void;
+  enable(): void;
+  disable(): void;
+  getContextMenuPlugin(): WeaveContextMenuPlugin | undefined;
+  getStageGridPlugin(): WeaveStageGridPlugin | undefined;
+  getNodesEdgeSnappingPlugin(): WeaveNodesEdgeSnappingPlugin | undefined;
+  getNodesDistanceSnappingPlugin(): WeaveNodesDistanceSnappingPlugin | undefined;
+  getStagePanningPlugin(): WeaveStagePanningPlugin | undefined;
+  getSelectorConfig(): TransformerConfig;
+}
+
+//#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;
+  private 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;
+  onAdd(nodeInstance: WeaveElementInstance): void;
+  abstract onRender(props: WeaveElementAttributes): WeaveElementInstance;
+  abstract onUpdate(instance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
+  onDestroy(nodeInstance: WeaveElementInstance): 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;
+  private getNodesSelectionPlugin;
+  getNodesEdgeSnappingPlugin(): WeaveNodesEdgeSnappingPlugin | undefined;
+  getNodesDistanceSnappingPlugin(): WeaveNodesDistanceSnappingPlugin | undefined;
+  realOffset(instance: WeaveStateElement): Konva.Vector2d;
+  private getRealSelectedNode;
+}
+
+//#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;
+  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/logger/logger.d.ts
+//# sourceMappingURL=action.d.ts.map
+declare class WeaveLogger {
+  private config;
+  private disabled;
+  private logger;
+  constructor(config: WeaveLoggerConfig);
+  private log;
+  getDisabled(): boolean;
+  getLevel(): pino.LevelWithSilentOrString;
+  getLogger(): Logger;
+  getChildLogger(name: string): pino.Logger<never, boolean>;
+}
+
+//#endregion
+//#region src/managers/cloning.d.ts
+//# sourceMappingURL=logger.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;
+  cloneNodes(instancesToClone: Konva.Node[], targetContainer: Konva.Group | Konva.Layer | undefined, onPoint: Konva.Vector2d): void;
+  private recursivelyUpdateKeys;
+  cloneNode(targetNode: Konva.Node): Konva.Node | undefined;
+  addClone(node: Konva.Node): void;
+  removeClone(node: Konva.Node): void;
+  getClones(): konva_lib_Node9.Node<konva_lib_Node8.NodeConfig>[];
+  isClone(node: Konva.Node): konva_lib_Node11.Node<konva_lib_Node10.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
+declare class Weave {
+  private id;
+  private emitter;
+  private config;
+  private logger;
+  private moduleLogger;
+  private reconciler;
+  private stateSerializer;
+  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 asyncElements;
+  constructor(weaveConfig: WeaveConfig, stageConfig: Konva.StageConfig);
+  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;
+  removeEventListener<T>(event: string, callback: (payload: T) => void): void;
+  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, index?: number | undefined): void;
+  updateNode(node: WeaveStateElement): void;
+  updateNodes(nodes: WeaveStateElement[]): void;
+  removeNode(node: WeaveStateElement): void;
+  removeNodes(nodes: WeaveStateElement[]): void;
+  moveNode(node: WeaveStateElement, position: WeavePosition): void;
+  getElementsTree(): WeaveStateElement[];
+  isEmpty(): boolean;
+  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;
+  };
+  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;
+  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;
+  getCloningManager(): WeaveCloningManager;
+  nodesToGroupSerialized(instancesToClone: Konva.Node[]): WeaveSerializedGroup;
+  cloneNodes(instancesToClone: Konva.Node[], targetContainer: Konva.Layer | Konva.Group | undefined, onPoint: Konva.Vector2d): void;
+  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;
+  }>;
+  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;
+} //#endregion
 //#region ../types/dist/types.d.ts
 
+//#endregion
+//#region src/stores/types.d.ts
+//# sourceMappingURL=weave.d.ts.map
 //#endregion
 //#region src/base/store.d.ts
 type WeaveStoreOptions = {
@@ -22,7 +1080,9 @@ type WeaveUser = {
 type WeaveUndoManagerOptions = {
   captureTimeout?: number;
   trackedOrigins?: Set<any>;
-}; //#endregion
+};
+
+//#endregion
 //#region src/types.d.ts
 type WeaveStoreWebsocketsOptions = {
   roomId: string;