@inditextech/weave-sdk 0.1.1 → 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/sdk.d.ts CHANGED
@@ -1,2255 +1,1433 @@
1
- import { ClipFuncOutput } from 'konva/lib/Container';
2
- import { Context } from 'konva/lib/Context';
3
- import { default as default_2 } from 'emittery';
4
- import { default as default_3 } from 'konva';
5
- import { default as default_4 } from 'pino';
6
- import { Doc } from 'yjs';
7
- import { Filter } from 'konva/lib/Node';
8
- import { Group } from 'konva/lib/Group';
9
- import { Layer } from 'konva/lib/Layer';
10
- import { Line } from 'konva/lib/shapes/Line';
11
- import { LineCap } from 'konva/lib/Shape';
12
- import { LineJoin } from 'konva/lib/Shape';
13
- import { Logger } from 'pino';
14
- import { MappedTypeDescription } from '../../../../node_modules/@syncedstore/core/types/doc';
15
- import { Node as Node_2 } from 'konva/lib/Node';
16
- import { NodeSerializable } from '@inditextech/weave-types';
17
- import { Rect } from 'konva/lib/shapes/Rect';
18
- import { SceneContext } from 'konva/lib/Context';
19
- import { Shape } from 'konva/lib/Shape';
20
- import { ShapeConfig } from 'konva/lib/Shape';
21
- import { Stage } from 'konva/lib/Stage';
22
- import { StageConfig } from 'konva/lib/Stage';
23
- import { Text as Text_2 } from 'konva/lib/shapes/Text';
24
- import { Transformer as Transformer_2 } from 'konva/lib/shapes/Transformer';
25
- import { Vector2d } from 'konva/lib/types';
26
- import { WeaveAwarenessChange } from '@inditextech/weave-types';
27
- import { WeaveConfig } from '@inditextech/weave-types';
28
- import { WeaveElementAttributes } from '@inditextech/weave-types';
29
- import { WeaveElementInstance } from '@inditextech/weave-types';
30
- import { WeaveExportNodeOptions } from '@inditextech/weave-types';
31
- import { WeaveFont } from '@inditextech/weave-types';
32
- import { WeaveLoggerConfig } from '@inditextech/weave-types';
33
- import { WeaveNodeBase } from '@inditextech/weave-types';
34
- import { WeavePluginBase } from '@inditextech/weave-types';
35
- import { WeavePosition } from '@inditextech/weave-types';
36
- import { WeaveSelection } from '@inditextech/weave-types';
37
- import { WeaveState } from '@inditextech/weave-types';
38
- import { WeaveStateElement } from '@inditextech/weave-types';
39
- import { WeaveStatus } from '@inditextech/weave-types';
40
- import { WeaveStoreBase } from '@inditextech/weave-types';
41
- import { WeaveStoreOptions } from '@inditextech/weave-types';
42
- import { WeaveUser } from '@inditextech/weave-types';
43
-
44
- export declare const BRUSH_TOOL_STATE: {
45
- readonly INACTIVE: "inactive";
46
- readonly IDLE: "idle";
47
- readonly DEFINE_STROKE: "defineStroke";
48
- };
49
-
50
- export declare const COPY_PASTE_NODES_PLUGIN_STATE: {
51
- readonly IDLE: "idle";
52
- readonly PASTING: "pasting";
53
- };
54
-
55
- export declare const FRAME_TOOL_ACTION_NAME = "frameTool";
56
-
57
- export declare const FRAME_TOOL_STATE: {
58
- readonly IDLE: "idle";
59
- readonly ADDING: "adding";
60
- readonly ADDED: "added";
61
- };
62
-
63
- export declare type Guide = {
64
- lineGuide: number;
65
- offset: number;
66
- orientation: GuideOrientation;
67
- snap: NodeSnap;
68
- };
69
-
70
- export declare const GUIDE_LINE_NAME = "guide-line";
71
-
72
- export declare const GUIDE_ORIENTATION: {
73
- readonly HORIZONTAL: "H";
74
- readonly VERTICAL: "V";
75
- };
76
-
77
- export declare type GuideOrientation = (typeof GUIDE_ORIENTATION)[GuideOrientationKeys];
78
-
79
- export declare type GuideOrientationKeys = keyof typeof GUIDE_ORIENTATION;
80
-
81
- export declare const IMAGE_TOOL_STATE: {
82
- readonly IDLE: "idle";
83
- readonly UPLOADING: "uploading";
84
- readonly ADDING: "adding";
85
- readonly FINISHED: "finished";
86
- };
87
-
88
- export declare type ImageProps = WeaveElementAttributes & {
89
- id: string;
90
- width?: number;
91
- height?: number;
92
- imageURL?: string;
93
- imageInfo?: {
94
- width: number;
95
- height: number;
96
- };
97
- };
98
-
99
- export declare type LineGuide = {
100
- lineGuide: number;
101
- diff: number;
102
- snap: NodeSnap;
103
- offset: number;
104
- };
105
-
106
- export declare type LineGuideStop = {
107
- vertical: number[];
108
- horizontal: number[];
109
- };
110
-
111
- export declare const MOVE_TOOL_ACTION_NAME = "moveTool";
112
-
113
- export declare const MOVE_TOOL_STATE: {
114
- readonly IDLE: "idle";
115
- readonly MOVING: "moving";
116
- };
117
-
118
- export declare const NODE_SNAP: {
119
- readonly START: "start";
120
- readonly CENTER: "center";
121
- readonly END: "end";
122
- };
123
-
124
- export declare type NodeSnap = (typeof NODE_SNAP)[NodeSnapKeys];
125
-
126
- export declare type NodeSnapKeys = keyof typeof NODE_SNAP;
127
-
128
- export declare type NodeSnappingEdge = {
129
- guide: number;
130
- offset: number;
131
- snap: NodeSnap;
132
- };
133
-
134
- export declare type NodeSnappingEdges = {
135
- vertical: NodeSnappingEdge[];
136
- horizontal: NodeSnappingEdge[];
137
- };
138
-
139
- export declare const PEN_TOOL_STATE: {
140
- readonly IDLE: "idle";
141
- readonly ADDING: "adding";
142
- readonly DEFINING_SIZE: "definingSize";
143
- readonly ADDED: "added";
144
- };
145
-
146
- export declare const RECTANGLE_TOOL_ACTION_NAME = "rectangleTool";
147
-
148
- export declare const RECTANGLE_TOOL_STATE: {
149
- readonly IDLE: "idle";
150
- readonly ADDING: "adding";
151
- readonly DEFINING_SIZE: "definingSize";
152
- readonly ADDED: "added";
153
- };
154
-
155
- export declare function resetScale(node: default_3.Node): void;
156
-
157
- export declare const SELECTION_TOOL_ACTION_NAME = "selectionTool";
158
-
159
- export declare const SELECTION_TOOL_STATE: {
160
- readonly IDLE: "idle";
161
- readonly SELECTING: "selection";
162
- };
163
-
164
- export declare function sendEvent<T>(eventName: string, payload: T): void;
165
-
166
- export declare const TEXT_TOOL_STATE: {
167
- readonly IDLE: "idle";
168
- readonly ADDING: "adding";
169
- readonly FINISHED: "finished";
170
- };
171
-
172
- export declare type TextSerializable = default_3.TextConfig & NodeSerializable & {
173
- type: 'text';
174
- id: string;
175
- };
176
-
177
- export declare class Weave extends default_2 {
178
- private id;
179
- private config;
180
- private logger;
181
- private moduleLogger;
182
- private reconciler;
183
- private stateSerializer;
184
- private renderer;
185
- private status;
186
- private setupManager;
187
- private registerManager;
188
- private stateManager;
189
- private storeManager;
190
- private stageManager;
191
- private groupsManager;
192
- private targetingManager;
193
- private cloningManager;
194
- private fontsManager;
195
- private zIndexManager;
196
- private pluginsManager;
197
- private actionsManager;
198
- private exportManager;
199
- constructor(weaveConfig: WeaveConfig, stageConfig: default_3.StageConfig);
200
- setupRenderer(): void;
201
- setStatus(status: WeaveStatus): void;
202
- getStatus(): WeaveStatus;
203
- setStore(store: WeaveStore): void;
204
- start(): Promise<void>;
205
- getId(): string;
206
- getConfiguration(): WeaveConfig;
207
- emitEvent<T>(event: string, payload: T): void;
208
- addEventListener<T>(event: string, callback: (payload: T) => void): void;
209
- removeEventListener<T>(event: string, callback: (payload: T) => void): void;
210
- getLogger(): WeaveLogger;
211
- getMainLogger(): Logger;
212
- getChildLogger(name: string): default_4.Logger<never, boolean>;
213
- getStageManager(): WeaveStageManager;
214
- getStage(): Stage;
215
- getMainLayer(): Layer | undefined;
216
- setStage(stage: default_3.Stage): void;
217
- getStageConfiguration(): StageConfig;
218
- getInstanceRecursive(instance: default_3.Node, filterInstanceType?: string[]): default_3.Node;
219
- getRegisterManager(): WeaveRegisterManager;
220
- getPlugins(): Record<string, WeavePlugin>;
221
- getPlugin<T extends WeavePlugin>(pluginName: string): T;
222
- getNodesHandlers(): Record<string, WeaveNode>;
223
- getNodeHandler<T extends WeaveNode>(nodeType: string): T;
224
- getActionsHandlers(): Record<string, WeaveAction>;
225
- getActionHandler<T extends WeaveAction>(actionName: string): T;
226
- getStore<T extends WeaveStore>(): T;
227
- registerPlugin(plugin: WeavePlugin): void;
228
- registerNodeHandler(node: WeaveNode): void;
229
- registerActionHandler(action: WeaveAction): void;
230
- registerStore(store: WeaveStore): void;
231
- isPluginEnabled(pluginName: string): boolean;
232
- enablePlugin(pluginName: string): void;
233
- disablePlugin(pluginName: string): void;
234
- getActiveAction(): string | undefined;
235
- triggerAction<T>(actionName: string, params?: T): unknown;
236
- getPropsAction(actionName: string): WeaveElementAttributes;
237
- updatePropsAction(actionName: string, params: WeaveElementAttributes): void;
238
- cancelAction(actionName: string): void;
239
- update(newState: WeaveState): void;
240
- render(): void;
241
- findNodeById(tree: WeaveStateElement, key: string, parent?: WeaveStateElement | null, index?: number): {
242
- node: WeaveStateElement | null;
243
- parent: WeaveStateElement | null;
244
- index: number;
245
- };
246
- findNodesByType(tree: WeaveStateElement, nodeType: string): WeaveStateElement[];
247
- getNode(nodeKey: string): {
248
- node: WeaveStateElement | null;
249
- parent: WeaveStateElement | null;
250
- index: number;
251
- };
252
- addNode(node: WeaveStateElement, parentId?: string, index?: number | undefined, doRender?: boolean): void;
253
- updateNode(node: WeaveStateElement, doRender?: boolean): void;
254
- removeNode(node: WeaveStateElement, doRender?: boolean): void;
255
- removeNodes(nodes: WeaveStateElement[], doRender?: boolean): void;
256
- moveNode(node: WeaveStateElement, position: WeavePosition, doRender?: boolean): void;
257
- moveUp(node: WeaveElementInstance): void;
258
- moveDown(node: WeaveElementInstance): void;
259
- sendToBack(node: WeaveElementInstance): void;
260
- bringToFront(node: WeaveElementInstance): void;
261
- group(nodes: WeaveStateElement[]): void;
262
- unGroup(group: WeaveStateElement): void;
263
- getMousePointer(point?: Vector2d): {
264
- mousePoint: Vector2d;
265
- container: Group | Layer | undefined;
266
- measureContainer: Group | Layer | undefined;
267
- };
268
- getMousePointerRelativeToContainer(container: default_3.Group | default_3.Layer): {
269
- mousePoint: {
270
- x: number;
271
- y: number;
272
- };
273
- container: Group | Layer;
274
- };
275
- nodesToGroupSerialized(instancesToClone: default_3.Node[]): {
276
- serializedNodes: WeaveStateElement[];
277
- minPoint: Vector2d;
278
- } | undefined;
279
- cloneNodes(instancesToClone: default_3.Node[], targetContainer: default_3.Layer | default_3.Group | undefined, onPoint: Vector2d): void;
280
- getFonts(): WeaveFont[];
281
- exportStage(options: WeaveExportNodeOptions): Promise<HTMLImageElement>;
282
- exportNode(node: WeaveElementInstance, options: WeaveExportNodeOptions): Promise<HTMLImageElement>;
283
- }
284
-
285
- declare const WEAVE_CONNECTED_USER_INFO_KEY = "userInfo";
286
-
287
- export declare const WEAVE_FRAME_NODE_TYPE = "frame";
288
-
289
- export declare const WEAVE_GRID_DEFAULT_SIZE = 50;
290
-
291
- export declare const WEAVE_GRID_LAYER_ID = "gridLayer";
292
-
293
- export declare const WEAVE_GRID_TYPES: {
294
- readonly LINES: "lines";
295
- readonly DOTS: "dots";
296
- };
297
-
298
- export declare const WEAVE_NODES_SELECTION_LAYER_ID = "selectionLayer";
299
-
300
- declare const WEAVE_USER_POINTER_KEY = "userPointer";
301
-
302
- export declare abstract class WeaveAction {
303
- protected instance: Weave;
304
- protected name: string;
305
- props: WeaveElementAttributes;
306
- protected callbacks: WeaveActionCallbacks | undefined;
307
- private logger;
308
- constructor(callbacks?: WeaveActionCallbacks);
309
- getName(): string;
310
- getLogger(): Logger;
311
- register(instance: Weave): this;
312
- updateProps(props: WeaveElementAttributes): void;
313
- getProps(): WeaveElementAttributes;
314
- abstract init?(): void;
315
- abstract trigger(cancelAction: () => void, params?: unknown): unknown;
316
- abstract internalUpdate?(): void;
317
- abstract cleanup?(): void;
318
- }
319
-
320
- export declare type WeaveActionCallbacks = {
321
- onPropsChange?: WeaveActionPropsChangeCallback;
322
- };
323
-
324
- export declare type WeaveActionPropsChangeCallback = (props: WeaveElementAttributes) => void;
325
-
326
- export declare class WeaveBrushToolAction extends WeaveAction {
327
- protected initialized: boolean;
328
- protected state: WeaveBrushToolActionState;
329
- protected clickPoint: Vector2d | null;
330
- protected strokeId: string | null;
331
- protected container: default_3.Layer | default_3.Group | undefined;
332
- protected measureContainer: default_3.Layer | default_3.Group | undefined;
333
- protected cancelAction: () => void;
334
- internalUpdate: undefined;
335
- init: undefined;
336
- constructor(callbacks: WeaveBrushToolCallbacks);
337
- getName(): string;
338
- initProps(): {
339
- stroke: string;
340
- strokeWidth: number;
341
- opacity: number;
342
- };
343
- private setupEvents;
344
- private setState;
345
- private handleStartStroke;
346
- private handleEndStroke;
347
- private handleMovement;
348
- trigger(cancel: () => void): void;
349
- cleanup(): void;
350
- }
351
-
352
- export declare type WeaveBrushToolActionState = (typeof BRUSH_TOOL_STATE)[WeaveBrushToolActionStateKeys];
353
-
354
- export declare type WeaveBrushToolActionStateKeys = keyof typeof BRUSH_TOOL_STATE;
355
-
356
- export declare type WeaveBrushToolCallbacks = WeaveActionCallbacks;
357
-
358
- export declare type WeaveConnectedUserInfoKey = typeof WEAVE_CONNECTED_USER_INFO_KEY;
359
-
360
- export declare type WeaveConnectedUsersChangeCallback = (users: WeaveConnectedUsersChanged) => void;
361
-
362
- export declare type WeaveConnectedUsersChanged = {
363
- [userName: string]: WeaveUser;
364
- };
365
-
366
- export declare class WeaveConnectedUsersPlugin extends WeavePlugin {
367
- private connectedUsers;
368
- private getUser;
369
- private onConnectedUsersChanged;
370
- getLayerName: undefined;
371
- initLayer: undefined;
372
- render: undefined;
373
- constructor(params: WeaveConnectedUsersPluginParams);
374
- registersLayers(): boolean;
375
- getName(): string;
376
- init(): void;
377
- enable(): void;
378
- disable(): void;
379
- }
380
-
381
- export declare type WeaveConnectedUsersPluginParams = {
382
- onConnectedUsersChanged?: WeaveConnectedUsersChangeCallback;
383
- getUser?: () => WeaveUser;
384
- };
385
-
386
- export declare class WeaveContextMenuPlugin extends WeavePlugin {
387
- private config;
388
- private callbacks;
389
- private touchTimer;
390
- private tapHold;
391
- getLayerName: undefined;
392
- initLayer: undefined;
393
- render: undefined;
394
- constructor(options: WeaveStageContextMenuPluginOptions, callbacks: WeaveStageContextMenuPluginCallbacks);
395
- registersLayers(): boolean;
396
- getName(): string;
397
- init(): void;
398
- triggerContextMenu(target: any): void;
399
- private initEvents;
400
- isTapHold(): boolean;
401
- enable(): void;
402
- disable(): void;
403
- }
404
-
405
- export declare type WeaveCopyPasteNodesCanCopyChangeCallback = (canCopy: boolean) => void;
406
-
407
- export declare type WeaveCopyPasteNodesCanPasteChangeCallback = (canPaste: boolean, nodes: WeaveToPasteNode[]) => void;
408
-
409
- export declare type WeaveCopyPasteNodesOnCopyCallback = (error?: Error) => void;
410
-
411
- export declare type WeaveCopyPasteNodesOnPasteCallback = (error?: Error) => void;
412
-
413
- export declare type WeaveCopyPasteNodesOnPasteExternalCallback = (item: ClipboardItem) => void;
414
-
415
- export declare class WeaveCopyPasteNodesPlugin extends WeavePlugin {
416
- protected state: WeaveCopyPasteNodesPluginState;
417
- private callbacks;
418
- private toPaste;
419
- getLayerName: undefined;
420
- initLayer: undefined;
421
- render: undefined;
422
- constructor(callbacks?: WeaveCopyPasteNodesPluginCallbacks);
423
- registersLayers(): boolean;
424
- getName(): string;
425
- init(): void;
426
- private readClipboardData;
427
- private writeClipboardData;
428
- private initEvents;
429
- private mapToPasteNodes;
430
- private setState;
431
- private handlePaste;
432
- private performCopy;
433
- private performPaste;
434
- copy(): Promise<void>;
435
- paste(): Promise<void>;
436
- getSelectedNodes(): {
437
- konvaNode: Group | Shape<ShapeConfig>;
438
- node: NodeSerializable;
439
- }[];
440
- isPasting(): boolean;
441
- private cancel;
442
- private getNodesSelectionPlugin;
443
- enable(): void;
444
- disable(): void;
445
- }
446
-
447
- export declare type WeaveCopyPasteNodesPluginCallbacks = {
448
- onCopy?: WeaveCopyPasteNodesOnCopyCallback;
449
- onPaste?: WeaveCopyPasteNodesOnPasteCallback;
450
- onPasteExternal?: WeaveCopyPasteNodesOnPasteExternalCallback;
451
- };
452
-
453
- export declare type WeaveCopyPasteNodesPluginState = (typeof COPY_PASTE_NODES_PLUGIN_STATE)[WeaveCopyPasteNodesPluginStateKeys];
454
-
455
- export declare type WeaveCopyPasteNodesPluginStateKeys = keyof typeof COPY_PASTE_NODES_PLUGIN_STATE;
456
-
457
- export declare type WeaveExportNodeActionParams = {
458
- node: WeaveElementInstance;
459
- options?: WeaveExportNodeOptions;
460
- };
461
-
462
- export declare class WeaveExportNodeToolAction extends WeaveAction {
463
- protected cancelAction: () => void;
464
- private defaultFormatOptions;
465
- private options;
466
- internalUpdate: undefined;
467
- init: undefined;
468
- getName(): string;
469
- private exportNode;
470
- trigger(cancelAction: () => void, { node, options }: WeaveExportNodeActionParams): Promise<void>;
471
- cleanup(): void;
472
- }
473
-
474
- export declare type WeaveExportStageActionParams = {
475
- options?: WeaveExportNodeOptions;
476
- };
477
-
478
- export declare class WeaveExportStageToolAction extends WeaveAction {
479
- protected cancelAction: () => void;
480
- private defaultFormatOptions;
481
- private options;
482
- internalUpdate: undefined;
483
- init: undefined;
484
- getName(): string;
485
- private exportStage;
486
- trigger(cancelAction: () => void, { options }: WeaveExportStageActionParams): Promise<void>;
487
- cleanup(): void;
488
- }
489
-
490
- export declare class WeaveFitToScreenToolAction extends WeaveAction {
491
- protected previousAction: string;
492
- protected cancelAction: () => void;
493
- internalUpdate: undefined;
494
- getName(): string;
495
- private getStageZoomPlugin;
496
- init(): void;
497
- trigger(cancelAction: () => void, params: WeaveFitToScreenToolActionParams): void;
498
- cleanup(): void;
499
- }
500
-
501
- export declare type WeaveFitToScreenToolActionParams = {
502
- previousAction: string;
503
- };
504
-
505
- export declare class WeaveFitToSelectionToolAction extends WeaveAction {
506
- protected previousAction: string;
507
- protected cancelAction: () => void;
508
- internalUpdate: undefined;
509
- getName(): string;
510
- private getNodesSelectionPlugin;
511
- private getStageZoomPlugin;
512
- init(): void;
513
- trigger(cancelAction: () => void, params: WeaveFitToSelectionToolActionParams): void;
514
- cleanup(): void;
515
- }
516
-
517
- export declare type WeaveFitToSelectionToolActionParams = {
518
- previousAction: string;
519
- };
520
-
521
- export declare class WeaveFrameNode extends WeaveNode {
522
- protected nodeType: string;
523
- createNode(key: string, props: WeaveElementAttributes): {
524
- key: string;
525
- type: string;
526
- props: {
527
- id: string;
528
- nodeType: string;
529
- children: never[];
530
- };
531
- };
532
- createInstance(props: WeaveElementAttributes): Group;
533
- updateInstance(nodeInstance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
534
- removeInstance(nodeInstance: WeaveElementInstance): void;
535
- toNode(instance: WeaveElementInstance): {
536
- key: string;
537
- type: any;
538
- props: {
539
- id: string;
540
- nodeType: any;
541
- children: WeaveStateElement[];
542
- clearBeforeDraw?: boolean;
543
- clipFunc?: (ctx: SceneContext) => ClipFuncOutput;
544
- clipX?: number;
545
- clipY?: number;
546
- clipWidth?: number;
547
- clipHeight?: number;
548
- x?: number;
549
- y?: number;
550
- width?: number;
551
- height?: number;
552
- visible?: boolean;
553
- listening?: boolean;
554
- name?: string;
555
- opacity?: number;
556
- scale?: Vector2d;
557
- scaleX?: number;
558
- skewX?: number;
559
- skewY?: number;
560
- scaleY?: number;
561
- rotation?: number;
562
- rotationDeg?: number;
563
- offset?: Vector2d;
564
- offsetX?: number;
565
- offsetY?: number;
566
- draggable?: boolean;
567
- dragDistance?: number;
568
- dragBoundFunc?: (this: Node_2, pos: Vector2d) => Vector2d;
569
- preventDefault?: boolean;
570
- globalCompositeOperation?: "" | "source-over" | "source-in" | "source-out" | "source-atop" | "destination-over" | "destination-in" | "destination-out" | "destination-atop" | "lighter" | "copy" | "xor" | "multiply" | "screen" | "overlay" | "darken" | "lighten" | "color-dodge" | "color-burn" | "hard-light" | "soft-light" | "difference" | "exclusion" | "hue" | "saturation" | "color" | "luminosity";
571
- filters?: Array<Filter>;
572
- } | {
573
- id: string;
574
- nodeType: any;
575
- children: WeaveStateElement[];
576
- fill?: string | CanvasGradient;
577
- fillPatternImage?: HTMLImageElement;
578
- fillPatternX?: number;
579
- fillPatternY?: number;
580
- fillPatternOffset?: Vector2d;
581
- fillPatternOffsetX?: number;
582
- fillPatternOffsetY?: number;
583
- fillPatternScale?: Vector2d;
584
- fillPatternScaleX?: number;
585
- fillPatternScaleY?: number;
586
- fillPatternRotation?: number;
587
- fillPatternRepeat?: string;
588
- fillLinearGradientStartPoint?: Vector2d;
589
- fillLinearGradientStartPointX?: number;
590
- fillLinearGradientStartPointY?: number;
591
- fillLinearGradientEndPoint?: Vector2d;
592
- fillLinearGradientEndPointX?: number;
593
- fillLinearGradientEndPointY?: number;
594
- fillLinearGradientColorStops?: Array<number | string>;
595
- fillRadialGradientStartPoint?: Vector2d;
596
- fillRadialGradientStartPointX?: number;
597
- fillRadialGradientStartPointY?: number;
598
- fillRadialGradientEndPoint?: Vector2d;
599
- fillRadialGradientEndPointX?: number;
600
- fillRadialGradientEndPointY?: number;
601
- fillRadialGradientStartRadius?: number;
602
- fillRadialGradientEndRadius?: number;
603
- fillRadialGradientColorStops?: Array<number | string>;
604
- fillEnabled?: boolean;
605
- fillPriority?: string;
606
- fillRule?: CanvasFillRule;
607
- stroke?: string | CanvasGradient;
608
- strokeWidth?: number;
609
- fillAfterStrokeEnabled?: boolean;
610
- hitStrokeWidth?: number | string;
611
- strokeScaleEnabled?: boolean;
612
- strokeHitEnabled?: boolean;
613
- strokeEnabled?: boolean;
614
- lineJoin?: LineJoin;
615
- lineCap?: LineCap;
616
- sceneFunc?: (con: Context, shape: Shape) => void;
617
- hitFunc?: (con: Context, shape: Shape) => void;
618
- shadowColor?: string;
619
- shadowBlur?: number;
620
- shadowOffset?: Vector2d;
621
- shadowOffsetX?: number;
622
- shadowOffsetY?: number;
623
- shadowOpacity?: number;
624
- shadowEnabled?: boolean;
625
- shadowForStrokeEnabled?: boolean;
626
- dash?: number[];
627
- dashOffset?: number;
628
- dashEnabled?: boolean;
629
- perfectDrawEnabled?: boolean;
630
- x?: number;
631
- y?: number;
632
- width?: number;
633
- height?: number;
634
- visible?: boolean;
635
- listening?: boolean;
636
- name?: string;
637
- opacity?: number;
638
- scale?: Vector2d;
639
- scaleX?: number;
640
- skewX?: number;
641
- skewY?: number;
642
- scaleY?: number;
643
- rotation?: number;
644
- rotationDeg?: number;
645
- offset?: Vector2d;
646
- offsetX?: number;
647
- offsetY?: number;
648
- draggable?: boolean;
649
- dragDistance?: number;
650
- dragBoundFunc?: (this: Node_2, pos: Vector2d) => Vector2d;
651
- preventDefault?: boolean;
652
- globalCompositeOperation?: "" | "source-over" | "source-in" | "source-out" | "source-atop" | "destination-over" | "destination-in" | "destination-out" | "destination-atop" | "lighter" | "copy" | "xor" | "multiply" | "screen" | "overlay" | "darken" | "lighten" | "color-dodge" | "color-burn" | "hard-light" | "soft-light" | "difference" | "exclusion" | "hue" | "saturation" | "color" | "luminosity";
653
- filters?: Array<Filter>;
654
- };
655
- };
656
- }
657
-
658
- export declare class WeaveFrameToolAction extends WeaveAction {
659
- protected initialized: boolean;
660
- protected state: WeaveFrameToolActionState;
661
- protected frameId: string | null;
662
- protected container: default_3.Layer | default_3.Group | undefined;
663
- protected clickPoint: Vector2d | null;
664
- protected cancelAction: () => void;
665
- internalUpdate: undefined;
666
- init: undefined;
667
- constructor(callbacks: WeaveFrameToolCallbacks);
668
- getName(): string;
669
- initProps(params?: WeaveFrameToolActionTriggerParams): {
670
- title: string;
671
- fontFamily: string;
672
- editing: boolean;
673
- opacity: number;
674
- };
675
- private setupEvents;
676
- private setState;
677
- private addFrame;
678
- private handleAdding;
679
- trigger(cancelAction: () => void, params?: WeaveFrameToolActionTriggerParams): void;
680
- cleanup(): void;
681
- }
682
-
683
- export declare type WeaveFrameToolActionState = (typeof FRAME_TOOL_STATE)[WeaveFrameToolActionStateKeys];
684
-
685
- export declare type WeaveFrameToolActionStateKeys = keyof typeof FRAME_TOOL_STATE;
686
-
687
- export declare type WeaveFrameToolActionTriggerParams = {
688
- fontFamily?: string;
689
- };
690
-
691
- export declare type WeaveFrameToolCallbacks = WeaveActionCallbacks;
692
-
693
- export declare class WeaveGroupNode extends WeaveNode {
694
- protected nodeType: string;
695
- createNode(key: string, props: WeaveElementAttributes): {
696
- key: string;
697
- type: string;
698
- props: {
699
- id: string;
700
- nodeType: string;
701
- children: never[];
702
- };
703
- };
704
- createInstance(props: WeaveElementAttributes): Group;
705
- updateInstance(nodeInstance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
706
- removeInstance(nodeInstance: WeaveElementInstance): void;
707
- toNode(instance: WeaveElementInstance): {
708
- key: string;
709
- type: any;
710
- props: {
711
- id: string;
712
- nodeType: any;
713
- children: WeaveStateElement[];
714
- clearBeforeDraw?: boolean;
715
- clipFunc?: (ctx: SceneContext) => ClipFuncOutput;
716
- clipX?: number;
717
- clipY?: number;
718
- clipWidth?: number;
719
- clipHeight?: number;
720
- x?: number;
721
- y?: number;
722
- width?: number;
723
- height?: number;
724
- visible?: boolean;
725
- listening?: boolean;
726
- name?: string;
727
- opacity?: number;
728
- scale?: Vector2d;
729
- scaleX?: number;
730
- skewX?: number;
731
- skewY?: number;
732
- scaleY?: number;
733
- rotation?: number;
734
- rotationDeg?: number;
735
- offset?: Vector2d;
736
- offsetX?: number;
737
- offsetY?: number;
738
- draggable?: boolean;
739
- dragDistance?: number;
740
- dragBoundFunc?: (this: Node_2, pos: Vector2d) => Vector2d;
741
- preventDefault?: boolean;
742
- globalCompositeOperation?: "" | "source-over" | "source-in" | "source-out" | "source-atop" | "destination-over" | "destination-in" | "destination-out" | "destination-atop" | "lighter" | "copy" | "xor" | "multiply" | "screen" | "overlay" | "darken" | "lighten" | "color-dodge" | "color-burn" | "hard-light" | "soft-light" | "difference" | "exclusion" | "hue" | "saturation" | "color" | "luminosity";
743
- filters?: Array<Filter>;
744
- } | {
745
- id: string;
746
- nodeType: any;
747
- children: WeaveStateElement[];
748
- fill?: string | CanvasGradient;
749
- fillPatternImage?: HTMLImageElement;
750
- fillPatternX?: number;
751
- fillPatternY?: number;
752
- fillPatternOffset?: Vector2d;
753
- fillPatternOffsetX?: number;
754
- fillPatternOffsetY?: number;
755
- fillPatternScale?: Vector2d;
756
- fillPatternScaleX?: number;
757
- fillPatternScaleY?: number;
758
- fillPatternRotation?: number;
759
- fillPatternRepeat?: string;
760
- fillLinearGradientStartPoint?: Vector2d;
761
- fillLinearGradientStartPointX?: number;
762
- fillLinearGradientStartPointY?: number;
763
- fillLinearGradientEndPoint?: Vector2d;
764
- fillLinearGradientEndPointX?: number;
765
- fillLinearGradientEndPointY?: number;
766
- fillLinearGradientColorStops?: Array<number | string>;
767
- fillRadialGradientStartPoint?: Vector2d;
768
- fillRadialGradientStartPointX?: number;
769
- fillRadialGradientStartPointY?: number;
770
- fillRadialGradientEndPoint?: Vector2d;
771
- fillRadialGradientEndPointX?: number;
772
- fillRadialGradientEndPointY?: number;
773
- fillRadialGradientStartRadius?: number;
774
- fillRadialGradientEndRadius?: number;
775
- fillRadialGradientColorStops?: Array<number | string>;
776
- fillEnabled?: boolean;
777
- fillPriority?: string;
778
- fillRule?: CanvasFillRule;
779
- stroke?: string | CanvasGradient;
780
- strokeWidth?: number;
781
- fillAfterStrokeEnabled?: boolean;
782
- hitStrokeWidth?: number | string;
783
- strokeScaleEnabled?: boolean;
784
- strokeHitEnabled?: boolean;
785
- strokeEnabled?: boolean;
786
- lineJoin?: LineJoin;
787
- lineCap?: LineCap;
788
- sceneFunc?: (con: Context, shape: Shape) => void;
789
- hitFunc?: (con: Context, shape: Shape) => void;
790
- shadowColor?: string;
791
- shadowBlur?: number;
792
- shadowOffset?: Vector2d;
793
- shadowOffsetX?: number;
794
- shadowOffsetY?: number;
795
- shadowOpacity?: number;
796
- shadowEnabled?: boolean;
797
- shadowForStrokeEnabled?: boolean;
798
- dash?: number[];
799
- dashOffset?: number;
800
- dashEnabled?: boolean;
801
- perfectDrawEnabled?: boolean;
802
- x?: number;
803
- y?: number;
804
- width?: number;
805
- height?: number;
806
- visible?: boolean;
807
- listening?: boolean;
808
- name?: string;
809
- opacity?: number;
810
- scale?: Vector2d;
811
- scaleX?: number;
812
- skewX?: number;
813
- skewY?: number;
814
- scaleY?: number;
815
- rotation?: number;
816
- rotationDeg?: number;
817
- offset?: Vector2d;
818
- offsetX?: number;
819
- offsetY?: number;
820
- draggable?: boolean;
821
- dragDistance?: number;
822
- dragBoundFunc?: (this: Node_2, pos: Vector2d) => Vector2d;
823
- preventDefault?: boolean;
824
- globalCompositeOperation?: "" | "source-over" | "source-in" | "source-out" | "source-atop" | "destination-over" | "destination-in" | "destination-out" | "destination-atop" | "lighter" | "copy" | "xor" | "multiply" | "screen" | "overlay" | "darken" | "lighten" | "color-dodge" | "color-burn" | "hard-light" | "soft-light" | "difference" | "exclusion" | "hue" | "saturation" | "color" | "luminosity";
825
- filters?: Array<Filter>;
826
- };
827
- };
828
- }
829
-
830
- export declare class WeaveImageNode extends WeaveNode {
831
- protected nodeType: string;
832
- private imageLoaded;
833
- cropping: boolean;
834
- constructor();
835
- createNode(key: string, props: WeaveElementAttributes): {
836
- key: string;
837
- type: string;
838
- props: {
839
- id: string;
840
- nodeType: string;
841
- children: never[];
842
- };
843
- };
844
- createInstance(props: WeaveElementAttributes): Group;
845
- updateInstance(nodeInstance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
846
- removeInstance(nodeInstance: WeaveElementInstance): void;
847
- toNode(instance: WeaveElementInstance): {
848
- key: string;
849
- type: any;
850
- props: {
851
- id: string;
852
- nodeType: any;
853
- children: never[];
854
- clearBeforeDraw?: boolean;
855
- clipFunc?: (ctx: SceneContext) => ClipFuncOutput;
856
- clipX?: number;
857
- clipY?: number;
858
- clipWidth?: number;
859
- clipHeight?: number;
860
- x?: number;
861
- y?: number;
862
- width?: number;
863
- height?: number;
864
- visible?: boolean;
865
- listening?: boolean;
866
- name?: string;
867
- opacity?: number;
868
- scale?: Vector2d;
869
- scaleX?: number;
870
- skewX?: number;
871
- skewY?: number;
872
- scaleY?: number;
873
- rotation?: number;
874
- rotationDeg?: number;
875
- offset?: Vector2d;
876
- offsetX?: number;
877
- offsetY?: number;
878
- draggable?: boolean;
879
- dragDistance?: number;
880
- dragBoundFunc?: (this: Node_2, pos: Vector2d) => Vector2d;
881
- preventDefault?: boolean;
882
- globalCompositeOperation?: "" | "source-over" | "source-in" | "source-out" | "source-atop" | "destination-over" | "destination-in" | "destination-out" | "destination-atop" | "lighter" | "copy" | "xor" | "multiply" | "screen" | "overlay" | "darken" | "lighten" | "color-dodge" | "color-burn" | "hard-light" | "soft-light" | "difference" | "exclusion" | "hue" | "saturation" | "color" | "luminosity";
883
- filters?: Array<Filter>;
884
- } | {
885
- id: string;
886
- nodeType: any;
887
- children: never[];
888
- fill?: string | CanvasGradient;
889
- fillPatternImage?: HTMLImageElement;
890
- fillPatternX?: number;
891
- fillPatternY?: number;
892
- fillPatternOffset?: Vector2d;
893
- fillPatternOffsetX?: number;
894
- fillPatternOffsetY?: number;
895
- fillPatternScale?: Vector2d;
896
- fillPatternScaleX?: number;
897
- fillPatternScaleY?: number;
898
- fillPatternRotation?: number;
899
- fillPatternRepeat?: string;
900
- fillLinearGradientStartPoint?: Vector2d;
901
- fillLinearGradientStartPointX?: number;
902
- fillLinearGradientStartPointY?: number;
903
- fillLinearGradientEndPoint?: Vector2d;
904
- fillLinearGradientEndPointX?: number;
905
- fillLinearGradientEndPointY?: number;
906
- fillLinearGradientColorStops?: Array<number | string>;
907
- fillRadialGradientStartPoint?: Vector2d;
908
- fillRadialGradientStartPointX?: number;
909
- fillRadialGradientStartPointY?: number;
910
- fillRadialGradientEndPoint?: Vector2d;
911
- fillRadialGradientEndPointX?: number;
912
- fillRadialGradientEndPointY?: number;
913
- fillRadialGradientStartRadius?: number;
914
- fillRadialGradientEndRadius?: number;
915
- fillRadialGradientColorStops?: Array<number | string>;
916
- fillEnabled?: boolean;
917
- fillPriority?: string;
918
- fillRule?: CanvasFillRule;
919
- stroke?: string | CanvasGradient;
920
- strokeWidth?: number;
921
- fillAfterStrokeEnabled?: boolean;
922
- hitStrokeWidth?: number | string;
923
- strokeScaleEnabled?: boolean;
924
- strokeHitEnabled?: boolean;
925
- strokeEnabled?: boolean;
926
- lineJoin?: LineJoin;
927
- lineCap?: LineCap;
928
- sceneFunc?: (con: Context, shape: Shape) => void;
929
- hitFunc?: (con: Context, shape: Shape) => void;
930
- shadowColor?: string;
931
- shadowBlur?: number;
932
- shadowOffset?: Vector2d;
933
- shadowOffsetX?: number;
934
- shadowOffsetY?: number;
935
- shadowOpacity?: number;
936
- shadowEnabled?: boolean;
937
- shadowForStrokeEnabled?: boolean;
938
- dash?: number[];
939
- dashOffset?: number;
940
- dashEnabled?: boolean;
941
- perfectDrawEnabled?: boolean;
942
- x?: number;
943
- y?: number;
944
- width?: number;
945
- height?: number;
946
- visible?: boolean;
947
- listening?: boolean;
948
- name?: string;
949
- opacity?: number;
950
- scale?: Vector2d;
951
- scaleX?: number;
952
- skewX?: number;
953
- skewY?: number;
954
- scaleY?: number;
955
- rotation?: number;
956
- rotationDeg?: number;
957
- offset?: Vector2d;
958
- offsetX?: number;
959
- offsetY?: number;
960
- draggable?: boolean;
961
- dragDistance?: number;
962
- dragBoundFunc?: (this: Node_2, pos: Vector2d) => Vector2d;
963
- preventDefault?: boolean;
964
- globalCompositeOperation?: "" | "source-over" | "source-in" | "source-out" | "source-atop" | "destination-over" | "destination-in" | "destination-out" | "destination-atop" | "lighter" | "copy" | "xor" | "multiply" | "screen" | "overlay" | "darken" | "lighten" | "color-dodge" | "color-burn" | "hard-light" | "soft-light" | "difference" | "exclusion" | "hue" | "saturation" | "color" | "luminosity";
965
- filters?: Array<Filter>;
966
- };
967
- };
968
- private loadImage;
969
- private getImageToolAction;
970
- }
971
-
972
- export declare class WeaveImageToolAction extends WeaveAction {
973
- private imageCallbacks;
974
- protected initialized: boolean;
975
- protected initialCursor: string | null;
976
- protected state: WeaveImageToolActionState;
977
- protected imageId: string | null;
978
- protected tempImageId: string | null;
979
- protected container: default_3.Layer | default_3.Group | undefined;
980
- protected imageURL: string | null;
981
- protected preloadImgs: Record<string, HTMLImageElement>;
982
- protected clickPoint: Vector2d | null;
983
- protected cancelAction: () => void;
984
- update: undefined;
985
- constructor(imageCallbacks: WeaveImageToolActionCallbacks);
986
- getName(): string;
987
- getPreloadedImage(imageId: string): HTMLImageElement | undefined;
988
- initProps(): {
989
- width: number;
990
- height: number;
991
- scaleX: number;
992
- scaleY: number;
993
- };
994
- init(): void;
995
- private setupEvents;
996
- private setState;
997
- private loadImage;
998
- private addImageNode;
999
- private addImage;
1000
- private handleAdding;
1001
- trigger(cancelAction: () => void, params?: WeaveImageToolActionTriggerParams): {
1002
- finishUploadCallback: (imageURL: string) => void;
1003
- } | undefined;
1004
- internalUpdate(): void;
1005
- cleanup(): void;
1006
- }
1007
-
1008
- export declare type WeaveImageToolActionCallbacks = WeaveActionCallbacks & {
1009
- onUploadImage: WeaveImageToolActionOnAddImageCallback;
1010
- onImageLoadStart?: WeaveImageToolActionOnStartLoadImageCallback;
1011
- onImageLoadEnd?: WeaveImageToolActionOnEndLoadImageCallback;
1012
- };
1013
-
1014
- export declare type WeaveImageToolActionOnAddImageCallback = (finished: (imageURL: string) => void) => Promise<void>;
1015
-
1016
- export declare type WeaveImageToolActionOnEndLoadImageCallback = (error?: Error) => void;
1017
-
1018
- export declare type WeaveImageToolActionOnStartLoadImageCallback = () => void;
1019
-
1020
- export declare type WeaveImageToolActionState = (typeof IMAGE_TOOL_STATE)[WeaveImageToolActionStateKeys];
1021
-
1022
- export declare type WeaveImageToolActionStateKeys = keyof typeof IMAGE_TOOL_STATE;
1023
-
1024
- export declare type WeaveImageToolActionTriggerParams = {
1025
- imageURL?: string;
1026
- };
1027
-
1028
- export declare class WeaveLayerNode extends WeaveNode {
1029
- protected nodeType: string;
1030
- createNode(key: string, props: WeaveElementAttributes): {
1031
- key: string;
1032
- type: string;
1033
- props: {
1034
- id: string;
1035
- nodeType: string;
1036
- children: never[];
1037
- };
1038
- };
1039
- createInstance(props: WeaveElementAttributes): Layer;
1040
- updateInstance(nodeInstance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
1041
- removeInstance(nodeInstance: WeaveElementInstance): void;
1042
- toNode(instance: WeaveElementInstance): {
1043
- key: string;
1044
- type: any;
1045
- props: {
1046
- id: string;
1047
- nodeType: any;
1048
- children: WeaveStateElement[];
1049
- clearBeforeDraw?: boolean;
1050
- clipFunc?: (ctx: SceneContext) => ClipFuncOutput;
1051
- clipX?: number;
1052
- clipY?: number;
1053
- clipWidth?: number;
1054
- clipHeight?: number;
1055
- x?: number;
1056
- y?: number;
1057
- width?: number;
1058
- height?: number;
1059
- visible?: boolean;
1060
- listening?: boolean;
1061
- name?: string;
1062
- opacity?: number;
1063
- scale?: Vector2d;
1064
- scaleX?: number;
1065
- skewX?: number;
1066
- skewY?: number;
1067
- scaleY?: number;
1068
- rotation?: number;
1069
- rotationDeg?: number;
1070
- offset?: Vector2d;
1071
- offsetX?: number;
1072
- offsetY?: number;
1073
- draggable?: boolean;
1074
- dragDistance?: number;
1075
- dragBoundFunc?: (this: Node_2, pos: Vector2d) => Vector2d;
1076
- preventDefault?: boolean;
1077
- globalCompositeOperation?: "" | "source-over" | "source-in" | "source-out" | "source-atop" | "destination-over" | "destination-in" | "destination-out" | "destination-atop" | "lighter" | "copy" | "xor" | "multiply" | "screen" | "overlay" | "darken" | "lighten" | "color-dodge" | "color-burn" | "hard-light" | "soft-light" | "difference" | "exclusion" | "hue" | "saturation" | "color" | "luminosity";
1078
- filters?: Array<Filter>;
1079
- } | {
1080
- id: string;
1081
- nodeType: any;
1082
- children: WeaveStateElement[];
1083
- fill?: string | CanvasGradient;
1084
- fillPatternImage?: HTMLImageElement;
1085
- fillPatternX?: number;
1086
- fillPatternY?: number;
1087
- fillPatternOffset?: Vector2d;
1088
- fillPatternOffsetX?: number;
1089
- fillPatternOffsetY?: number;
1090
- fillPatternScale?: Vector2d;
1091
- fillPatternScaleX?: number;
1092
- fillPatternScaleY?: number;
1093
- fillPatternRotation?: number;
1094
- fillPatternRepeat?: string;
1095
- fillLinearGradientStartPoint?: Vector2d;
1096
- fillLinearGradientStartPointX?: number;
1097
- fillLinearGradientStartPointY?: number;
1098
- fillLinearGradientEndPoint?: Vector2d;
1099
- fillLinearGradientEndPointX?: number;
1100
- fillLinearGradientEndPointY?: number;
1101
- fillLinearGradientColorStops?: Array<number | string>;
1102
- fillRadialGradientStartPoint?: Vector2d;
1103
- fillRadialGradientStartPointX?: number;
1104
- fillRadialGradientStartPointY?: number;
1105
- fillRadialGradientEndPoint?: Vector2d;
1106
- fillRadialGradientEndPointX?: number;
1107
- fillRadialGradientEndPointY?: number;
1108
- fillRadialGradientStartRadius?: number;
1109
- fillRadialGradientEndRadius?: number;
1110
- fillRadialGradientColorStops?: Array<number | string>;
1111
- fillEnabled?: boolean;
1112
- fillPriority?: string;
1113
- fillRule?: CanvasFillRule;
1114
- stroke?: string | CanvasGradient;
1115
- strokeWidth?: number;
1116
- fillAfterStrokeEnabled?: boolean;
1117
- hitStrokeWidth?: number | string;
1118
- strokeScaleEnabled?: boolean;
1119
- strokeHitEnabled?: boolean;
1120
- strokeEnabled?: boolean;
1121
- lineJoin?: LineJoin;
1122
- lineCap?: LineCap;
1123
- sceneFunc?: (con: Context, shape: Shape) => void;
1124
- hitFunc?: (con: Context, shape: Shape) => void;
1125
- shadowColor?: string;
1126
- shadowBlur?: number;
1127
- shadowOffset?: Vector2d;
1128
- shadowOffsetX?: number;
1129
- shadowOffsetY?: number;
1130
- shadowOpacity?: number;
1131
- shadowEnabled?: boolean;
1132
- shadowForStrokeEnabled?: boolean;
1133
- dash?: number[];
1134
- dashOffset?: number;
1135
- dashEnabled?: boolean;
1136
- perfectDrawEnabled?: boolean;
1137
- x?: number;
1138
- y?: number;
1139
- width?: number;
1140
- height?: number;
1141
- visible?: boolean;
1142
- listening?: boolean;
1143
- name?: string;
1144
- opacity?: number;
1145
- scale?: Vector2d;
1146
- scaleX?: number;
1147
- skewX?: number;
1148
- skewY?: number;
1149
- scaleY?: number;
1150
- rotation?: number;
1151
- rotationDeg?: number;
1152
- offset?: Vector2d;
1153
- offsetX?: number;
1154
- offsetY?: number;
1155
- draggable?: boolean;
1156
- dragDistance?: number;
1157
- dragBoundFunc?: (this: Node_2, pos: Vector2d) => Vector2d;
1158
- preventDefault?: boolean;
1159
- globalCompositeOperation?: "" | "source-over" | "source-in" | "source-out" | "source-atop" | "destination-over" | "destination-in" | "destination-out" | "destination-atop" | "lighter" | "copy" | "xor" | "multiply" | "screen" | "overlay" | "darken" | "lighten" | "color-dodge" | "color-burn" | "hard-light" | "soft-light" | "difference" | "exclusion" | "hue" | "saturation" | "color" | "luminosity";
1160
- filters?: Array<Filter>;
1161
- };
1162
- };
1163
- }
1164
-
1165
- export declare class WeaveLineNode extends WeaveNode {
1166
- protected nodeType: string;
1167
- createNode(key: string, props: WeaveElementAttributes): {
1168
- key: string;
1169
- type: string;
1170
- props: {
1171
- id: string;
1172
- nodeType: string;
1173
- children: never[];
1174
- };
1175
- };
1176
- createInstance(props: WeaveElementAttributes): Line< {
1177
- name: string;
1178
- id?: string;
1179
- nodeType?: string;
1180
- children?: WeaveStateElement[];
1181
- }>;
1182
- updateInstance(nodeInstance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
1183
- removeInstance(nodeInstance: WeaveElementInstance): void;
1184
- toNode(instance: WeaveElementInstance): {
1185
- key: string;
1186
- type: any;
1187
- props: {
1188
- id: string;
1189
- nodeType: any;
1190
- children: never[];
1191
- clearBeforeDraw?: boolean;
1192
- clipFunc?: (ctx: SceneContext) => ClipFuncOutput;
1193
- clipX?: number;
1194
- clipY?: number;
1195
- clipWidth?: number;
1196
- clipHeight?: number;
1197
- x?: number;
1198
- y?: number;
1199
- width?: number;
1200
- height?: number;
1201
- visible?: boolean;
1202
- listening?: boolean;
1203
- name?: string;
1204
- opacity?: number;
1205
- scale?: Vector2d;
1206
- scaleX?: number;
1207
- skewX?: number;
1208
- skewY?: number;
1209
- scaleY?: number;
1210
- rotation?: number;
1211
- rotationDeg?: number;
1212
- offset?: Vector2d;
1213
- offsetX?: number;
1214
- offsetY?: number;
1215
- draggable?: boolean;
1216
- dragDistance?: number;
1217
- dragBoundFunc?: (this: Node_2, pos: Vector2d) => Vector2d;
1218
- preventDefault?: boolean;
1219
- globalCompositeOperation?: "" | "source-over" | "source-in" | "source-out" | "source-atop" | "destination-over" | "destination-in" | "destination-out" | "destination-atop" | "lighter" | "copy" | "xor" | "multiply" | "screen" | "overlay" | "darken" | "lighten" | "color-dodge" | "color-burn" | "hard-light" | "soft-light" | "difference" | "exclusion" | "hue" | "saturation" | "color" | "luminosity";
1220
- filters?: Array<Filter>;
1221
- } | {
1222
- id: string;
1223
- nodeType: any;
1224
- children: never[];
1225
- fill?: string | CanvasGradient;
1226
- fillPatternImage?: HTMLImageElement;
1227
- fillPatternX?: number;
1228
- fillPatternY?: number;
1229
- fillPatternOffset?: Vector2d;
1230
- fillPatternOffsetX?: number;
1231
- fillPatternOffsetY?: number;
1232
- fillPatternScale?: Vector2d;
1233
- fillPatternScaleX?: number;
1234
- fillPatternScaleY?: number;
1235
- fillPatternRotation?: number;
1236
- fillPatternRepeat?: string;
1237
- fillLinearGradientStartPoint?: Vector2d;
1238
- fillLinearGradientStartPointX?: number;
1239
- fillLinearGradientStartPointY?: number;
1240
- fillLinearGradientEndPoint?: Vector2d;
1241
- fillLinearGradientEndPointX?: number;
1242
- fillLinearGradientEndPointY?: number;
1243
- fillLinearGradientColorStops?: Array<number | string>;
1244
- fillRadialGradientStartPoint?: Vector2d;
1245
- fillRadialGradientStartPointX?: number;
1246
- fillRadialGradientStartPointY?: number;
1247
- fillRadialGradientEndPoint?: Vector2d;
1248
- fillRadialGradientEndPointX?: number;
1249
- fillRadialGradientEndPointY?: number;
1250
- fillRadialGradientStartRadius?: number;
1251
- fillRadialGradientEndRadius?: number;
1252
- fillRadialGradientColorStops?: Array<number | string>;
1253
- fillEnabled?: boolean;
1254
- fillPriority?: string;
1255
- fillRule?: CanvasFillRule;
1256
- stroke?: string | CanvasGradient;
1257
- strokeWidth?: number;
1258
- fillAfterStrokeEnabled?: boolean;
1259
- hitStrokeWidth?: number | string;
1260
- strokeScaleEnabled?: boolean;
1261
- strokeHitEnabled?: boolean;
1262
- strokeEnabled?: boolean;
1263
- lineJoin?: LineJoin;
1264
- lineCap?: LineCap;
1265
- sceneFunc?: (con: Context, shape: Shape) => void;
1266
- hitFunc?: (con: Context, shape: Shape) => void;
1267
- shadowColor?: string;
1268
- shadowBlur?: number;
1269
- shadowOffset?: Vector2d;
1270
- shadowOffsetX?: number;
1271
- shadowOffsetY?: number;
1272
- shadowOpacity?: number;
1273
- shadowEnabled?: boolean;
1274
- shadowForStrokeEnabled?: boolean;
1275
- dash?: number[];
1276
- dashOffset?: number;
1277
- dashEnabled?: boolean;
1278
- perfectDrawEnabled?: boolean;
1279
- x?: number;
1280
- y?: number;
1281
- width?: number;
1282
- height?: number;
1283
- visible?: boolean;
1284
- listening?: boolean;
1285
- name?: string;
1286
- opacity?: number;
1287
- scale?: Vector2d;
1288
- scaleX?: number;
1289
- skewX?: number;
1290
- skewY?: number;
1291
- scaleY?: number;
1292
- rotation?: number;
1293
- rotationDeg?: number;
1294
- offset?: Vector2d;
1295
- offsetX?: number;
1296
- offsetY?: number;
1297
- draggable?: boolean;
1298
- dragDistance?: number;
1299
- dragBoundFunc?: (this: Node_2, pos: Vector2d) => Vector2d;
1300
- preventDefault?: boolean;
1301
- globalCompositeOperation?: "" | "source-over" | "source-in" | "source-out" | "source-atop" | "destination-over" | "destination-in" | "destination-out" | "destination-atop" | "lighter" | "copy" | "xor" | "multiply" | "screen" | "overlay" | "darken" | "lighten" | "color-dodge" | "color-burn" | "hard-light" | "soft-light" | "difference" | "exclusion" | "hue" | "saturation" | "color" | "luminosity";
1302
- filters?: Array<Filter>;
1303
- };
1304
- };
1305
- }
1306
-
1307
- declare class WeaveLogger {
1308
- private config;
1309
- private disabled;
1310
- private logger;
1311
- constructor(config: WeaveLoggerConfig);
1312
- private log;
1313
- getDisabled(): boolean;
1314
- getLevel(): default_4.LevelWithSilentOrString;
1315
- getLogger(): Logger;
1316
- getChildLogger(name: string): default_4.Logger<never, boolean>;
1317
- }
1318
-
1319
- export declare class WeaveMoveToolAction extends WeaveAction {
1320
- protected initialized: boolean;
1321
- protected state: WeaveMoveToolActionState;
1322
- protected cancelAction: () => void;
1323
- internalUpdate: undefined;
1324
- init: undefined;
1325
- constructor();
1326
- getName(): string;
1327
- private setupEvents;
1328
- private setState;
1329
- private setMoving;
1330
- trigger(cancelAction: () => void): void;
1331
- cleanup(): void;
1332
- }
1333
-
1334
- export declare type WeaveMoveToolActionState = (typeof MOVE_TOOL_STATE)[WeaveMoveToolActionStateKeys];
1335
-
1336
- export declare type WeaveMoveToolActionStateKeys = keyof typeof MOVE_TOOL_STATE;
1337
-
1338
- export declare abstract class WeaveNode implements WeaveNodeBase {
1339
- protected instance: Weave;
1340
- protected nodeType: string;
1341
- private logger;
1342
- protected previousPointer: string | null;
1343
- register(instance: Weave): this;
1344
- getNodeType(): string;
1345
- getLogger(): Logger;
1346
- getSelectionPlugin(): WeaveNodesSelectionPlugin;
1347
- isSelecting(): boolean;
1348
- isPasting(): boolean;
1349
- isNodeSelected(ele: default_3.Node): boolean;
1350
- setupDefaultNodeEvents(node: default_3.Node): void;
1351
- abstract createNode(id: string, props: WeaveElementAttributes): WeaveStateElement;
1352
- abstract createInstance(props: WeaveElementAttributes): WeaveElementInstance;
1353
- abstract updateInstance(instance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
1354
- abstract removeInstance(instance: WeaveElementInstance): void;
1355
- abstract toNode(instance: WeaveElementInstance): WeaveStateElement;
1356
- }
1357
-
1358
- export declare type WeaveNodesSelectionChangeCallback = (nodes: WeaveSelection[]) => void;
1359
-
1360
- export declare class WeaveNodesSelectionPlugin extends WeavePlugin {
1361
- private tr;
1362
- private selectionRectangle;
1363
- private active;
1364
- private cameFromSelectingMultiple;
1365
- private selecting;
1366
- private initialized;
1367
- private callbacks;
1368
- render: undefined;
1369
- constructor(callbacks: WeaveNodesSelectionPluginCallbacks);
1370
- registersLayers(): boolean;
1371
- getName(): string;
1372
- getLayerName(): string;
1373
- initLayer(): void;
1374
- init(): void;
1375
- private getLayer;
1376
- private triggerSelectedNodesEvent;
1377
- private initEvents;
1378
- getTransformer(): Transformer_2;
1379
- setSelectedNodes(nodes: default_3.Node[]): void;
1380
- getSelectedNodes(): (default_3.Group | default_3.Shape)[];
1381
- removeSelectedNodes(): void;
1382
- selectAll(): void;
1383
- selectNone(): void;
1384
- enable(): void;
1385
- disable(): void;
1386
- }
1387
-
1388
- export declare type WeaveNodesSelectionPluginCallbacks = {
1389
- onNodesChange: WeaveNodesSelectionChangeCallback;
1390
- onStageSelection?: WeaveNodesSelectionStageSelectionCallback;
1391
- };
1392
-
1393
- export declare type WeaveNodesSelectionStageSelectionCallback = () => void;
1394
-
1395
- export declare class WeaveNodesSnappingPlugin extends WeavePlugin {
1396
- private guideLineOffset;
1397
- render: undefined;
1398
- constructor();
1399
- registersLayers(): boolean;
1400
- getName(): string;
1401
- init(): void;
1402
- setEnabled(enabled: boolean): void;
1403
- private initEvents;
1404
- getLineGuideStops(skipShape: default_3.Node): LineGuideStop;
1405
- getObjectSnappingEdges(node: default_3.Node): NodeSnappingEdges;
1406
- getGuides(lineGuideStops: LineGuideStop, itemBounds: NodeSnappingEdges): Guide[];
1407
- drawGuides(guides: Guide[]): void;
1408
- enable(): void;
1409
- disable(): void;
1410
- }
1411
-
1412
- export declare type WeaveOnNodeMenuCallback = (instance: Weave, selection: WeaveSelection[], point: Vector2d, visible: boolean) => void;
1413
-
1414
- export declare type WeavePasteModel = {
1415
- weaveInstanceId: string;
1416
- weave: Record<string, WeaveStateElement>;
1417
- weaveMinPoint: Vector2d;
1418
- };
1419
-
1420
- export declare class WeavePenToolAction extends WeaveAction {
1421
- protected initialized: boolean;
1422
- protected initialCursor: string | null;
1423
- protected state: WeavePenToolActionState;
1424
- protected lineId: string | null;
1425
- protected tempLineId: string | null;
1426
- protected container: default_3.Layer | default_3.Group | undefined;
1427
- protected measureContainer: default_3.Layer | default_3.Group | undefined;
1428
- protected clickPoint: Vector2d | null;
1429
- protected tempPoint: default_3.Circle | undefined;
1430
- protected tempNextPoint: default_3.Circle | undefined;
1431
- protected cancelAction: () => void;
1432
- internalUpdate: undefined;
1433
- init: undefined;
1434
- constructor(callbacks: WeavePenToolCallbacks);
1435
- getName(): string;
1436
- initProps(): {
1437
- stroke: string;
1438
- strokeWidth: number;
1439
- opacity: number;
1440
- };
1441
- private setupEvents;
1442
- private setState;
1443
- private addLine;
1444
- private handleAdding;
1445
- private handleSettingSize;
1446
- private handleMovement;
1447
- trigger(cancelAction: () => void): void;
1448
- cleanup(): void;
1449
- }
1450
-
1451
- export declare type WeavePenToolActionState = (typeof PEN_TOOL_STATE)[WeavePenToolActionStateKeys];
1452
-
1453
- export declare type WeavePenToolActionStateKeys = keyof typeof PEN_TOOL_STATE;
1454
-
1455
- export declare type WeavePenToolCallbacks = WeaveActionCallbacks;
1456
-
1457
- export declare abstract class WeavePlugin implements WeavePluginBase {
1458
- protected instance: Weave;
1459
- protected name: string;
1460
- protected enabled: boolean;
1461
- private logger;
1462
- register(instance: Weave): this;
1463
- getName(): string;
1464
- getLogger(): Logger;
1465
- isEnabled(): boolean;
1466
- abstract init?(): void;
1467
- abstract render?(): void;
1468
- abstract enable(): void;
1469
- abstract disable(): void;
1470
- }
1471
-
1472
- export declare class WeaveRectangleNode extends WeaveNode {
1473
- protected nodeType: string;
1474
- createNode(key: string, props: WeaveElementAttributes): {
1475
- key: string;
1476
- type: string;
1477
- props: {
1478
- id: string;
1479
- nodeType: string;
1480
- children: never[];
1481
- };
1482
- };
1483
- createInstance(props: WeaveElementAttributes): Rect;
1484
- updateInstance(nodeInstance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
1485
- removeInstance(nodeInstance: WeaveElementInstance): void;
1486
- toNode(instance: WeaveElementInstance): {
1487
- key: string;
1488
- type: any;
1489
- props: {
1490
- id: string;
1491
- nodeType: any;
1492
- children: never[];
1493
- clearBeforeDraw?: boolean;
1494
- clipFunc?: (ctx: SceneContext) => ClipFuncOutput;
1495
- clipX?: number;
1496
- clipY?: number;
1497
- clipWidth?: number;
1498
- clipHeight?: number;
1499
- x?: number;
1500
- y?: number;
1501
- width?: number;
1502
- height?: number;
1503
- visible?: boolean;
1504
- listening?: boolean;
1505
- name?: string;
1506
- opacity?: number;
1507
- scale?: Vector2d;
1508
- scaleX?: number;
1509
- skewX?: number;
1510
- skewY?: number;
1511
- scaleY?: number;
1512
- rotation?: number;
1513
- rotationDeg?: number;
1514
- offset?: Vector2d;
1515
- offsetX?: number;
1516
- offsetY?: number;
1517
- draggable?: boolean;
1518
- dragDistance?: number;
1519
- dragBoundFunc?: (this: Node_2, pos: Vector2d) => Vector2d;
1520
- preventDefault?: boolean;
1521
- globalCompositeOperation?: "" | "source-over" | "source-in" | "source-out" | "source-atop" | "destination-over" | "destination-in" | "destination-out" | "destination-atop" | "lighter" | "copy" | "xor" | "multiply" | "screen" | "overlay" | "darken" | "lighten" | "color-dodge" | "color-burn" | "hard-light" | "soft-light" | "difference" | "exclusion" | "hue" | "saturation" | "color" | "luminosity";
1522
- filters?: Array<Filter>;
1523
- } | {
1524
- id: string;
1525
- nodeType: any;
1526
- children: never[];
1527
- fill?: string | CanvasGradient;
1528
- fillPatternImage?: HTMLImageElement;
1529
- fillPatternX?: number;
1530
- fillPatternY?: number;
1531
- fillPatternOffset?: Vector2d;
1532
- fillPatternOffsetX?: number;
1533
- fillPatternOffsetY?: number;
1534
- fillPatternScale?: Vector2d;
1535
- fillPatternScaleX?: number;
1536
- fillPatternScaleY?: number;
1537
- fillPatternRotation?: number;
1538
- fillPatternRepeat?: string;
1539
- fillLinearGradientStartPoint?: Vector2d;
1540
- fillLinearGradientStartPointX?: number;
1541
- fillLinearGradientStartPointY?: number;
1542
- fillLinearGradientEndPoint?: Vector2d;
1543
- fillLinearGradientEndPointX?: number;
1544
- fillLinearGradientEndPointY?: number;
1545
- fillLinearGradientColorStops?: Array<number | string>;
1546
- fillRadialGradientStartPoint?: Vector2d;
1547
- fillRadialGradientStartPointX?: number;
1548
- fillRadialGradientStartPointY?: number;
1549
- fillRadialGradientEndPoint?: Vector2d;
1550
- fillRadialGradientEndPointX?: number;
1551
- fillRadialGradientEndPointY?: number;
1552
- fillRadialGradientStartRadius?: number;
1553
- fillRadialGradientEndRadius?: number;
1554
- fillRadialGradientColorStops?: Array<number | string>;
1555
- fillEnabled?: boolean;
1556
- fillPriority?: string;
1557
- fillRule?: CanvasFillRule;
1558
- stroke?: string | CanvasGradient;
1559
- strokeWidth?: number;
1560
- fillAfterStrokeEnabled?: boolean;
1561
- hitStrokeWidth?: number | string;
1562
- strokeScaleEnabled?: boolean;
1563
- strokeHitEnabled?: boolean;
1564
- strokeEnabled?: boolean;
1565
- lineJoin?: LineJoin;
1566
- lineCap?: LineCap;
1567
- sceneFunc?: (con: Context, shape: Shape) => void;
1568
- hitFunc?: (con: Context, shape: Shape) => void;
1569
- shadowColor?: string;
1570
- shadowBlur?: number;
1571
- shadowOffset?: Vector2d;
1572
- shadowOffsetX?: number;
1573
- shadowOffsetY?: number;
1574
- shadowOpacity?: number;
1575
- shadowEnabled?: boolean;
1576
- shadowForStrokeEnabled?: boolean;
1577
- dash?: number[];
1578
- dashOffset?: number;
1579
- dashEnabled?: boolean;
1580
- perfectDrawEnabled?: boolean;
1581
- x?: number;
1582
- y?: number;
1583
- width?: number;
1584
- height?: number;
1585
- visible?: boolean;
1586
- listening?: boolean;
1587
- name?: string;
1588
- opacity?: number;
1589
- scale?: Vector2d;
1590
- scaleX?: number;
1591
- skewX?: number;
1592
- skewY?: number;
1593
- scaleY?: number;
1594
- rotation?: number;
1595
- rotationDeg?: number;
1596
- offset?: Vector2d;
1597
- offsetX?: number;
1598
- offsetY?: number;
1599
- draggable?: boolean;
1600
- dragDistance?: number;
1601
- dragBoundFunc?: (this: Node_2, pos: Vector2d) => Vector2d;
1602
- preventDefault?: boolean;
1603
- globalCompositeOperation?: "" | "source-over" | "source-in" | "source-out" | "source-atop" | "destination-over" | "destination-in" | "destination-out" | "destination-atop" | "lighter" | "copy" | "xor" | "multiply" | "screen" | "overlay" | "darken" | "lighten" | "color-dodge" | "color-burn" | "hard-light" | "soft-light" | "difference" | "exclusion" | "hue" | "saturation" | "color" | "luminosity";
1604
- filters?: Array<Filter>;
1605
- };
1606
- };
1607
- }
1608
-
1609
- export declare class WeaveRectangleToolAction extends WeaveAction {
1610
- protected initialized: boolean;
1611
- protected state: WeaveRectangleToolActionState;
1612
- protected rectId: string | null;
1613
- protected creating: boolean;
1614
- protected moved: boolean;
1615
- protected clickPoint: Vector2d | null;
1616
- protected container: default_3.Group | default_3.Layer | undefined;
1617
- protected cancelAction: () => void;
1618
- internalUpdate: undefined;
1619
- init: undefined;
1620
- constructor(callbacks: WeaveRectangleToolCallbacks);
1621
- getName(): string;
1622
- initProps(): {
1623
- opacity: number;
1624
- fill: string;
1625
- stroke: string;
1626
- strokeWidth: number;
1627
- width: number;
1628
- height: number;
1629
- };
1630
- private setupEvents;
1631
- private setState;
1632
- private addRectangle;
1633
- private handleAdding;
1634
- private handleSettingSize;
1635
- private handleMovement;
1636
- trigger(cancelAction: () => void): void;
1637
- cleanup(): void;
1638
- }
1639
-
1640
- export declare type WeaveRectangleToolActionState = (typeof RECTANGLE_TOOL_STATE)[WeaveRectangleToolActionStateKeys];
1641
-
1642
- export declare type WeaveRectangleToolActionStateKeys = keyof typeof RECTANGLE_TOOL_STATE;
1643
-
1644
- export declare type WeaveRectangleToolCallbacks = WeaveActionCallbacks;
1645
-
1646
- declare class WeaveRegisterManager {
1647
- private instance;
1648
- private nodesHandlers;
1649
- private actionsHandlers;
1650
- private plugins;
1651
- private logger;
1652
- constructor(instance: Weave);
1653
- getPlugins(): Record<string, WeavePlugin>;
1654
- getNodesHandlers(): Record<string, WeaveNode>;
1655
- getActionsHandlers(): Record<string, WeaveAction>;
1656
- getPlugin<T extends WeavePlugin>(pluginName: string): T;
1657
- getActionHandler<T extends WeaveAction>(actionName: string): T;
1658
- getNodeHandler(nodeType: string): WeaveNode;
1659
- registerPlugins(): void;
1660
- registerPlugin(plugin: WeavePlugin): void;
1661
- registerNodesHandlers(): void;
1662
- registerNodeHandler(node: WeaveNode): void;
1663
- registerActionsHandlers(): void;
1664
- registerActionHandler(action: WeaveAction): void;
1665
- }
1666
-
1667
- export declare class WeaveSelectionToolAction extends WeaveAction {
1668
- protected initialized: boolean;
1669
- protected state: WeaveSelectionToolActionState;
1670
- protected cancelAction: () => void;
1671
- internalUpdate: undefined;
1672
- init: undefined;
1673
- constructor();
1674
- getName(): string;
1675
- private setupEvents;
1676
- private setState;
1677
- private setSelection;
1678
- trigger(cancelAction: () => void): void;
1679
- cleanup(): void;
1680
- }
1681
-
1682
- export declare type WeaveSelectionToolActionState = (typeof SELECTION_TOOL_STATE)[WeaveSelectionToolActionStateKeys];
1683
-
1684
- export declare type WeaveSelectionToolActionStateKeys = keyof typeof SELECTION_TOOL_STATE;
1685
-
1686
- export declare type WeaveStageContextMenuPluginCallbacks = {
1687
- onNodeMenu: WeaveOnNodeMenuCallback;
1688
- };
1689
-
1690
- export declare type WeaveStageContextMenuPluginOptions = {
1691
- xOffset?: number;
1692
- yOffset?: number;
1693
- };
1694
-
1695
- export declare class WeaveStageDropAreaPlugin extends WeavePlugin {
1696
- private callbacks?;
1697
- getLayerName: undefined;
1698
- initLayer: undefined;
1699
- render: undefined;
1700
- constructor(callbacks?: WeaveStageDropAreaPluginCallbacks);
1701
- registersLayers(): boolean;
1702
- getName(): string;
1703
- init(): void;
1704
- private initEvents;
1705
- enable(): void;
1706
- disable(): void;
1707
- }
1708
-
1709
- export declare type WeaveStageDropAreaPluginCallbacks = {
1710
- onStageDrop?: WeaveStageDropCallback;
1711
- doUploadFile?: WeaveStageDropUploadFileCallback;
1712
- };
1713
-
1714
- export declare type WeaveStageDropCallback = (event: DragEvent) => void;
1715
-
1716
- export declare type WeaveStageDropUploadFileCallback = (event: File) => Promise<void>;
1717
-
1718
- export declare class WeaveStageGridPlugin extends WeavePlugin {
1719
- private moveToolActive;
1720
- private isMouseMiddleButtonPressed;
1721
- private isSpaceKeyPressed;
1722
- private type;
1723
- private gridColor;
1724
- private originColor;
1725
- private gridSize;
1726
- constructor(params: WeaveStageGridPluginParams);
1727
- registersLayers(): boolean;
1728
- getName(): string;
1729
- getLayerName(): string;
1730
- initLayer(): void;
1731
- init(): void;
1732
- private initEvents;
1733
- getLayer(): Layer | undefined;
1734
- private renderGrid;
1735
- private round;
1736
- private renderGridLines;
1737
- private renderGridDots;
1738
- render(): void;
1739
- enable(): void;
1740
- disable(): void;
1741
- getType(): WeaveStageGridType;
1742
- setType(type: WeaveStageGridType): void;
1743
- }
1744
-
1745
- export declare type WeaveStageGridPluginParams = {
1746
- gridSize?: number;
1747
- };
1748
-
1749
- export declare type WeaveStageGridType = (typeof WEAVE_GRID_TYPES)[WeaveStageGridTypeKeys];
1750
-
1751
- export declare type WeaveStageGridTypeKeys = keyof typeof WEAVE_GRID_TYPES;
1752
-
1753
- declare class WeaveStageManager {
1754
- private instance;
1755
- private logger;
1756
- private stage;
1757
- private config;
1758
- constructor(instance: Weave, config: default_3.StageConfig);
1759
- getConfiguration(): StageConfig;
1760
- setStage(stage: default_3.Stage): void;
1761
- getStage(): Stage;
1762
- getMainLayer(): default_3.Layer | undefined;
1763
- getInstanceRecursive(instance: default_3.Node, filterInstanceType?: string[]): default_3.Node;
1764
- initStage(): void;
1765
- }
1766
-
1767
- export declare class WeaveStageNode extends WeaveNode {
1768
- protected nodeType: string;
1769
- createNode(key: string, props: WeaveElementAttributes): {
1770
- key: string;
1771
- type: string;
1772
- props: {
1773
- id: string;
1774
- nodeType: string;
1775
- children: never[];
1776
- };
1777
- };
1778
- createInstance(props: WeaveElementAttributes): Stage;
1779
- updateInstance(): void;
1780
- removeInstance(nodeInstance: WeaveElementInstance): void;
1781
- toNode(instance: WeaveElementInstance): {
1782
- key: string;
1783
- type: any;
1784
- props: {
1785
- id: string;
1786
- nodeType: any;
1787
- children: never[];
1788
- clearBeforeDraw?: boolean;
1789
- clipFunc?: (ctx: SceneContext) => ClipFuncOutput;
1790
- clipX?: number;
1791
- clipY?: number;
1792
- clipWidth?: number;
1793
- clipHeight?: number;
1794
- x?: number;
1795
- y?: number;
1796
- width?: number;
1797
- height?: number;
1798
- visible?: boolean;
1799
- listening?: boolean;
1800
- name?: string;
1801
- opacity?: number;
1802
- scale?: Vector2d;
1803
- scaleX?: number;
1804
- skewX?: number;
1805
- skewY?: number;
1806
- scaleY?: number;
1807
- rotation?: number;
1808
- rotationDeg?: number;
1809
- offset?: Vector2d;
1810
- offsetX?: number;
1811
- offsetY?: number;
1812
- draggable?: boolean;
1813
- dragDistance?: number;
1814
- dragBoundFunc?: (this: Node_2, pos: Vector2d) => Vector2d;
1815
- preventDefault?: boolean;
1816
- globalCompositeOperation?: "" | "source-over" | "source-in" | "source-out" | "source-atop" | "destination-over" | "destination-in" | "destination-out" | "destination-atop" | "lighter" | "copy" | "xor" | "multiply" | "screen" | "overlay" | "darken" | "lighten" | "color-dodge" | "color-burn" | "hard-light" | "soft-light" | "difference" | "exclusion" | "hue" | "saturation" | "color" | "luminosity";
1817
- filters?: Array<Filter>;
1818
- } | {
1819
- id: string;
1820
- nodeType: any;
1821
- children: never[];
1822
- fill?: string | CanvasGradient;
1823
- fillPatternImage?: HTMLImageElement;
1824
- fillPatternX?: number;
1825
- fillPatternY?: number;
1826
- fillPatternOffset?: Vector2d;
1827
- fillPatternOffsetX?: number;
1828
- fillPatternOffsetY?: number;
1829
- fillPatternScale?: Vector2d;
1830
- fillPatternScaleX?: number;
1831
- fillPatternScaleY?: number;
1832
- fillPatternRotation?: number;
1833
- fillPatternRepeat?: string;
1834
- fillLinearGradientStartPoint?: Vector2d;
1835
- fillLinearGradientStartPointX?: number;
1836
- fillLinearGradientStartPointY?: number;
1837
- fillLinearGradientEndPoint?: Vector2d;
1838
- fillLinearGradientEndPointX?: number;
1839
- fillLinearGradientEndPointY?: number;
1840
- fillLinearGradientColorStops?: Array<number | string>;
1841
- fillRadialGradientStartPoint?: Vector2d;
1842
- fillRadialGradientStartPointX?: number;
1843
- fillRadialGradientStartPointY?: number;
1844
- fillRadialGradientEndPoint?: Vector2d;
1845
- fillRadialGradientEndPointX?: number;
1846
- fillRadialGradientEndPointY?: number;
1847
- fillRadialGradientStartRadius?: number;
1848
- fillRadialGradientEndRadius?: number;
1849
- fillRadialGradientColorStops?: Array<number | string>;
1850
- fillEnabled?: boolean;
1851
- fillPriority?: string;
1852
- fillRule?: CanvasFillRule;
1853
- stroke?: string | CanvasGradient;
1854
- strokeWidth?: number;
1855
- fillAfterStrokeEnabled?: boolean;
1856
- hitStrokeWidth?: number | string;
1857
- strokeScaleEnabled?: boolean;
1858
- strokeHitEnabled?: boolean;
1859
- strokeEnabled?: boolean;
1860
- lineJoin?: LineJoin;
1861
- lineCap?: LineCap;
1862
- sceneFunc?: (con: Context, shape: Shape) => void;
1863
- hitFunc?: (con: Context, shape: Shape) => void;
1864
- shadowColor?: string;
1865
- shadowBlur?: number;
1866
- shadowOffset?: Vector2d;
1867
- shadowOffsetX?: number;
1868
- shadowOffsetY?: number;
1869
- shadowOpacity?: number;
1870
- shadowEnabled?: boolean;
1871
- shadowForStrokeEnabled?: boolean;
1872
- dash?: number[];
1873
- dashOffset?: number;
1874
- dashEnabled?: boolean;
1875
- perfectDrawEnabled?: boolean;
1876
- x?: number;
1877
- y?: number;
1878
- width?: number;
1879
- height?: number;
1880
- visible?: boolean;
1881
- listening?: boolean;
1882
- name?: string;
1883
- opacity?: number;
1884
- scale?: Vector2d;
1885
- scaleX?: number;
1886
- skewX?: number;
1887
- skewY?: number;
1888
- scaleY?: number;
1889
- rotation?: number;
1890
- rotationDeg?: number;
1891
- offset?: Vector2d;
1892
- offsetX?: number;
1893
- offsetY?: number;
1894
- draggable?: boolean;
1895
- dragDistance?: number;
1896
- dragBoundFunc?: (this: Node_2, pos: Vector2d) => Vector2d;
1897
- preventDefault?: boolean;
1898
- globalCompositeOperation?: "" | "source-over" | "source-in" | "source-out" | "source-atop" | "destination-over" | "destination-in" | "destination-out" | "destination-atop" | "lighter" | "copy" | "xor" | "multiply" | "screen" | "overlay" | "darken" | "lighten" | "color-dodge" | "color-burn" | "hard-light" | "soft-light" | "difference" | "exclusion" | "hue" | "saturation" | "color" | "luminosity";
1899
- filters?: Array<Filter>;
1900
- };
1901
- };
1902
- }
1903
-
1904
- export declare class WeaveStagePanningPlugin extends WeavePlugin {
1905
- private moveToolActive;
1906
- private isMouseMiddleButtonPressed;
1907
- private isSpaceKeyPressed;
1908
- protected previousPointer: string | null;
1909
- getLayerName: undefined;
1910
- initLayer: undefined;
1911
- render: undefined;
1912
- constructor();
1913
- registersLayers(): boolean;
1914
- getName(): string;
1915
- init(): void;
1916
- private enableMove;
1917
- private disableMove;
1918
- private initEvents;
1919
- enable(): void;
1920
- disable(): void;
1921
- }
1922
-
1923
- export declare class WeaveStageResizePlugin extends WeavePlugin {
1924
- getLayerName: undefined;
1925
- initLayer: undefined;
1926
- render: undefined;
1927
- registersLayers(): boolean;
1928
- getName(): string;
1929
- init(): void;
1930
- enable(): void;
1931
- disable(): void;
1932
- }
1933
-
1934
- export declare type WeaveStageZoomChanged = {
1935
- scale: number;
1936
- zoomSteps: number[];
1937
- actualStep: number;
1938
- onDefaultStep: boolean;
1939
- canZoomIn: boolean;
1940
- canZoomOut: boolean;
1941
- };
1942
-
1943
- export declare type WeaveStageZoomOnZoomChangeCallback = (zoomInfo: WeaveStageZoomChanged) => void;
1944
-
1945
- export declare class WeaveStageZoomPlugin extends WeavePlugin {
1946
- getLayerName: undefined;
1947
- initLayer: undefined;
1948
- render: undefined;
1949
- private zoomSteps;
1950
- private actualScale;
1951
- private actualStep;
1952
- private padding;
1953
- defaultStep: number;
1954
- private onZoomChangeCb;
1955
- constructor(params: WeaveStageZoomPluginParams);
1956
- registersLayers(): boolean;
1957
- getName(): string;
1958
- init(): void;
1959
- private setZoom;
1960
- canZoomOut(): boolean;
1961
- canZoomIn(): boolean;
1962
- zoomToStep(step: number): void;
1963
- private findClosestStepIndex;
1964
- zoomIn(): void;
1965
- zoomOut(): void;
1966
- fitToScreen(): void;
1967
- fitToSelection(): void;
1968
- enable(): void;
1969
- disable(): void;
1970
- }
1971
-
1972
- export declare type WeaveStageZoomPluginParams = {
1973
- zoomSteps?: number[];
1974
- defaultZoom?: number;
1975
- onZoomChange?: WeaveStageZoomOnZoomChangeCallback;
1976
- };
1977
-
1978
- export declare abstract class WeaveStore implements WeaveStoreBase {
1979
- protected instance: Weave;
1980
- protected name: string;
1981
- protected supportsUndoManager: boolean;
1982
- protected config: WeaveStoreOptions;
1983
- private state;
1984
- private latestState;
1985
- private document;
1986
- private logger;
1987
- private undoManager;
1988
- private isRoomLoaded;
1989
- constructor(config: WeaveStoreOptions);
1990
- getName(): string;
1991
- getLogger(): Logger;
1992
- register(instance: Weave): this;
1993
- getUser(): WeaveUser;
1994
- setState(state: WeaveState): void;
1995
- setLatestState(newState: WeaveState): void;
1996
- getLatestState(): WeaveState;
1997
- getDocument(): Doc;
1998
- getState(): MappedTypeDescription<WeaveState>;
1999
- getStateJson(): WeaveState;
2000
- setup(): void;
2001
- canUndoStateStep(): boolean;
2002
- canRedoStateStep(): boolean;
2003
- undoStateStep(): void;
2004
- redoStateStep(): void;
2005
- abstract connect(): void;
2006
- abstract disconnect(): void;
2007
- abstract onAwarenessChange<K extends string, T>(callback: (changes: WeaveAwarenessChange<K, T>[]) => void): void;
2008
- abstract setAwarenessInfo(field: string, value: unknown): void;
2009
- }
2010
-
2011
- export declare class WeaveTextNode extends WeaveNode {
2012
- protected nodeType: string;
2013
- private editing;
2014
- constructor();
2015
- getType(): string;
2016
- createNode(key: string, props: WeaveElementAttributes): {
2017
- key: string;
2018
- type: string;
2019
- props: {
2020
- id: string;
2021
- nodeType: string;
2022
- children: never[];
2023
- };
2024
- };
2025
- private updateNode;
2026
- createInstance(props: WeaveElementAttributes): Text_2;
2027
- updateInstance(nodeInstance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
2028
- removeInstance(nodeInstance: WeaveElementInstance): void;
2029
- toNode(instance: WeaveElementInstance): {
2030
- key: string;
2031
- type: any;
2032
- props: {
2033
- id: string;
2034
- nodeType: any;
2035
- children: never[];
2036
- clearBeforeDraw?: boolean;
2037
- clipFunc?: (ctx: SceneContext) => ClipFuncOutput;
2038
- clipX?: number;
2039
- clipY?: number;
2040
- clipWidth?: number;
2041
- clipHeight?: number;
2042
- x?: number;
2043
- y?: number;
2044
- width?: number;
2045
- height?: number;
2046
- visible?: boolean;
2047
- listening?: boolean;
2048
- name?: string;
2049
- opacity?: number;
2050
- scale?: Vector2d;
2051
- scaleX?: number;
2052
- skewX?: number;
2053
- skewY?: number;
2054
- scaleY?: number;
2055
- rotation?: number;
2056
- rotationDeg?: number;
2057
- offset?: Vector2d;
2058
- offsetX?: number;
2059
- offsetY?: number;
2060
- draggable?: boolean;
2061
- dragDistance?: number;
2062
- dragBoundFunc?: (this: Node_2, pos: Vector2d) => Vector2d;
2063
- preventDefault?: boolean;
2064
- globalCompositeOperation?: "" | "source-over" | "source-in" | "source-out" | "source-atop" | "destination-over" | "destination-in" | "destination-out" | "destination-atop" | "lighter" | "copy" | "xor" | "multiply" | "screen" | "overlay" | "darken" | "lighten" | "color-dodge" | "color-burn" | "hard-light" | "soft-light" | "difference" | "exclusion" | "hue" | "saturation" | "color" | "luminosity";
2065
- filters?: Array<Filter>;
2066
- } | {
2067
- id: string;
2068
- nodeType: any;
2069
- children: never[];
2070
- fill?: string | CanvasGradient;
2071
- fillPatternImage?: HTMLImageElement;
2072
- fillPatternX?: number;
2073
- fillPatternY?: number;
2074
- fillPatternOffset?: Vector2d;
2075
- fillPatternOffsetX?: number;
2076
- fillPatternOffsetY?: number;
2077
- fillPatternScale?: Vector2d;
2078
- fillPatternScaleX?: number;
2079
- fillPatternScaleY?: number;
2080
- fillPatternRotation?: number;
2081
- fillPatternRepeat?: string;
2082
- fillLinearGradientStartPoint?: Vector2d;
2083
- fillLinearGradientStartPointX?: number;
2084
- fillLinearGradientStartPointY?: number;
2085
- fillLinearGradientEndPoint?: Vector2d;
2086
- fillLinearGradientEndPointX?: number;
2087
- fillLinearGradientEndPointY?: number;
2088
- fillLinearGradientColorStops?: Array<number | string>;
2089
- fillRadialGradientStartPoint?: Vector2d;
2090
- fillRadialGradientStartPointX?: number;
2091
- fillRadialGradientStartPointY?: number;
2092
- fillRadialGradientEndPoint?: Vector2d;
2093
- fillRadialGradientEndPointX?: number;
2094
- fillRadialGradientEndPointY?: number;
2095
- fillRadialGradientStartRadius?: number;
2096
- fillRadialGradientEndRadius?: number;
2097
- fillRadialGradientColorStops?: Array<number | string>;
2098
- fillEnabled?: boolean;
2099
- fillPriority?: string;
2100
- fillRule?: CanvasFillRule;
2101
- stroke?: string | CanvasGradient;
2102
- strokeWidth?: number;
2103
- fillAfterStrokeEnabled?: boolean;
2104
- hitStrokeWidth?: number | string;
2105
- strokeScaleEnabled?: boolean;
2106
- strokeHitEnabled?: boolean;
2107
- strokeEnabled?: boolean;
2108
- lineJoin?: LineJoin;
2109
- lineCap?: LineCap;
2110
- sceneFunc?: (con: Context, shape: Shape) => void;
2111
- hitFunc?: (con: Context, shape: Shape) => void;
2112
- shadowColor?: string;
2113
- shadowBlur?: number;
2114
- shadowOffset?: Vector2d;
2115
- shadowOffsetX?: number;
2116
- shadowOffsetY?: number;
2117
- shadowOpacity?: number;
2118
- shadowEnabled?: boolean;
2119
- shadowForStrokeEnabled?: boolean;
2120
- dash?: number[];
2121
- dashOffset?: number;
2122
- dashEnabled?: boolean;
2123
- perfectDrawEnabled?: boolean;
2124
- x?: number;
2125
- y?: number;
2126
- width?: number;
2127
- height?: number;
2128
- visible?: boolean;
2129
- listening?: boolean;
2130
- name?: string;
2131
- opacity?: number;
2132
- scale?: Vector2d;
2133
- scaleX?: number;
2134
- skewX?: number;
2135
- skewY?: number;
2136
- scaleY?: number;
2137
- rotation?: number;
2138
- rotationDeg?: number;
2139
- offset?: Vector2d;
2140
- offsetX?: number;
2141
- offsetY?: number;
2142
- draggable?: boolean;
2143
- dragDistance?: number;
2144
- dragBoundFunc?: (this: Node_2, pos: Vector2d) => Vector2d;
2145
- preventDefault?: boolean;
2146
- globalCompositeOperation?: "" | "source-over" | "source-in" | "source-out" | "source-atop" | "destination-over" | "destination-in" | "destination-out" | "destination-atop" | "lighter" | "copy" | "xor" | "multiply" | "screen" | "overlay" | "darken" | "lighten" | "color-dodge" | "color-burn" | "hard-light" | "soft-light" | "difference" | "exclusion" | "hue" | "saturation" | "color" | "luminosity";
2147
- filters?: Array<Filter>;
2148
- };
2149
- };
2150
- private createTextAreaDOM;
2151
- private removeTextAreaDOM;
2152
- private triggerEditMode;
2153
- }
2154
-
2155
- export declare class WeaveTextToolAction extends WeaveAction {
2156
- protected initialized: boolean;
2157
- protected initialCursor: string | null;
2158
- protected state: WeaveTextToolActionState;
2159
- protected textId: string | null;
2160
- protected container: default_3.Layer | default_3.Group | undefined;
2161
- protected clickPoint: Vector2d | null;
2162
- protected cancelAction: () => void;
2163
- internalUpdate: undefined;
2164
- init: undefined;
2165
- constructor();
2166
- getName(): string;
2167
- private setupEvents;
2168
- private setState;
2169
- private addText;
2170
- private handleAdding;
2171
- trigger(cancelAction: () => void): void;
2172
- cleanup(): void;
2173
- }
2174
-
2175
- export declare type WeaveTextToolActionState = (typeof TEXT_TOOL_STATE)[WeaveTextToolActionStateKeys];
2176
-
2177
- export declare type WeaveTextToolActionStateKeys = keyof typeof TEXT_TOOL_STATE;
2178
-
2179
- export declare type WeaveToPasteNode = {
2180
- konvaNode: default_3.Node;
2181
- node: NodeSerializable;
2182
- };
2183
-
2184
- export declare type WeaveUserPointer = {
2185
- user: string;
2186
- x: number;
2187
- y: number;
2188
- };
2189
-
2190
- export declare type WeaveUserPointerKey = typeof WEAVE_USER_POINTER_KEY;
2191
-
2192
- export declare class WeaveUsersPointersPlugin extends WeavePlugin {
2193
- private usersPointers;
2194
- private usersPointersTimers;
2195
- private getUser;
2196
- private renderCursors;
2197
- private userPointerCircleRadius;
2198
- private userPointerSeparation;
2199
- private userPointerCircleStrokeWidth;
2200
- private userPointerNameFontSize;
2201
- private userPointerBackgroundCornerRadius;
2202
- private userPointerBackgroundPaddingX;
2203
- private userPointerBackgroundPaddingY;
2204
- render: undefined;
2205
- constructor(params: WeaveUsersPointersPluginParams);
2206
- registersLayers(): boolean;
2207
- getName(): string;
2208
- getLayerName(): string;
2209
- initLayer(): void;
2210
- getLayer(): default_3.Layer | undefined;
2211
- init(): void;
2212
- private stringToColour;
2213
- private setUserMovementTimer;
2214
- private renderPointers;
2215
- toggleRenderCursors(): void;
2216
- setRenderCursors(render: boolean): void;
2217
- enable(): void;
2218
- disable(): void;
2219
- }
2220
-
2221
- export declare type WeaveUsersPointersPluginParams = {
2222
- getUser?: () => WeaveUser;
2223
- };
2224
-
2225
- export declare class WeaveZoomInToolAction extends WeaveAction {
2226
- protected previousAction: string;
2227
- protected cancelAction: () => void;
2228
- internalUpdate: undefined;
2229
- getName(): string;
2230
- private getStageZoomPlugin;
2231
- init(): void;
2232
- trigger(cancelAction: () => void, params: WeaveZoomInToolActionParams): void;
2233
- cleanup(): void;
2234
- }
2235
-
2236
- export declare type WeaveZoomInToolActionParams = {
2237
- previousAction: string;
2238
- };
2239
-
2240
- export declare class WeaveZoomOutToolAction extends WeaveAction {
2241
- protected previousAction: string;
2242
- protected cancelAction: () => void;
2243
- internalUpdate: undefined;
2244
- getName(): string;
2245
- private getStageZoomPlugin;
2246
- init(): void;
2247
- trigger(cancelAction: () => void, params: WeaveZoomOutToolActionParams): void;
2248
- cleanup(): void;
2249
- }
2250
-
2251
- export declare type WeaveZoomOutToolActionParams = {
2252
- previousAction: string;
2253
- };
2254
-
2255
- export { }
1
+ import Konva from "konva";
2
+ import { Vector2d } from "konva/lib/types";
3
+ import { MappedTypeDescription } from "@syncedstore/core/types/doc";
4
+ import { Doc } from "yjs";
5
+ import Emittery from "emittery";
6
+ import pino, { Logger } from "pino";
7
+ import { StageConfig } from "konva/lib/Stage";
8
+
9
+ //#region ../types/dist/types.d.ts
10
+ declare const WEAVE_INSTANCE_STATUS: {
11
+ readonly "IDLE": "idle";
12
+ readonly "STARTING": "starting";
13
+ readonly "LOADING_FONTS": "loadingFonts";
14
+ readonly "RUNNING": "running";
15
+ };
16
+ declare const WEAVE_NODE_POSITION: {
17
+ readonly "UP": "up";
18
+ readonly "DOWN": "down";
19
+ readonly "FRONT": "front";
20
+ readonly "BACK": "back";
21
+ };
22
+ declare const WEAVE_EXPORT_FORMATS: {
23
+ readonly "PNG": "image/png";
24
+ readonly "JPEG": "image/jpeg";
25
+ };
26
+ //#endregion
27
+ //#region src/base/action.d.ts
28
+ interface WeaveActionBase {
29
+ init?(): void;
30
+ trigger(cancelAction: () => void, params?: unknown): unknown;
31
+ internalUpdate?(): void;
32
+ cleanup?(): void;
33
+ }
34
+
35
+ //#endregion
36
+ //#region src/base/plugin.d.ts
37
+ interface WeavePluginBase {
38
+ init?(): void;
39
+ render?(): void;
40
+ enable(): void;
41
+ disable(): void;
42
+ isEnabled(): boolean;
43
+ }
44
+
45
+ //#endregion
46
+ //#region src/base/store.d.ts
47
+ type WeaveStoreOptions = {
48
+ getUser: () => WeaveUser;
49
+ undoManagerOptions?: WeaveUndoManagerOptions;
50
+ };
51
+ interface WeaveStoreBase {
52
+ connect(): void;
53
+ disconnect(): void;
54
+ onAwarenessChange<K extends string, T>(callback: (changes: WeaveAwarenessChange<K, T>[]) => void): void;
55
+ setAwarenessInfo(field: string, value: unknown): void;
56
+ }
57
+
58
+ //#endregion
59
+ //#region src/types.d.ts
60
+ type WeaveConfig = {
61
+ store: WeaveStoreBase;
62
+ nodes?: WeaveNodeBase[];
63
+ actions?: WeaveActionBase[];
64
+ plugins?: WeavePluginBase[];
65
+ fonts?: WeaveFont[];
66
+ callbacks?: WeaveCallbacks;
67
+ logger?: WeaveLoggerConfig;
68
+ };
69
+ type WeaveStatusKeys = keyof typeof WEAVE_INSTANCE_STATUS;
70
+ type WeaveStatus = (typeof WEAVE_INSTANCE_STATUS)[WeaveStatusKeys];
71
+ type NodeSerializable = Konva.NodeConfig & {
72
+ id: string;
73
+ type: string;
74
+ };
75
+ type WeaveElementAttributes = {
76
+ [key: string]: any;
77
+ id?: string;
78
+ nodeType?: string;
79
+ children?: WeaveStateElement[];
80
+ };
81
+ type WeaveStateElement = {
82
+ key: string;
83
+ type: string;
84
+ props: WeaveElementAttributes;
85
+ };
86
+ type WeaveState = {
87
+ weave: {
88
+ key: "stage";
89
+ type: "stage";
90
+ props: {
91
+ [key: string]: unknown;
92
+ id: "stage";
93
+ children: WeaveStateElement[];
94
+ };
95
+ } | Record<string, WeaveStateElement>;
96
+ };
97
+ type WeaveSelection = {
98
+ instance: Konva.Shape | Konva.Group;
99
+ node: WeaveStateElement;
100
+ };
101
+ type WeaveMousePointInfoSimple = {
102
+ mousePoint: Vector2d;
103
+ container: Konva.Layer | Konva.Group | undefined;
104
+ };
105
+ type WeaveMousePointInfo = WeaveMousePointInfoSimple & {
106
+ measureContainer: Konva.Layer | Konva.Group | undefined;
107
+ };
108
+ type WeaveSerializedGroup = {
109
+ serializedNodes: WeaveStateElement[];
110
+ minPoint: Vector2d;
111
+ } | undefined;
112
+ type WeaveNodeFound = {
113
+ node: WeaveStateElement | null;
114
+ parent: WeaveStateElement | null;
115
+ index: number;
116
+ };
117
+ type WeaveAwarenessChange<K extends string, T> = { [key in K]: T };
118
+ type WeaveElementInstance = Konva.Layer | Konva.Group | Konva.Shape;
119
+ type WeaveLoggerConfig = {
120
+ disabled?: boolean;
121
+ level?: "debug" | "info" | "warn" | "error";
122
+ };
123
+ type WeavePositionKeys = keyof typeof WEAVE_NODE_POSITION;
124
+ type WeavePosition = (typeof WEAVE_NODE_POSITION)[WeavePositionKeys];
125
+ type WeaveExportNodeOptions = {
126
+ format?: typeof WEAVE_EXPORT_FORMATS.PNG;
127
+ padding?: number;
128
+ pixelRatio?: number;
129
+ backgroundColor?: string;
130
+ quality?: number;
131
+ };
132
+ type WeaveUser = {
133
+ name: string;
134
+ email: string;
135
+ };
136
+ type WeaveFont = {
137
+ id: string;
138
+ name: string;
139
+ };
140
+ type WeaveUndoManagerOptions = {
141
+ captureTimeout?: number;
142
+ trackedOrigins?: Set<any>;
143
+ };
144
+ type WeaveUndoRedoChange = {
145
+ canRedo: boolean;
146
+ canUndo: boolean;
147
+ redoStackLength: number;
148
+ undoStackLength: number;
149
+ };
150
+ type WeaveCallbacks = {
151
+ onRender?: () => void;
152
+ onRoomLoaded?: (loaded: boolean) => void;
153
+ onInstanceStatus?: (status: WeaveStatus) => void;
154
+ onActiveActionChange?: (actionName: string | undefined) => void;
155
+ onStateChange?: (state: WeaveState) => void;
156
+ onUndoManagerStatusChange?: (undoManagerStatus: WeaveUndoRedoChange) => void;
157
+ };
158
+
159
+ //#endregion
160
+ //#region src/base/node.d.ts
161
+ interface WeaveNodeBase {
162
+ createNode(id: string, props: WeaveElementAttributes): WeaveStateElement;
163
+ createInstance(props: WeaveElementAttributes): WeaveElementInstance;
164
+ updateInstance(instance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
165
+ removeInstance(instance: WeaveElementInstance): void;
166
+ toNode(instance: WeaveElementInstance): WeaveStateElement;
167
+ } //#endregion
168
+ //#region src/stores/store.d.ts
169
+
170
+ //#endregion
171
+ declare abstract class WeaveStore implements WeaveStoreBase {
172
+ protected instance: Weave;
173
+ protected name: string;
174
+ protected supportsUndoManager: boolean;
175
+ protected config: WeaveStoreOptions;
176
+ private state;
177
+ private latestState;
178
+ private document;
179
+ private logger;
180
+ private undoManager;
181
+ private isRoomLoaded;
182
+ constructor(config: WeaveStoreOptions);
183
+ getName(): string;
184
+ getLogger(): Logger;
185
+ register(instance: Weave): WeaveStore;
186
+ getUser(): WeaveUser;
187
+ setState(state: WeaveState): void;
188
+ setLatestState(newState: WeaveState): void;
189
+ getLatestState(): WeaveState;
190
+ getDocument(): Doc;
191
+ getState(): MappedTypeDescription<WeaveState>;
192
+ getStateJson(): WeaveState;
193
+ setup(): void;
194
+ canUndoStateStep(): boolean;
195
+ canRedoStateStep(): boolean;
196
+ undoStateStep(): void;
197
+ redoStateStep(): void;
198
+ abstract connect(): void;
199
+ abstract disconnect(): void;
200
+ abstract onAwarenessChange<K extends string, T>(callback: (changes: WeaveAwarenessChange<K, T>[]) => void): void;
201
+ abstract setAwarenessInfo(field: string, value: unknown): void;
202
+ }
203
+
204
+ //#endregion
205
+ //#region src/plugins/plugin.d.ts
206
+ declare abstract class WeavePlugin implements WeavePluginBase {
207
+ protected instance: Weave;
208
+ protected name: string;
209
+ protected enabled: boolean;
210
+ private logger;
211
+ register(instance: Weave): WeavePlugin;
212
+ getName(): string;
213
+ getLogger(): Logger;
214
+ isEnabled(): boolean;
215
+ abstract init?(): void;
216
+ abstract render?(): void;
217
+ abstract enable(): void;
218
+ abstract disable(): void;
219
+ }
220
+
221
+ //#endregion
222
+ //#region src/plugins/nodes-selection/types.d.ts
223
+ type WeaveNodesSelectionChangeCallback = (nodes: WeaveSelection[]) => void;
224
+ type WeaveNodesSelectionStageSelectionCallback = () => void;
225
+ type WeaveNodesSelectionPluginCallbacks = {
226
+ onNodesChange: WeaveNodesSelectionChangeCallback;
227
+ onStageSelection?: WeaveNodesSelectionStageSelectionCallback;
228
+ };
229
+
230
+ //#endregion
231
+ //#region src/plugins/nodes-selection/nodes-selection.d.ts
232
+ declare class WeaveNodesSelectionPlugin extends WeavePlugin {
233
+ private tr;
234
+ private selectionRectangle;
235
+ private active;
236
+ private cameFromSelectingMultiple;
237
+ private selecting;
238
+ private initialized;
239
+ private callbacks;
240
+ render: undefined;
241
+ constructor(callbacks: WeaveNodesSelectionPluginCallbacks);
242
+ getName(): string;
243
+ getLayerName(): string;
244
+ initLayer(): void;
245
+ init(): void;
246
+ private getLayer;
247
+ private triggerSelectedNodesEvent;
248
+ private initEvents;
249
+ getTransformer(): Konva.Transformer;
250
+ setSelectedNodes(nodes: Konva.Node[]): void;
251
+ getSelectedNodes(): (Konva.Group | Konva.Shape)[];
252
+ removeSelectedNodes(): void;
253
+ selectAll(): void;
254
+ selectNone(): void;
255
+ enable(): void;
256
+ disable(): void;
257
+ }
258
+
259
+ //#endregion
260
+ //#region src/nodes/node.d.ts
261
+ declare abstract class WeaveNode implements WeaveNodeBase {
262
+ protected instance: Weave;
263
+ protected nodeType: string;
264
+ private logger;
265
+ protected previousPointer: string | null;
266
+ register(instance: Weave): WeaveNode;
267
+ getNodeType(): string;
268
+ getLogger(): Logger;
269
+ getSelectionPlugin(): WeaveNodesSelectionPlugin;
270
+ isSelecting(): boolean;
271
+ isPasting(): boolean;
272
+ isNodeSelected(ele: Konva.Node): boolean;
273
+ setupDefaultNodeEvents(node: Konva.Node): void;
274
+ abstract createNode(id: string, props: WeaveElementAttributes): WeaveStateElement;
275
+ abstract createInstance(props: WeaveElementAttributes): WeaveElementInstance;
276
+ abstract updateInstance(instance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
277
+ abstract removeInstance(instance: WeaveElementInstance): void;
278
+ abstract toNode(instance: WeaveElementInstance): WeaveStateElement;
279
+ }
280
+
281
+ //#endregion
282
+ //#region src/actions/types.d.ts
283
+ type WeaveActionPropsChangeCallback = (props: WeaveElementAttributes) => void;
284
+ type WeaveActionCallbacks = {
285
+ onPropsChange?: WeaveActionPropsChangeCallback;
286
+ };
287
+
288
+ //#endregion
289
+ //#region src/actions/action.d.ts
290
+ declare abstract class WeaveAction {
291
+ protected instance: Weave;
292
+ protected name: string;
293
+ props: WeaveElementAttributes;
294
+ protected callbacks: WeaveActionCallbacks | undefined;
295
+ private logger;
296
+ constructor(callbacks?: WeaveActionCallbacks);
297
+ getName(): string;
298
+ getLogger(): Logger;
299
+ register(instance: Weave): WeaveAction;
300
+ updateProps(props: WeaveElementAttributes): void;
301
+ getProps(): WeaveElementAttributes;
302
+ abstract init?(): void;
303
+ abstract trigger(cancelAction: () => void, params?: unknown): unknown;
304
+ abstract internalUpdate?(): void;
305
+ abstract cleanup?(): void;
306
+ }
307
+
308
+ //#endregion
309
+ //#region src/logger/logger.d.ts
310
+ declare class WeaveLogger {
311
+ private config;
312
+ private disabled;
313
+ private logger;
314
+ constructor(config: WeaveLoggerConfig);
315
+ private log;
316
+ getDisabled(): boolean;
317
+ getLevel(): pino.LevelWithSilentOrString;
318
+ getLogger(): Logger;
319
+ getChildLogger(name: string): pino.Logger<never, boolean>;
320
+ }
321
+
322
+ //#endregion
323
+ //#region src/managers/register.d.ts
324
+ declare class WeaveRegisterManager {
325
+ private instance;
326
+ private nodesHandlers;
327
+ private actionsHandlers;
328
+ private plugins;
329
+ private logger;
330
+ constructor(instance: Weave);
331
+ getPlugins(): Record<string, WeavePlugin>;
332
+ getNodesHandlers(): Record<string, WeaveNode>;
333
+ getActionsHandlers(): Record<string, WeaveAction>;
334
+ getPlugin<T extends WeavePlugin>(pluginName: string): T;
335
+ getActionHandler<T extends WeaveAction>(actionName: string): T;
336
+ getNodeHandler(nodeType: string): WeaveNode;
337
+ registerPlugins(): void;
338
+ registerPlugin(plugin: WeavePlugin): void;
339
+ registerNodesHandlers(): void;
340
+ registerNodeHandler(node: WeaveNode): void;
341
+ registerActionsHandlers(): void;
342
+ registerActionHandler(action: WeaveAction): void;
343
+ }
344
+
345
+ //#endregion
346
+ //#region src/managers/stage.d.ts
347
+ declare class WeaveStageManager {
348
+ private instance;
349
+ private logger;
350
+ private stage;
351
+ private config;
352
+ constructor(instance: Weave, config: Konva.StageConfig);
353
+ getConfiguration(): StageConfig;
354
+ setStage(stage: Konva.Stage): void;
355
+ getStage(): Konva.Stage;
356
+ getMainLayer(): Konva.Layer | undefined;
357
+ getInstanceRecursive(instance: Konva.Node, filterInstanceType?: string[]): Konva.Node;
358
+ initStage(): void;
359
+ }
360
+
361
+ //#endregion
362
+ //#region src/weave.d.ts
363
+ declare class Weave extends Emittery {
364
+ private id;
365
+ private config;
366
+ private logger;
367
+ private moduleLogger;
368
+ private reconciler;
369
+ private stateSerializer;
370
+ private renderer;
371
+ private status;
372
+ private setupManager;
373
+ private registerManager;
374
+ private stateManager;
375
+ private storeManager;
376
+ private stageManager;
377
+ private groupsManager;
378
+ private targetingManager;
379
+ private cloningManager;
380
+ private fontsManager;
381
+ private zIndexManager;
382
+ private pluginsManager;
383
+ private actionsManager;
384
+ private exportManager;
385
+ constructor(weaveConfig: WeaveConfig, stageConfig: Konva.StageConfig);
386
+ setupRenderer(): void;
387
+ setStatus(status: WeaveStatus): void;
388
+ getStatus(): WeaveStatus;
389
+ setStore(store: WeaveStore): void;
390
+ start(): Promise<void>;
391
+ getId(): string;
392
+ getConfiguration(): WeaveConfig;
393
+ emitEvent<T>(event: string, payload: T): void;
394
+ addEventListener<T>(event: string, callback: (payload: T) => void): void;
395
+ removeEventListener<T>(event: string, callback: (payload: T) => void): void;
396
+ getLogger(): WeaveLogger;
397
+ getMainLogger(): Logger;
398
+ getChildLogger(name: string): pino.Logger<never, boolean>;
399
+ getStageManager(): WeaveStageManager;
400
+ getStage(): Konva.Stage;
401
+ getMainLayer(): Konva.Layer | undefined;
402
+ setStage(stage: Konva.Stage): void;
403
+ getStageConfiguration(): StageConfig;
404
+ getInstanceRecursive(instance: Konva.Node, filterInstanceType?: string[]): Konva.Node;
405
+ getRegisterManager(): WeaveRegisterManager;
406
+ getPlugins(): Record<string, WeavePlugin>;
407
+ getPlugin<T extends WeavePlugin>(pluginName: string): T;
408
+ getNodesHandlers(): Record<string, WeaveNode>;
409
+ getNodeHandler<T extends WeaveNode>(nodeType: string): T;
410
+ getActionsHandlers(): Record<string, WeaveAction>;
411
+ getActionHandler<T extends WeaveAction>(actionName: string): T;
412
+ getStore<T extends WeaveStore>(): T;
413
+ registerPlugin(plugin: WeavePlugin): void;
414
+ registerNodeHandler(node: WeaveNode): void;
415
+ registerActionHandler(action: WeaveAction): void;
416
+ registerStore(store: WeaveStore): void;
417
+ isPluginEnabled(pluginName: string): boolean;
418
+ enablePlugin(pluginName: string): void;
419
+ disablePlugin(pluginName: string): void;
420
+ getActiveAction(): string | undefined;
421
+ triggerAction<T>(actionName: string, params?: T): unknown;
422
+ getPropsAction(actionName: string): WeaveElementAttributes;
423
+ updatePropsAction(actionName: string, params: WeaveElementAttributes): void;
424
+ cancelAction(actionName: string): void;
425
+ update(newState: WeaveState): void;
426
+ render(): void;
427
+ findNodeById(tree: WeaveStateElement, key: string, parent?: WeaveStateElement | null, index?: number): WeaveNodeFound;
428
+ findNodesByType(tree: WeaveStateElement, nodeType: string): WeaveStateElement[];
429
+ getNode(nodeKey: string): {
430
+ node: WeaveStateElement | null;
431
+ parent: WeaveStateElement | null;
432
+ index: number;
433
+ };
434
+ addNode(node: WeaveStateElement, parentId?: string, index?: number | undefined, doRender?: boolean): void;
435
+ updateNode(node: WeaveStateElement, doRender?: boolean): void;
436
+ removeNode(node: WeaveStateElement, doRender?: boolean): void;
437
+ removeNodes(nodes: WeaveStateElement[], doRender?: boolean): void;
438
+ moveNode(node: WeaveStateElement, position: WeavePosition, doRender?: boolean): void;
439
+ moveUp(node: WeaveElementInstance): void;
440
+ moveDown(node: WeaveElementInstance): void;
441
+ sendToBack(node: WeaveElementInstance): void;
442
+ bringToFront(node: WeaveElementInstance): void;
443
+ group(nodes: WeaveStateElement[]): void;
444
+ unGroup(group: WeaveStateElement): void;
445
+ getMousePointer(point?: Vector2d): WeaveMousePointInfo;
446
+ getMousePointerRelativeToContainer(container: Konva.Group | Konva.Layer): WeaveMousePointInfoSimple;
447
+ nodesToGroupSerialized(instancesToClone: Konva.Node[]): WeaveSerializedGroup;
448
+ cloneNodes(instancesToClone: Konva.Node[], targetContainer: Konva.Layer | Konva.Group | undefined, onPoint: Vector2d): void;
449
+ getFonts(): WeaveFont[];
450
+ exportStage(options: WeaveExportNodeOptions): Promise<HTMLImageElement>;
451
+ exportNode(node: WeaveElementInstance, options: WeaveExportNodeOptions): Promise<HTMLImageElement>;
452
+ }
453
+
454
+ //#endregion
455
+ //#region src/utils.d.ts
456
+ declare function resetScale(node: Konva.Node): void;
457
+
458
+ //#endregion
459
+ //#region src/nodes/stage/stage.d.ts
460
+ declare class WeaveStageNode extends WeaveNode {
461
+ protected nodeType: string;
462
+ createNode(key: string, props: WeaveElementAttributes): WeaveStateElement;
463
+ createInstance(props: WeaveElementAttributes): WeaveElementInstance;
464
+ updateInstance(): void;
465
+ removeInstance(nodeInstance: WeaveElementInstance): void;
466
+ toNode(instance: WeaveElementInstance): WeaveStateElement;
467
+ }
468
+
469
+ //#endregion
470
+ //#region src/nodes/layer/layer.d.ts
471
+ declare class WeaveLayerNode extends WeaveNode {
472
+ protected nodeType: string;
473
+ createNode(key: string, props: WeaveElementAttributes): WeaveStateElement;
474
+ createInstance(props: WeaveElementAttributes): WeaveElementInstance;
475
+ updateInstance(nodeInstance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
476
+ removeInstance(nodeInstance: WeaveElementInstance): void;
477
+ toNode(instance: WeaveElementInstance): WeaveStateElement;
478
+ }
479
+
480
+ //#endregion
481
+ //#region src/nodes/group/group.d.ts
482
+ declare class WeaveGroupNode extends WeaveNode {
483
+ protected nodeType: string;
484
+ createNode(key: string, props: WeaveElementAttributes): WeaveStateElement;
485
+ createInstance(props: WeaveElementAttributes): WeaveElementInstance;
486
+ updateInstance(nodeInstance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
487
+ removeInstance(nodeInstance: WeaveElementInstance): void;
488
+ toNode(instance: WeaveElementInstance): WeaveStateElement;
489
+ }
490
+
491
+ //#endregion
492
+ //#region src/nodes/rectangle/rectangle.d.ts
493
+ declare class WeaveRectangleNode extends WeaveNode {
494
+ protected nodeType: string;
495
+ createNode(key: string, props: WeaveElementAttributes): WeaveStateElement;
496
+ createInstance(props: WeaveElementAttributes): WeaveElementInstance;
497
+ updateInstance(nodeInstance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
498
+ removeInstance(nodeInstance: WeaveElementInstance): void;
499
+ toNode(instance: WeaveElementInstance): WeaveStateElement;
500
+ }
501
+
502
+ //#endregion
503
+ //#region src/nodes/line/line.d.ts
504
+ declare class WeaveLineNode extends WeaveNode {
505
+ protected nodeType: string;
506
+ createNode(key: string, props: WeaveElementAttributes): WeaveStateElement;
507
+ createInstance(props: WeaveElementAttributes): WeaveElementInstance;
508
+ updateInstance(nodeInstance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
509
+ removeInstance(nodeInstance: WeaveElementInstance): void;
510
+ toNode(instance: WeaveElementInstance): WeaveStateElement;
511
+ }
512
+
513
+ //#endregion
514
+ //#region src/nodes/text/text.d.ts
515
+ declare class WeaveTextNode extends WeaveNode {
516
+ protected nodeType: string;
517
+ private editing;
518
+ constructor();
519
+ getType(): string;
520
+ createNode(key: string, props: WeaveElementAttributes): WeaveStateElement;
521
+ private updateNode;
522
+ createInstance(props: WeaveElementAttributes): WeaveElementInstance;
523
+ updateInstance(nodeInstance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
524
+ removeInstance(nodeInstance: WeaveElementInstance): void;
525
+ toNode(instance: WeaveElementInstance): WeaveStateElement;
526
+ private createTextAreaDOM;
527
+ private removeTextAreaDOM;
528
+ private triggerEditMode;
529
+ }
530
+
531
+ //#endregion
532
+ //#region src/nodes/text/types.d.ts
533
+ type TextSerializable = Konva.TextConfig & NodeSerializable & {
534
+ type: "text";
535
+ id: string;
536
+ };
537
+
538
+ //#endregion
539
+ //#region src/nodes/image/image.d.ts
540
+ declare class WeaveImageNode extends WeaveNode {
541
+ protected nodeType: string;
542
+ private imageLoaded;
543
+ cropping: boolean;
544
+ constructor();
545
+ createNode(key: string, props: WeaveElementAttributes): WeaveStateElement;
546
+ createInstance(props: WeaveElementAttributes): WeaveElementInstance;
547
+ updateInstance(nodeInstance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
548
+ removeInstance(nodeInstance: WeaveElementInstance): void;
549
+ toNode(instance: WeaveElementInstance): WeaveStateElement;
550
+ private loadImage;
551
+ private getImageToolAction;
552
+ }
553
+
554
+ //#endregion
555
+ //#region src/nodes/image/types.d.ts
556
+ type ImageProps = WeaveElementAttributes & {
557
+ id: string;
558
+ width?: number;
559
+ height?: number;
560
+ imageURL?: string;
561
+ imageInfo?: {
562
+ width: number;
563
+ height: number;
564
+ };
565
+ };
566
+
567
+ //#endregion
568
+ //#region src/nodes/frame/frame.d.ts
569
+ declare class WeaveFrameNode extends WeaveNode {
570
+ protected nodeType: string;
571
+ createNode(key: string, props: WeaveElementAttributes): WeaveStateElement;
572
+ createInstance(props: WeaveElementAttributes): WeaveElementInstance;
573
+ updateInstance(nodeInstance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
574
+ removeInstance(nodeInstance: WeaveElementInstance): void;
575
+ toNode(instance: WeaveElementInstance): WeaveStateElement;
576
+ }
577
+
578
+ //#endregion
579
+ //#region src/nodes/frame/constants.d.ts
580
+ declare const WEAVE_FRAME_NODE_TYPE = "frame";
581
+
582
+ //#endregion
583
+ //#region src/actions/zoom-out-tool/types.d.ts
584
+ type WeaveZoomOutToolActionParams = {
585
+ previousAction: string;
586
+ };
587
+
588
+ //#endregion
589
+ //#region src/actions/zoom-out-tool/zoom-out-tool.d.ts
590
+ declare class WeaveZoomOutToolAction extends WeaveAction {
591
+ protected previousAction: string;
592
+ protected cancelAction: () => void;
593
+ internalUpdate: undefined;
594
+ getName(): string;
595
+ private getStageZoomPlugin;
596
+ init(): void;
597
+ trigger(cancelAction: () => void, params: WeaveZoomOutToolActionParams): void;
598
+ cleanup(): void;
599
+ }
600
+
601
+ //#endregion
602
+ //#region src/actions/zoom-in-tool/types.d.ts
603
+ type WeaveZoomInToolActionParams = {
604
+ previousAction: string;
605
+ };
606
+
607
+ //#endregion
608
+ //#region src/actions/zoom-in-tool/zoom-in-tool.d.ts
609
+ declare class WeaveZoomInToolAction extends WeaveAction {
610
+ protected previousAction: string;
611
+ protected cancelAction: () => void;
612
+ internalUpdate: undefined;
613
+ getName(): string;
614
+ private getStageZoomPlugin;
615
+ init(): void;
616
+ trigger(cancelAction: () => void, params: WeaveZoomInToolActionParams): void;
617
+ cleanup(): void;
618
+ }
619
+
620
+ //#endregion
621
+ //#region src/actions/fit-to-screen-tool/types.d.ts
622
+ type WeaveFitToScreenToolActionParams = {
623
+ previousAction: string;
624
+ };
625
+
626
+ //#endregion
627
+ //#region src/actions/fit-to-screen-tool/fit-to-screen-tool.d.ts
628
+ declare class WeaveFitToScreenToolAction extends WeaveAction {
629
+ protected previousAction: string;
630
+ protected cancelAction: () => void;
631
+ internalUpdate: undefined;
632
+ getName(): string;
633
+ private getStageZoomPlugin;
634
+ init(): void;
635
+ trigger(cancelAction: () => void, params: WeaveFitToScreenToolActionParams): void;
636
+ cleanup(): void;
637
+ }
638
+
639
+ //#endregion
640
+ //#region src/actions/fit-to-selection-tool/types.d.ts
641
+ type WeaveFitToSelectionToolActionParams = {
642
+ previousAction: string;
643
+ };
644
+
645
+ //#endregion
646
+ //#region src/actions/fit-to-selection-tool/fit-to-selection-tool.d.ts
647
+ declare class WeaveFitToSelectionToolAction extends WeaveAction {
648
+ protected previousAction: string;
649
+ protected cancelAction: () => void;
650
+ internalUpdate: undefined;
651
+ getName(): string;
652
+ private getNodesSelectionPlugin;
653
+ private getStageZoomPlugin;
654
+ init(): void;
655
+ trigger(cancelAction: () => void, params: WeaveFitToSelectionToolActionParams): void;
656
+ cleanup(): void;
657
+ }
658
+
659
+ //#endregion
660
+ //#region src/actions/move-tool/constants.d.ts
661
+ declare const MOVE_TOOL_ACTION_NAME = "moveTool";
662
+ declare const MOVE_TOOL_STATE: {
663
+ readonly "IDLE": "idle";
664
+ readonly "MOVING": "moving";
665
+ };
666
+
667
+ //#endregion
668
+ //#region src/actions/move-tool/types.d.ts
669
+ type WeaveMoveToolActionStateKeys = keyof typeof MOVE_TOOL_STATE;
670
+ type WeaveMoveToolActionState = (typeof MOVE_TOOL_STATE)[WeaveMoveToolActionStateKeys];
671
+
672
+ //#endregion
673
+ //#region src/actions/move-tool/move-tool.d.ts
674
+ declare class WeaveMoveToolAction extends WeaveAction {
675
+ protected initialized: boolean;
676
+ protected state: WeaveMoveToolActionState;
677
+ protected cancelAction: () => void;
678
+ internalUpdate: undefined;
679
+ init: undefined;
680
+ constructor();
681
+ getName(): string;
682
+ private setupEvents;
683
+ private setState;
684
+ private setMoving;
685
+ trigger(cancelAction: () => void): void;
686
+ cleanup(): void;
687
+ }
688
+
689
+ //#endregion
690
+ //#region src/actions/selection-tool/constants.d.ts
691
+ declare const SELECTION_TOOL_ACTION_NAME = "selectionTool";
692
+ declare const SELECTION_TOOL_STATE: {
693
+ readonly "IDLE": "idle";
694
+ readonly "SELECTING": "selection";
695
+ };
696
+
697
+ //#endregion
698
+ //#region src/actions/selection-tool/types.d.ts
699
+ type WeaveSelectionToolActionStateKeys = keyof typeof SELECTION_TOOL_STATE;
700
+ type WeaveSelectionToolActionState = (typeof SELECTION_TOOL_STATE)[WeaveSelectionToolActionStateKeys];
701
+
702
+ //#endregion
703
+ //#region src/actions/selection-tool/selection-tool.d.ts
704
+ declare class WeaveSelectionToolAction extends WeaveAction {
705
+ protected initialized: boolean;
706
+ protected state: WeaveSelectionToolActionState;
707
+ protected cancelAction: () => void;
708
+ internalUpdate: undefined;
709
+ init: undefined;
710
+ constructor();
711
+ getName(): string;
712
+ private setupEvents;
713
+ private setState;
714
+ private setSelection;
715
+ trigger(cancelAction: () => void): void;
716
+ cleanup(): void;
717
+ }
718
+
719
+ //#endregion
720
+ //#region src/actions/rectangle-tool/constants.d.ts
721
+ declare const RECTANGLE_TOOL_ACTION_NAME = "rectangleTool";
722
+ declare const RECTANGLE_TOOL_STATE: {
723
+ readonly "IDLE": "idle";
724
+ readonly "ADDING": "adding";
725
+ readonly "DEFINING_SIZE": "definingSize";
726
+ readonly "ADDED": "added";
727
+ };
728
+
729
+ //#endregion
730
+ //#region src/actions/rectangle-tool/types.d.ts
731
+ type WeaveRectangleToolActionStateKeys = keyof typeof RECTANGLE_TOOL_STATE;
732
+ type WeaveRectangleToolActionState = (typeof RECTANGLE_TOOL_STATE)[WeaveRectangleToolActionStateKeys];
733
+ type WeaveRectangleToolCallbacks = WeaveActionCallbacks;
734
+
735
+ //#endregion
736
+ //#region src/actions/rectangle-tool/rectangle-tool.d.ts
737
+ declare class WeaveRectangleToolAction extends WeaveAction {
738
+ protected initialized: boolean;
739
+ protected state: WeaveRectangleToolActionState;
740
+ protected rectId: string | null;
741
+ protected creating: boolean;
742
+ protected moved: boolean;
743
+ protected clickPoint: Vector2d | null;
744
+ protected container: Konva.Group | Konva.Layer | undefined;
745
+ protected cancelAction: () => void;
746
+ internalUpdate: undefined;
747
+ init: undefined;
748
+ constructor(callbacks: WeaveRectangleToolCallbacks);
749
+ getName(): string;
750
+ initProps(): {
751
+ opacity: number;
752
+ fill: string;
753
+ stroke: string;
754
+ strokeWidth: number;
755
+ width: number;
756
+ height: number;
757
+ };
758
+ private setupEvents;
759
+ private setState;
760
+ private addRectangle;
761
+ private handleAdding;
762
+ private handleSettingSize;
763
+ private handleMovement;
764
+ trigger(cancelAction: () => void): void;
765
+ cleanup(): void;
766
+ }
767
+
768
+ //#endregion
769
+ //#region src/actions/pen-tool/constants.d.ts
770
+ declare const PEN_TOOL_STATE: {
771
+ readonly "IDLE": "idle";
772
+ readonly "ADDING": "adding";
773
+ readonly "DEFINING_SIZE": "definingSize";
774
+ readonly "ADDED": "added";
775
+ };
776
+
777
+ //#endregion
778
+ //#region src/actions/pen-tool/types.d.ts
779
+ type WeavePenToolActionStateKeys = keyof typeof PEN_TOOL_STATE;
780
+ type WeavePenToolActionState = (typeof PEN_TOOL_STATE)[WeavePenToolActionStateKeys];
781
+ type WeavePenToolCallbacks = WeaveActionCallbacks;
782
+
783
+ //#endregion
784
+ //#region src/actions/pen-tool/pen-tool.d.ts
785
+ declare class WeavePenToolAction extends WeaveAction {
786
+ protected initialized: boolean;
787
+ protected initialCursor: string | null;
788
+ protected state: WeavePenToolActionState;
789
+ protected lineId: string | null;
790
+ protected tempLineId: string | null;
791
+ protected container: Konva.Layer | Konva.Group | undefined;
792
+ protected measureContainer: Konva.Layer | Konva.Group | undefined;
793
+ protected clickPoint: Vector2d | null;
794
+ protected tempPoint: Konva.Circle | undefined;
795
+ protected tempNextPoint: Konva.Circle | undefined;
796
+ protected cancelAction: () => void;
797
+ internalUpdate: undefined;
798
+ init: undefined;
799
+ constructor(callbacks: WeavePenToolCallbacks);
800
+ getName(): string;
801
+ initProps(): {
802
+ stroke: string;
803
+ strokeWidth: number;
804
+ opacity: number;
805
+ };
806
+ private setupEvents;
807
+ private setState;
808
+ private addLine;
809
+ private handleAdding;
810
+ private handleSettingSize;
811
+ private handleMovement;
812
+ trigger(cancelAction: () => void): void;
813
+ cleanup(): void;
814
+ }
815
+
816
+ //#endregion
817
+ //#region src/actions/brush-tool/constants.d.ts
818
+ declare const BRUSH_TOOL_STATE: {
819
+ readonly "INACTIVE": "inactive";
820
+ readonly "IDLE": "idle";
821
+ readonly "DEFINE_STROKE": "defineStroke";
822
+ };
823
+
824
+ //#endregion
825
+ //#region src/actions/brush-tool/types.d.ts
826
+ type WeaveBrushToolActionStateKeys = keyof typeof BRUSH_TOOL_STATE;
827
+ type WeaveBrushToolActionState = (typeof BRUSH_TOOL_STATE)[WeaveBrushToolActionStateKeys];
828
+ type WeaveBrushToolCallbacks = WeaveActionCallbacks;
829
+
830
+ //#endregion
831
+ //#region src/actions/brush-tool/brush-tool.d.ts
832
+ declare class WeaveBrushToolAction extends WeaveAction {
833
+ protected initialized: boolean;
834
+ protected state: WeaveBrushToolActionState;
835
+ protected clickPoint: Vector2d | null;
836
+ protected strokeId: string | null;
837
+ protected container: Konva.Layer | Konva.Group | undefined;
838
+ protected measureContainer: Konva.Layer | Konva.Group | undefined;
839
+ protected cancelAction: () => void;
840
+ internalUpdate: undefined;
841
+ init: undefined;
842
+ constructor(callbacks: WeaveBrushToolCallbacks);
843
+ getName(): string;
844
+ initProps(): {
845
+ stroke: string;
846
+ strokeWidth: number;
847
+ opacity: number;
848
+ };
849
+ private setupEvents;
850
+ private setState;
851
+ private handleStartStroke;
852
+ private handleEndStroke;
853
+ private handleMovement;
854
+ trigger(cancel: () => void): void;
855
+ cleanup(): void;
856
+ }
857
+
858
+ //#endregion
859
+ //#region src/actions/text-tool/constants.d.ts
860
+ declare const TEXT_TOOL_STATE: {
861
+ readonly "IDLE": "idle";
862
+ readonly "ADDING": "adding";
863
+ readonly "FINISHED": "finished";
864
+ };
865
+
866
+ //#endregion
867
+ //#region src/actions/text-tool/types.d.ts
868
+ type WeaveTextToolActionStateKeys = keyof typeof TEXT_TOOL_STATE;
869
+ type WeaveTextToolActionState = (typeof TEXT_TOOL_STATE)[WeaveTextToolActionStateKeys];
870
+
871
+ //#endregion
872
+ //#region src/actions/text-tool/text-tool.d.ts
873
+ declare class WeaveTextToolAction extends WeaveAction {
874
+ protected initialized: boolean;
875
+ protected initialCursor: string | null;
876
+ protected state: WeaveTextToolActionState;
877
+ protected textId: string | null;
878
+ protected container: Konva.Layer | Konva.Group | undefined;
879
+ protected clickPoint: Vector2d | null;
880
+ protected cancelAction: () => void;
881
+ internalUpdate: undefined;
882
+ init: undefined;
883
+ constructor();
884
+ getName(): string;
885
+ private setupEvents;
886
+ private setState;
887
+ private addText;
888
+ private handleAdding;
889
+ trigger(cancelAction: () => void): void;
890
+ cleanup(): void;
891
+ }
892
+
893
+ //#endregion
894
+ //#region src/actions/image-tool/constants.d.ts
895
+ declare const IMAGE_TOOL_STATE: {
896
+ readonly "IDLE": "idle";
897
+ readonly "UPLOADING": "uploading";
898
+ readonly "ADDING": "adding";
899
+ readonly "FINISHED": "finished";
900
+ };
901
+
902
+ //#endregion
903
+ //#region src/actions/image-tool/types.d.ts
904
+ type WeaveImageToolActionStateKeys = keyof typeof IMAGE_TOOL_STATE;
905
+ type WeaveImageToolActionState = (typeof IMAGE_TOOL_STATE)[WeaveImageToolActionStateKeys];
906
+ type WeaveImageToolActionOnAddImageCallback = (finished: (imageURL: string) => void) => Promise<void>;
907
+ type WeaveImageToolActionOnStartLoadImageCallback = () => void;
908
+ type WeaveImageToolActionOnEndLoadImageCallback = (error?: Error) => void;
909
+ type WeaveImageToolActionCallbacks = WeaveActionCallbacks & {
910
+ onUploadImage: WeaveImageToolActionOnAddImageCallback;
911
+ onImageLoadStart?: WeaveImageToolActionOnStartLoadImageCallback;
912
+ onImageLoadEnd?: WeaveImageToolActionOnEndLoadImageCallback;
913
+ };
914
+ type WeaveImageToolActionTriggerParams = {
915
+ imageURL?: string;
916
+ };
917
+ type WeaveImageToolActionTriggerReturn = {
918
+ finishUploadCallback: (imageURL: string) => void;
919
+ } | undefined;
920
+
921
+ //#endregion
922
+ //#region src/actions/image-tool/image-tool.d.ts
923
+ declare class WeaveImageToolAction extends WeaveAction {
924
+ private imageCallbacks;
925
+ protected initialized: boolean;
926
+ protected initialCursor: string | null;
927
+ protected state: WeaveImageToolActionState;
928
+ protected imageId: string | null;
929
+ protected tempImageId: string | null;
930
+ protected container: Konva.Layer | Konva.Group | undefined;
931
+ protected imageURL: string | null;
932
+ protected preloadImgs: Record<string, HTMLImageElement>;
933
+ protected clickPoint: Vector2d | null;
934
+ protected cancelAction: () => void;
935
+ update: undefined;
936
+ constructor(imageCallbacks: WeaveImageToolActionCallbacks);
937
+ getName(): string;
938
+ getPreloadedImage(imageId: string): HTMLImageElement | undefined;
939
+ initProps(): {
940
+ width: number;
941
+ height: number;
942
+ scaleX: number;
943
+ scaleY: number;
944
+ };
945
+ init(): void;
946
+ private setupEvents;
947
+ private setState;
948
+ private loadImage;
949
+ private addImageNode;
950
+ private addImage;
951
+ private handleAdding;
952
+ trigger(cancelAction: () => void, params?: WeaveImageToolActionTriggerParams): WeaveImageToolActionTriggerReturn;
953
+ internalUpdate(): void;
954
+ cleanup(): void;
955
+ }
956
+
957
+ //#endregion
958
+ //#region src/actions/frame-tool/constants.d.ts
959
+ declare const FRAME_TOOL_ACTION_NAME = "frameTool";
960
+ declare const FRAME_TOOL_STATE: {
961
+ readonly "IDLE": "idle";
962
+ readonly "ADDING": "adding";
963
+ readonly "ADDED": "added";
964
+ };
965
+
966
+ //#endregion
967
+ //#region src/actions/frame-tool/types.d.ts
968
+ type WeaveFrameToolActionStateKeys = keyof typeof FRAME_TOOL_STATE;
969
+ type WeaveFrameToolActionState = (typeof FRAME_TOOL_STATE)[WeaveFrameToolActionStateKeys];
970
+ type WeaveFrameToolCallbacks = WeaveActionCallbacks;
971
+ type WeaveFrameToolActionTriggerParams = {
972
+ fontFamily?: string;
973
+ };
974
+ type WeaveFrameToolProps = {
975
+ title: string;
976
+ fontFamily: string;
977
+ editing: boolean;
978
+ opacity: number;
979
+ };
980
+
981
+ //#endregion
982
+ //#region src/actions/frame-tool/frame-tool.d.ts
983
+ declare class WeaveFrameToolAction extends WeaveAction {
984
+ protected initialized: boolean;
985
+ protected state: WeaveFrameToolActionState;
986
+ protected frameId: string | null;
987
+ protected container: Konva.Layer | Konva.Group | undefined;
988
+ protected clickPoint: Vector2d | null;
989
+ protected cancelAction: () => void;
990
+ internalUpdate: undefined;
991
+ init: undefined;
992
+ constructor(callbacks: WeaveFrameToolCallbacks);
993
+ getName(): string;
994
+ initProps(params?: WeaveFrameToolActionTriggerParams): WeaveFrameToolProps;
995
+ private setupEvents;
996
+ private setState;
997
+ private addFrame;
998
+ private handleAdding;
999
+ trigger(cancelAction: () => void, params?: WeaveFrameToolActionTriggerParams): void;
1000
+ cleanup(): void;
1001
+ }
1002
+
1003
+ //#endregion
1004
+ //#region src/actions/export-stage-tool/types.d.ts
1005
+ type WeaveExportStageActionParams = {
1006
+ options?: WeaveExportNodeOptions;
1007
+ };
1008
+
1009
+ //#endregion
1010
+ //#region src/actions/export-stage-tool/export-stage-tool.d.ts
1011
+ declare class WeaveExportStageToolAction extends WeaveAction {
1012
+ protected cancelAction: () => void;
1013
+ private defaultFormatOptions;
1014
+ private options;
1015
+ internalUpdate: undefined;
1016
+ init: undefined;
1017
+ getName(): string;
1018
+ private exportStage;
1019
+ trigger(cancelAction: () => void, {
1020
+ options
1021
+ }: WeaveExportStageActionParams): Promise<void>;
1022
+ cleanup(): void;
1023
+ }
1024
+
1025
+ //#endregion
1026
+ //#region src/actions/export-node-tool/types.d.ts
1027
+ type WeaveExportNodeActionParams = {
1028
+ node: WeaveElementInstance;
1029
+ options?: WeaveExportNodeOptions;
1030
+ };
1031
+
1032
+ //#endregion
1033
+ //#region src/actions/export-node-tool/export-node-tool.d.ts
1034
+ declare class WeaveExportNodeToolAction extends WeaveAction {
1035
+ protected cancelAction: () => void;
1036
+ private defaultFormatOptions;
1037
+ private options;
1038
+ internalUpdate: undefined;
1039
+ init: undefined;
1040
+ getName(): string;
1041
+ private exportNode;
1042
+ trigger(cancelAction: () => void, {
1043
+ node,
1044
+ options
1045
+ }: WeaveExportNodeActionParams): Promise<void>;
1046
+ cleanup(): void;
1047
+ }
1048
+
1049
+ //#endregion
1050
+ //#region src/plugins/stage-grid/constants.d.ts
1051
+ declare const WEAVE_GRID_DEFAULT_SIZE = 50;
1052
+ declare const WEAVE_GRID_LAYER_ID = "gridLayer";
1053
+ declare const WEAVE_GRID_TYPES: {
1054
+ readonly "LINES": "lines";
1055
+ readonly "DOTS": "dots";
1056
+ };
1057
+
1058
+ //#endregion
1059
+ //#region src/plugins/stage-grid/types.d.ts
1060
+ type WeaveStageGridPluginParams = {
1061
+ gridSize?: number;
1062
+ };
1063
+ type WeaveStageGridTypeKeys = keyof typeof WEAVE_GRID_TYPES;
1064
+ type WeaveStageGridType = (typeof WEAVE_GRID_TYPES)[WeaveStageGridTypeKeys];
1065
+
1066
+ //#endregion
1067
+ //#region src/plugins/stage-grid/stage-grid.d.ts
1068
+ declare class WeaveStageGridPlugin extends WeavePlugin {
1069
+ private moveToolActive;
1070
+ private isMouseMiddleButtonPressed;
1071
+ private isSpaceKeyPressed;
1072
+ private type;
1073
+ private gridColor;
1074
+ private originColor;
1075
+ private gridSize;
1076
+ constructor(params: WeaveStageGridPluginParams);
1077
+ getName(): string;
1078
+ getLayerName(): string;
1079
+ initLayer(): void;
1080
+ init(): void;
1081
+ private initEvents;
1082
+ getLayer(): Konva.Layer | undefined;
1083
+ private renderGrid;
1084
+ private round;
1085
+ private renderGridLines;
1086
+ private renderGridDots;
1087
+ render(): void;
1088
+ enable(): void;
1089
+ disable(): void;
1090
+ getType(): WeaveStageGridType;
1091
+ setType(type: WeaveStageGridType): void;
1092
+ }
1093
+
1094
+ //#endregion
1095
+ //#region src/plugins/stage-panning/stage-panning.d.ts
1096
+ declare class WeaveStagePanningPlugin extends WeavePlugin {
1097
+ private moveToolActive;
1098
+ private isMouseMiddleButtonPressed;
1099
+ private isSpaceKeyPressed;
1100
+ protected previousPointer: string | null;
1101
+ getLayerName: undefined;
1102
+ initLayer: undefined;
1103
+ render: undefined;
1104
+ constructor();
1105
+ getName(): string;
1106
+ init(): void;
1107
+ private enableMove;
1108
+ private disableMove;
1109
+ private initEvents;
1110
+ enable(): void;
1111
+ disable(): void;
1112
+ }
1113
+
1114
+ //#endregion
1115
+ //#region src/plugins/stage-resize/stage-resize.d.ts
1116
+ declare class WeaveStageResizePlugin extends WeavePlugin {
1117
+ getLayerName: undefined;
1118
+ initLayer: undefined;
1119
+ render: undefined;
1120
+ getName(): string;
1121
+ init(): void;
1122
+ enable(): void;
1123
+ disable(): void;
1124
+ }
1125
+
1126
+ //#endregion
1127
+ //#region src/plugins/stage-zoom/types.d.ts
1128
+ type WeaveStageZoomChanged = {
1129
+ scale: number;
1130
+ zoomSteps: number[];
1131
+ actualStep: number;
1132
+ onDefaultStep: boolean;
1133
+ canZoomIn: boolean;
1134
+ canZoomOut: boolean;
1135
+ };
1136
+ type WeaveStageZoomOnZoomChangeCallback = (zoomInfo: WeaveStageZoomChanged) => void;
1137
+ type WeaveStageZoomPluginParams = {
1138
+ zoomSteps?: number[];
1139
+ defaultZoom?: number;
1140
+ onZoomChange?: WeaveStageZoomOnZoomChangeCallback;
1141
+ };
1142
+
1143
+ //#endregion
1144
+ //#region src/plugins/stage-zoom/stage-zoom.d.ts
1145
+ declare class WeaveStageZoomPlugin extends WeavePlugin {
1146
+ getLayerName: undefined;
1147
+ initLayer: undefined;
1148
+ render: undefined;
1149
+ private zoomSteps;
1150
+ private actualScale;
1151
+ private actualStep;
1152
+ private padding;
1153
+ defaultStep: number;
1154
+ private onZoomChangeCb;
1155
+ constructor(params: WeaveStageZoomPluginParams);
1156
+ getName(): string;
1157
+ init(): void;
1158
+ private setZoom;
1159
+ canZoomOut(): boolean;
1160
+ canZoomIn(): boolean;
1161
+ zoomToStep(step: number): void;
1162
+ private findClosestStepIndex;
1163
+ zoomIn(): void;
1164
+ zoomOut(): void;
1165
+ fitToScreen(): void;
1166
+ fitToSelection(): void;
1167
+ enable(): void;
1168
+ disable(): void;
1169
+ }
1170
+
1171
+ //#endregion
1172
+ //#region src/plugins/nodes-selection/constants.d.ts
1173
+ declare const WEAVE_NODES_SELECTION_LAYER_ID = "selectionLayer";
1174
+
1175
+ //#endregion
1176
+ //#region src/plugins/connected-users/constants.d.ts
1177
+ declare const WEAVE_CONNECTED_USER_INFO_KEY = "userInfo";
1178
+
1179
+ //#endregion
1180
+ //#region src/plugins/connected-users/types.d.ts
1181
+ type WeaveConnectedUsersPluginParams = {
1182
+ onConnectedUsersChanged?: WeaveConnectedUsersChangeCallback;
1183
+ getUser?: () => WeaveUser;
1184
+ };
1185
+ type WeaveConnectedUsersChanged = {
1186
+ [userName: string]: WeaveUser;
1187
+ };
1188
+ type WeaveConnectedUsersChangeCallback = (users: WeaveConnectedUsersChanged) => void;
1189
+ type WeaveConnectedUserInfoKey = typeof WEAVE_CONNECTED_USER_INFO_KEY;
1190
+
1191
+ //#endregion
1192
+ //#region src/plugins/connected-users/connected-users.d.ts
1193
+ declare class WeaveConnectedUsersPlugin extends WeavePlugin {
1194
+ private connectedUsers;
1195
+ private getUser;
1196
+ private onConnectedUsersChanged;
1197
+ getLayerName: undefined;
1198
+ initLayer: undefined;
1199
+ render: undefined;
1200
+ constructor(params: WeaveConnectedUsersPluginParams);
1201
+ getName(): string;
1202
+ init(): void;
1203
+ enable(): void;
1204
+ disable(): void;
1205
+ }
1206
+
1207
+ //#endregion
1208
+ //#region src/plugins/users-pointers/constants.d.ts
1209
+ declare const WEAVE_USER_POINTER_KEY = "userPointer";
1210
+
1211
+ //#endregion
1212
+ //#region src/plugins/users-pointers/types.d.ts
1213
+ type WeaveUsersPointersPluginParams = {
1214
+ getUser?: () => WeaveUser;
1215
+ };
1216
+ type WeaveUserPointer = {
1217
+ user: string;
1218
+ x: number;
1219
+ y: number;
1220
+ };
1221
+ type WeaveUserPointerKey = typeof WEAVE_USER_POINTER_KEY;
1222
+
1223
+ //#endregion
1224
+ //#region src/plugins/users-pointers/users-pointers.d.ts
1225
+ declare class WeaveUsersPointersPlugin extends WeavePlugin {
1226
+ private usersPointers;
1227
+ private usersPointersTimers;
1228
+ private getUser;
1229
+ private renderCursors;
1230
+ private userPointerCircleRadius;
1231
+ private userPointerSeparation;
1232
+ private userPointerCircleStrokeWidth;
1233
+ private userPointerNameFontSize;
1234
+ private userPointerBackgroundCornerRadius;
1235
+ private userPointerBackgroundPaddingX;
1236
+ private userPointerBackgroundPaddingY;
1237
+ render: undefined;
1238
+ constructor(params: WeaveUsersPointersPluginParams);
1239
+ getName(): string;
1240
+ getLayerName(): string;
1241
+ initLayer(): void;
1242
+ getLayer(): Konva.Layer | undefined;
1243
+ init(): void;
1244
+ private stringToColour;
1245
+ private setUserMovementTimer;
1246
+ private renderPointers;
1247
+ toggleRenderCursors(): void;
1248
+ setRenderCursors(render: boolean): void;
1249
+ enable(): void;
1250
+ disable(): void;
1251
+ }
1252
+
1253
+ //#endregion
1254
+ //#region src/plugins/context-menu/types.d.ts
1255
+ type WeaveStageContextMenuPluginOptions = {
1256
+ xOffset?: number;
1257
+ yOffset?: number;
1258
+ };
1259
+ type WeaveOnNodeMenuCallback = (instance: Weave, selection: WeaveSelection[], point: Vector2d, visible: boolean) => void;
1260
+ type WeaveStageContextMenuPluginCallbacks = {
1261
+ onNodeMenu: WeaveOnNodeMenuCallback;
1262
+ };
1263
+
1264
+ //#endregion
1265
+ //#region src/plugins/context-menu/context-menu.d.ts
1266
+ declare class WeaveContextMenuPlugin extends WeavePlugin {
1267
+ private config;
1268
+ private callbacks;
1269
+ private touchTimer;
1270
+ private tapHold;
1271
+ getLayerName: undefined;
1272
+ initLayer: undefined;
1273
+ render: undefined;
1274
+ constructor(options: WeaveStageContextMenuPluginOptions, callbacks: WeaveStageContextMenuPluginCallbacks);
1275
+ getName(): string;
1276
+ init(): void;
1277
+ triggerContextMenu(target: any): void;
1278
+ private initEvents;
1279
+ isTapHold(): boolean;
1280
+ enable(): void;
1281
+ disable(): void;
1282
+ }
1283
+
1284
+ //#endregion
1285
+ //#region src/plugins/stage-drop-area/types.d.ts
1286
+ type WeaveStageDropCallback = (event: DragEvent) => void;
1287
+ type WeaveStageDropUploadFileCallback = (event: File) => Promise<void>;
1288
+ type WeaveStageDropAreaPluginCallbacks = {
1289
+ onStageDrop?: WeaveStageDropCallback;
1290
+ doUploadFile?: WeaveStageDropUploadFileCallback;
1291
+ };
1292
+
1293
+ //#endregion
1294
+ //#region src/plugins/stage-drop-area/stage-drop-area.d.ts
1295
+ declare class WeaveStageDropAreaPlugin extends WeavePlugin {
1296
+ private callbacks?;
1297
+ getLayerName: undefined;
1298
+ initLayer: undefined;
1299
+ render: undefined;
1300
+ constructor(callbacks?: WeaveStageDropAreaPluginCallbacks);
1301
+ getName(): string;
1302
+ init(): void;
1303
+ private initEvents;
1304
+ enable(): void;
1305
+ disable(): void;
1306
+ }
1307
+
1308
+ //#endregion
1309
+ //#region src/plugins/copy-paste-nodes/constants.d.ts
1310
+ declare const COPY_PASTE_NODES_PLUGIN_STATE: {
1311
+ readonly "IDLE": "idle";
1312
+ readonly "PASTING": "pasting";
1313
+ };
1314
+
1315
+ //#endregion
1316
+ //#region src/plugins/copy-paste-nodes/types.d.ts
1317
+ type WeaveCopyPasteNodesPluginStateKeys = keyof typeof COPY_PASTE_NODES_PLUGIN_STATE;
1318
+ type WeaveCopyPasteNodesPluginState = (typeof COPY_PASTE_NODES_PLUGIN_STATE)[WeaveCopyPasteNodesPluginStateKeys];
1319
+ type WeaveCopyPasteNodesCanCopyChangeCallback = (canCopy: boolean) => void;
1320
+ type WeaveCopyPasteNodesCanPasteChangeCallback = (canPaste: boolean, nodes: WeaveToPasteNode[]) => void;
1321
+ type WeaveCopyPasteNodesOnCopyCallback = (error?: Error) => void;
1322
+ type WeaveCopyPasteNodesOnPasteCallback = (error?: Error) => void;
1323
+ type WeaveCopyPasteNodesOnPasteExternalCallback = (item: ClipboardItem) => void;
1324
+ type WeaveCopyPasteNodesPluginCallbacks = {
1325
+ onCopy?: WeaveCopyPasteNodesOnCopyCallback;
1326
+ onPaste?: WeaveCopyPasteNodesOnPasteCallback;
1327
+ onPasteExternal?: WeaveCopyPasteNodesOnPasteExternalCallback;
1328
+ };
1329
+ type WeavePasteModel = {
1330
+ weaveInstanceId: string;
1331
+ weave: Record<string, WeaveStateElement>;
1332
+ weaveMinPoint: Vector2d;
1333
+ };
1334
+ type WeaveToPasteNode = {
1335
+ konvaNode: Konva.Node;
1336
+ node: NodeSerializable;
1337
+ };
1338
+
1339
+ //#endregion
1340
+ //#region src/plugins/copy-paste-nodes/copy-paste-nodes.d.ts
1341
+ declare class WeaveCopyPasteNodesPlugin extends WeavePlugin {
1342
+ protected state: WeaveCopyPasteNodesPluginState;
1343
+ private callbacks;
1344
+ private toPaste;
1345
+ getLayerName: undefined;
1346
+ initLayer: undefined;
1347
+ render: undefined;
1348
+ constructor(callbacks?: WeaveCopyPasteNodesPluginCallbacks);
1349
+ getName(): string;
1350
+ init(): void;
1351
+ private readClipboardData;
1352
+ private writeClipboardData;
1353
+ private initEvents;
1354
+ private mapToPasteNodes;
1355
+ private setState;
1356
+ private handlePaste;
1357
+ private performCopy;
1358
+ private performPaste;
1359
+ copy(): Promise<void>;
1360
+ paste(): Promise<void>;
1361
+ getSelectedNodes(): WeaveToPasteNode[];
1362
+ isPasting(): boolean;
1363
+ private cancel;
1364
+ private getNodesSelectionPlugin;
1365
+ enable(): void;
1366
+ disable(): void;
1367
+ }
1368
+
1369
+ //#endregion
1370
+ //#region src/plugins/nodes-snapping/constants.d.ts
1371
+ declare const GUIDE_LINE_NAME = "guide-line";
1372
+ declare const GUIDE_ORIENTATION: {
1373
+ readonly "HORIZONTAL": "H";
1374
+ readonly "VERTICAL": "V";
1375
+ };
1376
+ declare const NODE_SNAP: {
1377
+ readonly "START": "start";
1378
+ readonly "CENTER": "center";
1379
+ readonly "END": "end";
1380
+ };
1381
+
1382
+ //#endregion
1383
+ //#region src/plugins/nodes-snapping/types.d.ts
1384
+ type NodeSnapKeys = keyof typeof NODE_SNAP;
1385
+ type NodeSnap = (typeof NODE_SNAP)[NodeSnapKeys];
1386
+ type NodeSnappingEdge = {
1387
+ guide: number;
1388
+ offset: number;
1389
+ snap: NodeSnap;
1390
+ };
1391
+ type NodeSnappingEdges = {
1392
+ vertical: NodeSnappingEdge[];
1393
+ horizontal: NodeSnappingEdge[];
1394
+ };
1395
+ type LineGuideStop = {
1396
+ vertical: number[];
1397
+ horizontal: number[];
1398
+ };
1399
+ type LineGuide = {
1400
+ lineGuide: number;
1401
+ diff: number;
1402
+ snap: NodeSnap;
1403
+ offset: number;
1404
+ };
1405
+ type GuideOrientationKeys = keyof typeof GUIDE_ORIENTATION;
1406
+ type GuideOrientation = (typeof GUIDE_ORIENTATION)[GuideOrientationKeys];
1407
+ type Guide = {
1408
+ lineGuide: number;
1409
+ offset: number;
1410
+ orientation: GuideOrientation;
1411
+ snap: NodeSnap;
1412
+ };
1413
+
1414
+ //#endregion
1415
+ //#region src/plugins/nodes-snapping/nodes-snapping.d.ts
1416
+ declare class WeaveNodesSnappingPlugin extends WeavePlugin {
1417
+ private guideLineOffset;
1418
+ render: undefined;
1419
+ constructor();
1420
+ getName(): string;
1421
+ init(): void;
1422
+ setEnabled(enabled: boolean): void;
1423
+ private initEvents;
1424
+ getLineGuideStops(skipShape: Konva.Node): LineGuideStop;
1425
+ getObjectSnappingEdges(node: Konva.Node): NodeSnappingEdges;
1426
+ getGuides(lineGuideStops: LineGuideStop, itemBounds: NodeSnappingEdges): Guide[];
1427
+ drawGuides(guides: Guide[]): void;
1428
+ enable(): void;
1429
+ disable(): void;
1430
+ }
1431
+
1432
+ //#endregion
1433
+ export { BRUSH_TOOL_STATE, COPY_PASTE_NODES_PLUGIN_STATE, FRAME_TOOL_ACTION_NAME, FRAME_TOOL_STATE, GUIDE_LINE_NAME, GUIDE_ORIENTATION, Guide, GuideOrientation, GuideOrientationKeys, IMAGE_TOOL_STATE, ImageProps, LineGuide, LineGuideStop, MOVE_TOOL_ACTION_NAME, MOVE_TOOL_STATE, NODE_SNAP, NodeSnap, NodeSnapKeys, NodeSnappingEdge, NodeSnappingEdges, PEN_TOOL_STATE, RECTANGLE_TOOL_ACTION_NAME, RECTANGLE_TOOL_STATE, SELECTION_TOOL_ACTION_NAME, SELECTION_TOOL_STATE, TEXT_TOOL_STATE, TextSerializable, WEAVE_FRAME_NODE_TYPE, WEAVE_GRID_DEFAULT_SIZE, WEAVE_GRID_LAYER_ID, WEAVE_GRID_TYPES, WEAVE_NODES_SELECTION_LAYER_ID, Weave, WeaveAction, WeaveActionCallbacks, WeaveActionPropsChangeCallback, WeaveBrushToolAction, WeaveBrushToolActionState, WeaveBrushToolActionStateKeys, WeaveBrushToolCallbacks, WeaveConnectedUserInfoKey, WeaveConnectedUsersChangeCallback, WeaveConnectedUsersChanged, WeaveConnectedUsersPlugin, WeaveConnectedUsersPluginParams, WeaveContextMenuPlugin, WeaveCopyPasteNodesCanCopyChangeCallback, WeaveCopyPasteNodesCanPasteChangeCallback, WeaveCopyPasteNodesOnCopyCallback, WeaveCopyPasteNodesOnPasteCallback, WeaveCopyPasteNodesOnPasteExternalCallback, WeaveCopyPasteNodesPlugin, WeaveCopyPasteNodesPluginCallbacks, WeaveCopyPasteNodesPluginState, WeaveCopyPasteNodesPluginStateKeys, WeaveExportNodeActionParams, WeaveExportNodeToolAction, WeaveExportStageActionParams, WeaveExportStageToolAction, WeaveFitToScreenToolAction, WeaveFitToScreenToolActionParams, WeaveFitToSelectionToolAction, WeaveFitToSelectionToolActionParams, WeaveFrameNode, WeaveFrameToolAction, WeaveFrameToolActionState, WeaveFrameToolActionStateKeys, WeaveFrameToolActionTriggerParams, WeaveFrameToolCallbacks, WeaveFrameToolProps, WeaveGroupNode, WeaveImageNode, WeaveImageToolAction, WeaveImageToolActionCallbacks, WeaveImageToolActionOnAddImageCallback, WeaveImageToolActionOnEndLoadImageCallback, WeaveImageToolActionOnStartLoadImageCallback, WeaveImageToolActionState, WeaveImageToolActionStateKeys, WeaveImageToolActionTriggerParams, WeaveImageToolActionTriggerReturn, WeaveLayerNode, WeaveLineNode, WeaveMoveToolAction, WeaveMoveToolActionState, WeaveMoveToolActionStateKeys, WeaveNode, WeaveNodesSelectionChangeCallback, WeaveNodesSelectionPlugin, WeaveNodesSelectionPluginCallbacks, WeaveNodesSelectionStageSelectionCallback, WeaveNodesSnappingPlugin, WeaveOnNodeMenuCallback, WeavePasteModel, WeavePenToolAction, WeavePenToolActionState, WeavePenToolActionStateKeys, WeavePenToolCallbacks, WeavePlugin, WeaveRectangleNode, WeaveRectangleToolAction, WeaveRectangleToolActionState, WeaveRectangleToolActionStateKeys, WeaveRectangleToolCallbacks, WeaveSelectionToolAction, WeaveSelectionToolActionState, WeaveSelectionToolActionStateKeys, WeaveStageContextMenuPluginCallbacks, WeaveStageContextMenuPluginOptions, WeaveStageDropAreaPlugin, WeaveStageDropAreaPluginCallbacks, WeaveStageDropCallback, WeaveStageDropUploadFileCallback, WeaveStageGridPlugin, WeaveStageGridPluginParams, WeaveStageGridType, WeaveStageGridTypeKeys, WeaveStageNode, WeaveStagePanningPlugin, WeaveStageResizePlugin, WeaveStageZoomChanged, WeaveStageZoomOnZoomChangeCallback, WeaveStageZoomPlugin, WeaveStageZoomPluginParams, WeaveStore, WeaveTextNode, WeaveTextToolAction, WeaveTextToolActionState, WeaveTextToolActionStateKeys, WeaveToPasteNode, WeaveUserPointer, WeaveUserPointerKey, WeaveUsersPointersPlugin, WeaveUsersPointersPluginParams, WeaveZoomInToolAction, WeaveZoomInToolActionParams, WeaveZoomOutToolAction, WeaveZoomOutToolActionParams, resetScale };