@inditextech/weave-store-websockets 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/client.cjs +52 -2
- package/dist/client.d.cts +489 -0
- package/dist/client.d.ts +489 -56
- package/dist/client.js +48 -376
- package/dist/server.cjs +1593 -1
- package/dist/server.d.cts +31 -0
- package/dist/server.d.ts +31 -59
- package/dist/server.js +1616 -349
- package/dist/types-BH9hIv5b.cjs +63 -0
- package/dist/types-Cq7de9Ah.js +13 -0
- package/dist/types.d-BmaSRpK3.d.ts +33 -0
- package/dist/types.d-BvFBHeXv.d.cts +33 -0
- package/package.json +14 -12
- package/dist/awareness-BgEfnEJw.cjs +0 -1
- package/dist/awareness-BgEfnEJw.cjs.gz +0 -0
- package/dist/awareness-C8fdGy2v.js +0 -453
- package/dist/awareness-C8fdGy2v.js.gz +0 -0
- package/dist/client.cjs.gz +0 -0
- package/dist/client.js.gz +0 -0
- package/dist/server.cjs.gz +0 -0
- package/dist/server.js.gz +0 -0
package/dist/client.cjs
CHANGED
|
@@ -1,2 +1,52 @@
|
|
|
1
|
-
"use strict";
|
|
2
|
-
|
|
1
|
+
"use strict";
|
|
2
|
+
const require_types = require('./types-BH9hIv5b.cjs');
|
|
3
|
+
const __inditextech_weave_sdk = require_types.__toESM(require("@inditextech/weave-sdk"));
|
|
4
|
+
require("@inditextech/weave-types");
|
|
5
|
+
const y_websocket = require_types.__toESM(require("y-websocket"));
|
|
6
|
+
|
|
7
|
+
//#region src/store-websockets.ts
|
|
8
|
+
var WeaveStoreWebsockets = class extends __inditextech_weave_sdk.WeaveStore {
|
|
9
|
+
name = require_types.WEAVE_STORE_WEBSOCKETS;
|
|
10
|
+
supportsUndoManager = true;
|
|
11
|
+
constructor(storeOptions, websocketOptions) {
|
|
12
|
+
super(storeOptions);
|
|
13
|
+
const { roomId } = websocketOptions;
|
|
14
|
+
this.websocketOptions = websocketOptions;
|
|
15
|
+
this.roomId = roomId;
|
|
16
|
+
this.init();
|
|
17
|
+
}
|
|
18
|
+
init() {
|
|
19
|
+
const { wsOptions: { serverUrl } } = this.websocketOptions;
|
|
20
|
+
this.provider = new y_websocket.WebsocketProvider(serverUrl, this.roomId, this.getDocument(), {
|
|
21
|
+
connect: false,
|
|
22
|
+
disableBc: true
|
|
23
|
+
});
|
|
24
|
+
this.provider.on("status", ({ status }) => {
|
|
25
|
+
this.websocketOptions.callbacks?.onConnectionStatusChange?.(status);
|
|
26
|
+
this.instance.emitEvent("onConnectionStatusChange", status);
|
|
27
|
+
});
|
|
28
|
+
}
|
|
29
|
+
connect() {
|
|
30
|
+
this.provider.connect();
|
|
31
|
+
}
|
|
32
|
+
disconnect() {
|
|
33
|
+
this.provider.connect();
|
|
34
|
+
}
|
|
35
|
+
setAwarenessInfo(field, value) {
|
|
36
|
+
const awareness = this.provider.awareness;
|
|
37
|
+
awareness.setLocalStateField(field, value);
|
|
38
|
+
}
|
|
39
|
+
onAwarenessChange(callback) {
|
|
40
|
+
const awareness = this.provider.awareness;
|
|
41
|
+
awareness.on("change", () => {
|
|
42
|
+
const values = Array.from(awareness.getStates().values());
|
|
43
|
+
values.splice(awareness.clientID, 1);
|
|
44
|
+
callback(values);
|
|
45
|
+
});
|
|
46
|
+
}
|
|
47
|
+
};
|
|
48
|
+
|
|
49
|
+
//#endregion
|
|
50
|
+
exports.WEAVE_STORE_WEBSOCKETS = require_types.WEAVE_STORE_WEBSOCKETS
|
|
51
|
+
exports.WEAVE_STORE_WEBSOCKETS_CONNECTION_STATUS = require_types.WEAVE_STORE_WEBSOCKETS_CONNECTION_STATUS
|
|
52
|
+
exports.WeaveStoreWebsockets = WeaveStoreWebsockets
|
|
@@ -0,0 +1,489 @@
|
|
|
1
|
+
import { ExtractRoomId, FetchInitialState, FetchRoom, PerformUpgrade, PersistRoom, WEAVE_STORE_WEBSOCKETS, WEAVE_STORE_WEBSOCKETS_CONNECTION_STATUS, WeaveStoreWebsocketsCallbacks, WeaveStoreWebsocketsConnectionStatus, WeaveStoreWebsocketsConnectionStatusKeys, WeaveStoreWebsocketsOptions } from "./types.d-BvFBHeXv.cjs";
|
|
2
|
+
import Konva from "konva";
|
|
3
|
+
import { Vector2d } from "konva/lib/types";
|
|
4
|
+
import { MappedTypeDescription } from "@syncedstore/core/types/doc";
|
|
5
|
+
import { Doc } from "yjs";
|
|
6
|
+
import Emittery from "emittery";
|
|
7
|
+
import pino, { Logger } from "pino";
|
|
8
|
+
import { StageConfig } from "konva/lib/Stage";
|
|
9
|
+
import { WebsocketProvider } from "y-websocket";
|
|
10
|
+
|
|
11
|
+
//#region ../sdk/dist/sdk.d.ts
|
|
12
|
+
//#region ../types/dist/types.d.ts
|
|
13
|
+
declare const WEAVE_INSTANCE_STATUS: {
|
|
14
|
+
readonly "IDLE": "idle";
|
|
15
|
+
readonly "STARTING": "starting";
|
|
16
|
+
readonly "LOADING_FONTS": "loadingFonts";
|
|
17
|
+
readonly "RUNNING": "running";
|
|
18
|
+
};
|
|
19
|
+
declare const WEAVE_NODE_POSITION: {
|
|
20
|
+
readonly "UP": "up";
|
|
21
|
+
readonly "DOWN": "down";
|
|
22
|
+
readonly "FRONT": "front";
|
|
23
|
+
readonly "BACK": "back";
|
|
24
|
+
};
|
|
25
|
+
declare const WEAVE_EXPORT_FORMATS: {
|
|
26
|
+
readonly "PNG": "image/png";
|
|
27
|
+
readonly "JPEG": "image/jpeg";
|
|
28
|
+
};
|
|
29
|
+
//#endregion
|
|
30
|
+
//#region src/base/action.d.ts
|
|
31
|
+
interface WeaveActionBase {
|
|
32
|
+
init?(): void;
|
|
33
|
+
trigger(cancelAction: () => void, params?: unknown): unknown;
|
|
34
|
+
internalUpdate?(): void;
|
|
35
|
+
cleanup?(): void;
|
|
36
|
+
}
|
|
37
|
+
|
|
38
|
+
//#endregion
|
|
39
|
+
//#region src/base/plugin.d.ts
|
|
40
|
+
interface WeavePluginBase {
|
|
41
|
+
init?(): void;
|
|
42
|
+
render?(): void;
|
|
43
|
+
enable(): void;
|
|
44
|
+
disable(): void;
|
|
45
|
+
isEnabled(): boolean;
|
|
46
|
+
}
|
|
47
|
+
|
|
48
|
+
//#endregion
|
|
49
|
+
//#region src/base/store.d.ts
|
|
50
|
+
type WeaveStoreOptions$1 = {
|
|
51
|
+
getUser: () => WeaveUser$1;
|
|
52
|
+
undoManagerOptions?: WeaveUndoManagerOptions$1;
|
|
53
|
+
};
|
|
54
|
+
interface WeaveStoreBase {
|
|
55
|
+
connect(): void;
|
|
56
|
+
disconnect(): void;
|
|
57
|
+
onAwarenessChange<K extends string, T>(callback: (changes: WeaveAwarenessChange$1<K, T>[]) => void): void;
|
|
58
|
+
setAwarenessInfo(field: string, value: unknown): void;
|
|
59
|
+
}
|
|
60
|
+
|
|
61
|
+
//#endregion
|
|
62
|
+
//#region src/types.d.ts
|
|
63
|
+
type WeaveConfig = {
|
|
64
|
+
store: WeaveStoreBase;
|
|
65
|
+
nodes?: WeaveNodeBase[];
|
|
66
|
+
actions?: WeaveActionBase[];
|
|
67
|
+
plugins?: WeavePluginBase[];
|
|
68
|
+
fonts?: WeaveFont[];
|
|
69
|
+
callbacks?: WeaveCallbacks;
|
|
70
|
+
logger?: WeaveLoggerConfig;
|
|
71
|
+
};
|
|
72
|
+
type WeaveStatusKeys = keyof typeof WEAVE_INSTANCE_STATUS;
|
|
73
|
+
type WeaveStatus = (typeof WEAVE_INSTANCE_STATUS)[WeaveStatusKeys];
|
|
74
|
+
type WeaveElementAttributes = {
|
|
75
|
+
[key: string]: any;
|
|
76
|
+
id?: string;
|
|
77
|
+
nodeType?: string;
|
|
78
|
+
children?: WeaveStateElement[];
|
|
79
|
+
};
|
|
80
|
+
type WeaveStateElement = {
|
|
81
|
+
key: string;
|
|
82
|
+
type: string;
|
|
83
|
+
props: WeaveElementAttributes;
|
|
84
|
+
};
|
|
85
|
+
type WeaveState = {
|
|
86
|
+
weave: {
|
|
87
|
+
key: "stage";
|
|
88
|
+
type: "stage";
|
|
89
|
+
props: {
|
|
90
|
+
[key: string]: unknown;
|
|
91
|
+
id: "stage";
|
|
92
|
+
children: WeaveStateElement[];
|
|
93
|
+
};
|
|
94
|
+
} | Record<string, WeaveStateElement>;
|
|
95
|
+
};
|
|
96
|
+
type WeaveSelection = {
|
|
97
|
+
instance: Konva.Shape | Konva.Group;
|
|
98
|
+
node: WeaveStateElement;
|
|
99
|
+
};
|
|
100
|
+
type WeaveMousePointInfoSimple = {
|
|
101
|
+
mousePoint: Vector2d;
|
|
102
|
+
container: Konva.Layer | Konva.Group | undefined;
|
|
103
|
+
};
|
|
104
|
+
type WeaveMousePointInfo = WeaveMousePointInfoSimple & {
|
|
105
|
+
measureContainer: Konva.Layer | Konva.Group | undefined;
|
|
106
|
+
};
|
|
107
|
+
type WeaveSerializedGroup = {
|
|
108
|
+
serializedNodes: WeaveStateElement[];
|
|
109
|
+
minPoint: Vector2d;
|
|
110
|
+
} | undefined;
|
|
111
|
+
type WeaveNodeFound = {
|
|
112
|
+
node: WeaveStateElement | null;
|
|
113
|
+
parent: WeaveStateElement | null;
|
|
114
|
+
index: number;
|
|
115
|
+
};
|
|
116
|
+
type WeaveAwarenessChange$1<K extends string, T> = { [key in K]: T };
|
|
117
|
+
type WeaveElementInstance = Konva.Layer | Konva.Group | Konva.Shape;
|
|
118
|
+
type WeaveLoggerConfig = {
|
|
119
|
+
disabled?: boolean;
|
|
120
|
+
level?: "debug" | "info" | "warn" | "error";
|
|
121
|
+
};
|
|
122
|
+
type WeavePositionKeys = keyof typeof WEAVE_NODE_POSITION;
|
|
123
|
+
type WeavePosition = (typeof WEAVE_NODE_POSITION)[WeavePositionKeys];
|
|
124
|
+
type WeaveExportNodeOptions = {
|
|
125
|
+
format?: typeof WEAVE_EXPORT_FORMATS.PNG;
|
|
126
|
+
padding?: number;
|
|
127
|
+
pixelRatio?: number;
|
|
128
|
+
backgroundColor?: string;
|
|
129
|
+
quality?: number;
|
|
130
|
+
};
|
|
131
|
+
type WeaveUser$1 = {
|
|
132
|
+
name: string;
|
|
133
|
+
email: string;
|
|
134
|
+
};
|
|
135
|
+
type WeaveFont = {
|
|
136
|
+
id: string;
|
|
137
|
+
name: string;
|
|
138
|
+
};
|
|
139
|
+
type WeaveUndoManagerOptions$1 = {
|
|
140
|
+
captureTimeout?: number;
|
|
141
|
+
trackedOrigins?: Set<any>;
|
|
142
|
+
};
|
|
143
|
+
type WeaveUndoRedoChange = {
|
|
144
|
+
canRedo: boolean;
|
|
145
|
+
canUndo: boolean;
|
|
146
|
+
redoStackLength: number;
|
|
147
|
+
undoStackLength: number;
|
|
148
|
+
};
|
|
149
|
+
type WeaveCallbacks = {
|
|
150
|
+
onRender?: () => void;
|
|
151
|
+
onRoomLoaded?: (loaded: boolean) => void;
|
|
152
|
+
onInstanceStatus?: (status: WeaveStatus) => void;
|
|
153
|
+
onActiveActionChange?: (actionName: string | undefined) => void;
|
|
154
|
+
onStateChange?: (state: WeaveState) => void;
|
|
155
|
+
onUndoManagerStatusChange?: (undoManagerStatus: WeaveUndoRedoChange) => void;
|
|
156
|
+
};
|
|
157
|
+
|
|
158
|
+
//#endregion
|
|
159
|
+
//#region src/base/node.d.ts
|
|
160
|
+
interface WeaveNodeBase {
|
|
161
|
+
createNode(id: string, props: WeaveElementAttributes): WeaveStateElement;
|
|
162
|
+
createInstance(props: WeaveElementAttributes): WeaveElementInstance;
|
|
163
|
+
updateInstance(instance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
|
|
164
|
+
removeInstance(instance: WeaveElementInstance): void;
|
|
165
|
+
toNode(instance: WeaveElementInstance): WeaveStateElement;
|
|
166
|
+
} //#endregion
|
|
167
|
+
//#region src/stores/store.d.ts
|
|
168
|
+
|
|
169
|
+
//#endregion
|
|
170
|
+
declare abstract class WeaveStore implements WeaveStoreBase {
|
|
171
|
+
protected instance: Weave;
|
|
172
|
+
protected name: string;
|
|
173
|
+
protected supportsUndoManager: boolean;
|
|
174
|
+
protected config: WeaveStoreOptions$1;
|
|
175
|
+
private state;
|
|
176
|
+
private latestState;
|
|
177
|
+
private document;
|
|
178
|
+
private logger;
|
|
179
|
+
private undoManager;
|
|
180
|
+
private isRoomLoaded;
|
|
181
|
+
constructor(config: WeaveStoreOptions$1);
|
|
182
|
+
getName(): string;
|
|
183
|
+
getLogger(): Logger;
|
|
184
|
+
register(instance: Weave): WeaveStore;
|
|
185
|
+
getUser(): WeaveUser$1;
|
|
186
|
+
setState(state: WeaveState): void;
|
|
187
|
+
setLatestState(newState: WeaveState): void;
|
|
188
|
+
getLatestState(): WeaveState;
|
|
189
|
+
getDocument(): Doc;
|
|
190
|
+
getState(): MappedTypeDescription<WeaveState>;
|
|
191
|
+
getStateJson(): WeaveState;
|
|
192
|
+
setup(): void;
|
|
193
|
+
canUndoStateStep(): boolean;
|
|
194
|
+
canRedoStateStep(): boolean;
|
|
195
|
+
undoStateStep(): void;
|
|
196
|
+
redoStateStep(): void;
|
|
197
|
+
abstract connect(): void;
|
|
198
|
+
abstract disconnect(): void;
|
|
199
|
+
abstract onAwarenessChange<K extends string, T>(callback: (changes: WeaveAwarenessChange$1<K, T>[]) => void): void;
|
|
200
|
+
abstract setAwarenessInfo(field: string, value: unknown): void;
|
|
201
|
+
}
|
|
202
|
+
|
|
203
|
+
//#endregion
|
|
204
|
+
//#region src/plugins/plugin.d.ts
|
|
205
|
+
declare abstract class WeavePlugin implements WeavePluginBase {
|
|
206
|
+
protected instance: Weave;
|
|
207
|
+
protected name: string;
|
|
208
|
+
protected enabled: boolean;
|
|
209
|
+
private logger;
|
|
210
|
+
register(instance: Weave): WeavePlugin;
|
|
211
|
+
getName(): string;
|
|
212
|
+
getLogger(): Logger;
|
|
213
|
+
isEnabled(): boolean;
|
|
214
|
+
abstract init?(): void;
|
|
215
|
+
abstract render?(): void;
|
|
216
|
+
abstract enable(): void;
|
|
217
|
+
abstract disable(): void;
|
|
218
|
+
}
|
|
219
|
+
|
|
220
|
+
//#endregion
|
|
221
|
+
//#region src/plugins/nodes-selection/types.d.ts
|
|
222
|
+
type WeaveNodesSelectionChangeCallback = (nodes: WeaveSelection[]) => void;
|
|
223
|
+
type WeaveNodesSelectionStageSelectionCallback = () => void;
|
|
224
|
+
type WeaveNodesSelectionPluginCallbacks = {
|
|
225
|
+
onNodesChange: WeaveNodesSelectionChangeCallback;
|
|
226
|
+
onStageSelection?: WeaveNodesSelectionStageSelectionCallback;
|
|
227
|
+
};
|
|
228
|
+
|
|
229
|
+
//#endregion
|
|
230
|
+
//#region src/plugins/nodes-selection/nodes-selection.d.ts
|
|
231
|
+
declare class WeaveNodesSelectionPlugin extends WeavePlugin {
|
|
232
|
+
private tr;
|
|
233
|
+
private selectionRectangle;
|
|
234
|
+
private active;
|
|
235
|
+
private cameFromSelectingMultiple;
|
|
236
|
+
private selecting;
|
|
237
|
+
private initialized;
|
|
238
|
+
private callbacks;
|
|
239
|
+
render: undefined;
|
|
240
|
+
constructor(callbacks: WeaveNodesSelectionPluginCallbacks);
|
|
241
|
+
getName(): string;
|
|
242
|
+
getLayerName(): string;
|
|
243
|
+
initLayer(): void;
|
|
244
|
+
init(): void;
|
|
245
|
+
private getLayer;
|
|
246
|
+
private triggerSelectedNodesEvent;
|
|
247
|
+
private initEvents;
|
|
248
|
+
getTransformer(): Konva.Transformer;
|
|
249
|
+
setSelectedNodes(nodes: Konva.Node[]): void;
|
|
250
|
+
getSelectedNodes(): (Konva.Group | Konva.Shape)[];
|
|
251
|
+
removeSelectedNodes(): void;
|
|
252
|
+
selectAll(): void;
|
|
253
|
+
selectNone(): void;
|
|
254
|
+
enable(): void;
|
|
255
|
+
disable(): void;
|
|
256
|
+
}
|
|
257
|
+
|
|
258
|
+
//#endregion
|
|
259
|
+
//#region src/nodes/node.d.ts
|
|
260
|
+
declare abstract class WeaveNode implements WeaveNodeBase {
|
|
261
|
+
protected instance: Weave;
|
|
262
|
+
protected nodeType: string;
|
|
263
|
+
private logger;
|
|
264
|
+
protected previousPointer: string | null;
|
|
265
|
+
register(instance: Weave): WeaveNode;
|
|
266
|
+
getNodeType(): string;
|
|
267
|
+
getLogger(): Logger;
|
|
268
|
+
getSelectionPlugin(): WeaveNodesSelectionPlugin;
|
|
269
|
+
isSelecting(): boolean;
|
|
270
|
+
isPasting(): boolean;
|
|
271
|
+
isNodeSelected(ele: Konva.Node): boolean;
|
|
272
|
+
setupDefaultNodeEvents(node: Konva.Node): void;
|
|
273
|
+
abstract createNode(id: string, props: WeaveElementAttributes): WeaveStateElement;
|
|
274
|
+
abstract createInstance(props: WeaveElementAttributes): WeaveElementInstance;
|
|
275
|
+
abstract updateInstance(instance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
|
|
276
|
+
abstract removeInstance(instance: WeaveElementInstance): void;
|
|
277
|
+
abstract toNode(instance: WeaveElementInstance): WeaveStateElement;
|
|
278
|
+
}
|
|
279
|
+
|
|
280
|
+
//#endregion
|
|
281
|
+
//#region src/actions/types.d.ts
|
|
282
|
+
type WeaveActionPropsChangeCallback = (props: WeaveElementAttributes) => void;
|
|
283
|
+
type WeaveActionCallbacks = {
|
|
284
|
+
onPropsChange?: WeaveActionPropsChangeCallback;
|
|
285
|
+
};
|
|
286
|
+
|
|
287
|
+
//#endregion
|
|
288
|
+
//#region src/actions/action.d.ts
|
|
289
|
+
declare abstract class WeaveAction {
|
|
290
|
+
protected instance: Weave;
|
|
291
|
+
protected name: string;
|
|
292
|
+
props: WeaveElementAttributes;
|
|
293
|
+
protected callbacks: WeaveActionCallbacks | undefined;
|
|
294
|
+
private logger;
|
|
295
|
+
constructor(callbacks?: WeaveActionCallbacks);
|
|
296
|
+
getName(): string;
|
|
297
|
+
getLogger(): Logger;
|
|
298
|
+
register(instance: Weave): WeaveAction;
|
|
299
|
+
updateProps(props: WeaveElementAttributes): void;
|
|
300
|
+
getProps(): WeaveElementAttributes;
|
|
301
|
+
abstract init?(): void;
|
|
302
|
+
abstract trigger(cancelAction: () => void, params?: unknown): unknown;
|
|
303
|
+
abstract internalUpdate?(): void;
|
|
304
|
+
abstract cleanup?(): void;
|
|
305
|
+
}
|
|
306
|
+
|
|
307
|
+
//#endregion
|
|
308
|
+
//#region src/logger/logger.d.ts
|
|
309
|
+
declare class WeaveLogger {
|
|
310
|
+
private config;
|
|
311
|
+
private disabled;
|
|
312
|
+
private logger;
|
|
313
|
+
constructor(config: WeaveLoggerConfig);
|
|
314
|
+
private log;
|
|
315
|
+
getDisabled(): boolean;
|
|
316
|
+
getLevel(): pino.LevelWithSilentOrString;
|
|
317
|
+
getLogger(): Logger;
|
|
318
|
+
getChildLogger(name: string): pino.Logger<never, boolean>;
|
|
319
|
+
}
|
|
320
|
+
|
|
321
|
+
//#endregion
|
|
322
|
+
//#region src/managers/register.d.ts
|
|
323
|
+
declare class WeaveRegisterManager {
|
|
324
|
+
private instance;
|
|
325
|
+
private nodesHandlers;
|
|
326
|
+
private actionsHandlers;
|
|
327
|
+
private plugins;
|
|
328
|
+
private logger;
|
|
329
|
+
constructor(instance: Weave);
|
|
330
|
+
getPlugins(): Record<string, WeavePlugin>;
|
|
331
|
+
getNodesHandlers(): Record<string, WeaveNode>;
|
|
332
|
+
getActionsHandlers(): Record<string, WeaveAction>;
|
|
333
|
+
getPlugin<T extends WeavePlugin>(pluginName: string): T;
|
|
334
|
+
getActionHandler<T extends WeaveAction>(actionName: string): T;
|
|
335
|
+
getNodeHandler(nodeType: string): WeaveNode;
|
|
336
|
+
registerPlugins(): void;
|
|
337
|
+
registerPlugin(plugin: WeavePlugin): void;
|
|
338
|
+
registerNodesHandlers(): void;
|
|
339
|
+
registerNodeHandler(node: WeaveNode): void;
|
|
340
|
+
registerActionsHandlers(): void;
|
|
341
|
+
registerActionHandler(action: WeaveAction): void;
|
|
342
|
+
}
|
|
343
|
+
|
|
344
|
+
//#endregion
|
|
345
|
+
//#region src/managers/stage.d.ts
|
|
346
|
+
declare class WeaveStageManager {
|
|
347
|
+
private instance;
|
|
348
|
+
private logger;
|
|
349
|
+
private stage;
|
|
350
|
+
private config;
|
|
351
|
+
constructor(instance: Weave, config: Konva.StageConfig);
|
|
352
|
+
getConfiguration(): StageConfig;
|
|
353
|
+
setStage(stage: Konva.Stage): void;
|
|
354
|
+
getStage(): Konva.Stage;
|
|
355
|
+
getMainLayer(): Konva.Layer | undefined;
|
|
356
|
+
getInstanceRecursive(instance: Konva.Node, filterInstanceType?: string[]): Konva.Node;
|
|
357
|
+
initStage(): void;
|
|
358
|
+
}
|
|
359
|
+
|
|
360
|
+
//#endregion
|
|
361
|
+
//#region src/weave.d.ts
|
|
362
|
+
declare class Weave extends Emittery {
|
|
363
|
+
private id;
|
|
364
|
+
private config;
|
|
365
|
+
private logger;
|
|
366
|
+
private moduleLogger;
|
|
367
|
+
private reconciler;
|
|
368
|
+
private stateSerializer;
|
|
369
|
+
private renderer;
|
|
370
|
+
private status;
|
|
371
|
+
private setupManager;
|
|
372
|
+
private registerManager;
|
|
373
|
+
private stateManager;
|
|
374
|
+
private storeManager;
|
|
375
|
+
private stageManager;
|
|
376
|
+
private groupsManager;
|
|
377
|
+
private targetingManager;
|
|
378
|
+
private cloningManager;
|
|
379
|
+
private fontsManager;
|
|
380
|
+
private zIndexManager;
|
|
381
|
+
private pluginsManager;
|
|
382
|
+
private actionsManager;
|
|
383
|
+
private exportManager;
|
|
384
|
+
constructor(weaveConfig: WeaveConfig, stageConfig: Konva.StageConfig);
|
|
385
|
+
setupRenderer(): void;
|
|
386
|
+
setStatus(status: WeaveStatus): void;
|
|
387
|
+
getStatus(): WeaveStatus;
|
|
388
|
+
setStore(store: WeaveStore): void;
|
|
389
|
+
start(): Promise<void>;
|
|
390
|
+
getId(): string;
|
|
391
|
+
getConfiguration(): WeaveConfig;
|
|
392
|
+
emitEvent<T>(event: string, payload: T): void;
|
|
393
|
+
addEventListener<T>(event: string, callback: (payload: T) => void): void;
|
|
394
|
+
removeEventListener<T>(event: string, callback: (payload: T) => void): void;
|
|
395
|
+
getLogger(): WeaveLogger;
|
|
396
|
+
getMainLogger(): Logger;
|
|
397
|
+
getChildLogger(name: string): pino.Logger<never, boolean>;
|
|
398
|
+
getStageManager(): WeaveStageManager;
|
|
399
|
+
getStage(): Konva.Stage;
|
|
400
|
+
getMainLayer(): Konva.Layer | undefined;
|
|
401
|
+
setStage(stage: Konva.Stage): void;
|
|
402
|
+
getStageConfiguration(): StageConfig;
|
|
403
|
+
getInstanceRecursive(instance: Konva.Node, filterInstanceType?: string[]): Konva.Node;
|
|
404
|
+
getRegisterManager(): WeaveRegisterManager;
|
|
405
|
+
getPlugins(): Record<string, WeavePlugin>;
|
|
406
|
+
getPlugin<T extends WeavePlugin>(pluginName: string): T;
|
|
407
|
+
getNodesHandlers(): Record<string, WeaveNode>;
|
|
408
|
+
getNodeHandler<T extends WeaveNode>(nodeType: string): T;
|
|
409
|
+
getActionsHandlers(): Record<string, WeaveAction>;
|
|
410
|
+
getActionHandler<T extends WeaveAction>(actionName: string): T;
|
|
411
|
+
getStore<T extends WeaveStore>(): T;
|
|
412
|
+
registerPlugin(plugin: WeavePlugin): void;
|
|
413
|
+
registerNodeHandler(node: WeaveNode): void;
|
|
414
|
+
registerActionHandler(action: WeaveAction): void;
|
|
415
|
+
registerStore(store: WeaveStore): void;
|
|
416
|
+
isPluginEnabled(pluginName: string): boolean;
|
|
417
|
+
enablePlugin(pluginName: string): void;
|
|
418
|
+
disablePlugin(pluginName: string): void;
|
|
419
|
+
getActiveAction(): string | undefined;
|
|
420
|
+
triggerAction<T>(actionName: string, params?: T): unknown;
|
|
421
|
+
getPropsAction(actionName: string): WeaveElementAttributes;
|
|
422
|
+
updatePropsAction(actionName: string, params: WeaveElementAttributes): void;
|
|
423
|
+
cancelAction(actionName: string): void;
|
|
424
|
+
update(newState: WeaveState): void;
|
|
425
|
+
render(): void;
|
|
426
|
+
findNodeById(tree: WeaveStateElement, key: string, parent?: WeaveStateElement | null, index?: number): WeaveNodeFound;
|
|
427
|
+
findNodesByType(tree: WeaveStateElement, nodeType: string): WeaveStateElement[];
|
|
428
|
+
getNode(nodeKey: string): {
|
|
429
|
+
node: WeaveStateElement | null;
|
|
430
|
+
parent: WeaveStateElement | null;
|
|
431
|
+
index: number;
|
|
432
|
+
};
|
|
433
|
+
addNode(node: WeaveStateElement, parentId?: string, index?: number | undefined, doRender?: boolean): void;
|
|
434
|
+
updateNode(node: WeaveStateElement, doRender?: boolean): void;
|
|
435
|
+
removeNode(node: WeaveStateElement, doRender?: boolean): void;
|
|
436
|
+
removeNodes(nodes: WeaveStateElement[], doRender?: boolean): void;
|
|
437
|
+
moveNode(node: WeaveStateElement, position: WeavePosition, doRender?: boolean): void;
|
|
438
|
+
moveUp(node: WeaveElementInstance): void;
|
|
439
|
+
moveDown(node: WeaveElementInstance): void;
|
|
440
|
+
sendToBack(node: WeaveElementInstance): void;
|
|
441
|
+
bringToFront(node: WeaveElementInstance): void;
|
|
442
|
+
group(nodes: WeaveStateElement[]): void;
|
|
443
|
+
unGroup(group: WeaveStateElement): void;
|
|
444
|
+
getMousePointer(point?: Vector2d): WeaveMousePointInfo;
|
|
445
|
+
getMousePointerRelativeToContainer(container: Konva.Group | Konva.Layer): WeaveMousePointInfoSimple;
|
|
446
|
+
nodesToGroupSerialized(instancesToClone: Konva.Node[]): WeaveSerializedGroup;
|
|
447
|
+
cloneNodes(instancesToClone: Konva.Node[], targetContainer: Konva.Layer | Konva.Group | undefined, onPoint: Vector2d): void;
|
|
448
|
+
getFonts(): WeaveFont[];
|
|
449
|
+
exportStage(options: WeaveExportNodeOptions): Promise<HTMLImageElement>;
|
|
450
|
+
exportNode(node: WeaveElementInstance, options: WeaveExportNodeOptions): Promise<HTMLImageElement>;
|
|
451
|
+
} //#endregion
|
|
452
|
+
//#region ../types/dist/types.d.ts
|
|
453
|
+
|
|
454
|
+
//#endregion
|
|
455
|
+
//#region src/utils.d.ts
|
|
456
|
+
//#endregion
|
|
457
|
+
//#region src/base/store.d.ts
|
|
458
|
+
type WeaveStoreOptions = {
|
|
459
|
+
getUser: () => WeaveUser;
|
|
460
|
+
undoManagerOptions?: WeaveUndoManagerOptions;
|
|
461
|
+
};
|
|
462
|
+
type WeaveAwarenessChange<K extends string, T> = { [key in K]: T };
|
|
463
|
+
type WeaveUser = {
|
|
464
|
+
name: string;
|
|
465
|
+
email: string;
|
|
466
|
+
};
|
|
467
|
+
type WeaveUndoManagerOptions = {
|
|
468
|
+
captureTimeout?: number;
|
|
469
|
+
trackedOrigins?: Set<any>;
|
|
470
|
+
};
|
|
471
|
+
|
|
472
|
+
//#endregion
|
|
473
|
+
//#region src/store-websockets.d.ts
|
|
474
|
+
declare class WeaveStoreWebsockets extends WeaveStore {
|
|
475
|
+
private websocketOptions;
|
|
476
|
+
private roomId;
|
|
477
|
+
protected provider: WebsocketProvider;
|
|
478
|
+
protected name: string;
|
|
479
|
+
protected supportsUndoManager: boolean;
|
|
480
|
+
constructor(storeOptions: WeaveStoreOptions, websocketOptions: WeaveStoreWebsocketsOptions);
|
|
481
|
+
private init;
|
|
482
|
+
connect(): void;
|
|
483
|
+
disconnect(): void;
|
|
484
|
+
setAwarenessInfo(field: string, value: unknown): void;
|
|
485
|
+
onAwarenessChange<K extends string, T>(callback: (changes: WeaveAwarenessChange<K, T>[]) => void): void;
|
|
486
|
+
}
|
|
487
|
+
|
|
488
|
+
//#endregion
|
|
489
|
+
export { ExtractRoomId, FetchInitialState, FetchRoom, PerformUpgrade, PersistRoom, WEAVE_STORE_WEBSOCKETS, WEAVE_STORE_WEBSOCKETS_CONNECTION_STATUS, WeaveStoreWebsockets, WeaveStoreWebsocketsCallbacks, WeaveStoreWebsocketsConnectionStatus, WeaveStoreWebsocketsConnectionStatusKeys, WeaveStoreWebsocketsOptions };
|