extprg-types 1.0.2 → 1.0.4

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.
Files changed (2) hide show
  1. package/index.d.ts +1527 -1523
  2. package/package.json +11 -1
package/index.d.ts CHANGED
@@ -3,7 +3,7 @@
3
3
 
4
4
  /**
5
5
  * Auto-generated. Do not edit manually.
6
- * 2026-05-07T14:05:16.404Z
6
+ * 2026-05-07T14:48:06.531Z
7
7
  */
8
8
 
9
9
  // ── 第三方类型导入 ──
@@ -19,395 +19,395 @@ import type * as react_dialog from "@radix-ui/react-dialog";
19
19
 
20
20
  // ── 本地类型定义 ──
21
21
  declare class AIEngine {
22
- createTransport(project: Project);
23
- createChatFetch(project: Project): typeof fetch;
24
- getModels();
22
+ createTransport(project: Project | { _: "Project" | string }): Promise<void>;
23
+ createChatFetch(project: Project | { _: "Project" | string }): Promise<typeof fetch>;
24
+ getModels(): Promise<void>;
25
25
  readRequestBody(body: BodyInit | null | undefined): Promise<any>;
26
26
  }
27
27
 
28
28
  declare class Association extends StageObject {
29
- associationList: StageObject[];
30
- color: Color;
29
+ associationList: Promise<StageObject>[];
30
+ color: Promise<Color>;
31
31
  }
32
32
 
33
33
  declare class AutoAlign {
34
- constructor(project: Project);
35
- getSelectionOuterRectangle(entities: Entity[]): Rectangle | null;
36
- calculateDistanceByRectangle(rectA: Rectangle, rectB: Rectangle);
37
- alignRectangleToTargetX(selectedRect: Rectangle, otherRect: Rectangle): number;
38
- alignRectangleToTargetY(selectedRect: Rectangle, otherRect: Rectangle): number;
39
- _addAlignEffectByRect(selectedRect: Rectangle, otherRect: Rectangle);
40
- getGridSnapDeltaX(rect: Rectangle);
41
- getGridSnapDeltaY(rect: Rectangle);
42
- alignAllSelectedToGrid();
43
- alignAllSelected();
44
- preAlignAllSelected();
45
- onEntityMoveAlignToGrid(selectedEntity: Entity);
46
- onEntityMoveAlignToGridX(selectedEntity: Entity);
47
- onEntityMoveAlignToGridY(selectedEntity: Entity);
48
- onEntityMoveAlignToOtherEntity(selectedEntity: Entity, otherEntities: Entity[], isPreAlign = false);
49
- _addAlignEffect(selectedEntity: Entity, otherEntity: Entity);
50
- onEntityMoveAlignToTargetEntityX(selectedEntity: Entity, otherEntity: Entity, isPreAlign = false): number;
51
- onEntityMoveAlignToTargetEntityY(selectedEntity: Entity, otherEntity: Entity, isPreAlign = false): number;
52
- calculateDistance(entityA: Entity, entityB: Entity);
53
- autoLayoutSelectedFastTreeMode(selectedRootEntity: ConnectableEntity);
34
+ constructor(project: Project | { _: "Project" | string });
35
+ getSelectionOuterRectangle(entities: Entity[]): Promise<Rectangle | null>;
36
+ calculateDistanceByRectangle(rectA: Rectangle | { _: "Rectangle" | string }, rectB: Rectangle | { _: "Rectangle" | string }): Promise<void>;
37
+ alignRectangleToTargetX(selectedRect: Rectangle | { _: "Rectangle" | string }, otherRect: Rectangle | { _: "Rectangle" | string }): Promise<number>;
38
+ alignRectangleToTargetY(selectedRect: Rectangle | { _: "Rectangle" | string }, otherRect: Rectangle | { _: "Rectangle" | string }): Promise<number>;
39
+ _addAlignEffectByRect(selectedRect: Rectangle | { _: "Rectangle" | string }, otherRect: Rectangle | { _: "Rectangle" | string }): Promise<void>;
40
+ getGridSnapDeltaX(rect: Rectangle | { _: "Rectangle" | string }): Promise<void>;
41
+ getGridSnapDeltaY(rect: Rectangle | { _: "Rectangle" | string }): Promise<void>;
42
+ alignAllSelectedToGrid(): Promise<void>;
43
+ alignAllSelected(): Promise<void>;
44
+ preAlignAllSelected(): Promise<void>;
45
+ onEntityMoveAlignToGrid(selectedEntity: Entity | { _: "Entity" | string }): Promise<void>;
46
+ onEntityMoveAlignToGridX(selectedEntity: Entity | { _: "Entity" | string }): Promise<void>;
47
+ onEntityMoveAlignToGridY(selectedEntity: Entity | { _: "Entity" | string }): Promise<void>;
48
+ onEntityMoveAlignToOtherEntity(selectedEntity: Entity | { _: "Entity" | string }, otherEntities: Entity[], isPreAlign = false): Promise<void>;
49
+ _addAlignEffect(selectedEntity: Entity | { _: "Entity" | string }, otherEntity: Entity | { _: "Entity" | string }): Promise<void>;
50
+ onEntityMoveAlignToTargetEntityX(selectedEntity: Entity | { _: "Entity" | string }, otherEntity: Entity | { _: "Entity" | string }, isPreAlign = false): Promise<number>;
51
+ onEntityMoveAlignToTargetEntityY(selectedEntity: Entity | { _: "Entity" | string }, otherEntity: Entity | { _: "Entity" | string }, isPreAlign = false): Promise<number>;
52
+ calculateDistance(entityA: Entity | { _: "Entity" | string }, entityB: Entity | { _: "Entity" | string }): Promise<void>;
53
+ autoLayoutSelectedFastTreeMode(selectedRootEntity: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<void>;
54
54
  }
55
55
 
56
56
  declare class AutoCompleteManager {
57
- currentWindowId: string | undefined;
58
- constructor(project: Project);
57
+ currentWindowId: Promise<string | undefined>;
58
+ constructor(project: Project | { _: "Project" | string });
59
59
  handle;
60
- openWindow(node: TextNode, entries: Record<string, string>, onSelect: (value: string) => void, setWindowId: (id: string) => void);
61
- handleLogic(text: string, node: TextNode, ele: HTMLTextAreaElement, setWindowId: (id: string) => void);
60
+ openWindow(node: TextNode, entries: Record<string, string>, onSelect: (value: string) => void, setWindowId: (id: string) => void): Promise<void>;
61
+ handleLogic(text: string, node: TextNode, ele: HTMLTextAreaElement, setWindowId: (id: string) => void): Promise<void>;
62
62
  handleReference;
63
- handleReferenceFile(searchText: string, node: TextNode, ele: HTMLTextAreaElement, setWindowId: (id: string) => void);
64
- handleReferenceSection(searchText: string, node: TextNode, ele: HTMLTextAreaElement, setWindowId: (id: string) => void);
63
+ handleReferenceFile(searchText: string, node: TextNode, ele: HTMLTextAreaElement, setWindowId: (id: string) => void): Promise<void>;
64
+ handleReferenceSection(searchText: string, node: TextNode, ele: HTMLTextAreaElement, setWindowId: (id: string) => void): Promise<void>;
65
65
  }
66
66
 
67
67
  declare class AutoCompute {
68
- MapOperationNameFunction: StringFunctionMap;
69
- MapNameFunction: StringFunctionMap;
70
- MapVariableFunction: VariableFunctionMap;
71
- MapOtherFunction: OtherFunctionMap;
68
+ MapOperationNameFunction: Promise<StringFunctionMap>;
69
+ MapNameFunction: Promise<StringFunctionMap>;
70
+ MapVariableFunction: Promise<VariableFunctionMap>;
71
+ MapOtherFunction: Promise<OtherFunctionMap>;
72
72
  variables;
73
- constructor(project: Project);
73
+ constructor(project: Project | { _: "Project" | string });
74
74
  tickNumber;
75
- tick();
76
- funcTypeTrans(mF: MathFunctionType): StringFunctionType;
77
- isTextNodeLogic(node: TextNode): boolean;
78
- isSectionLogic(section: Section): boolean;
79
- sortEntityByLocation(entities: ConnectableEntity[]): ConnectableEntity[];
80
- computeTextNode(node: TextNode);
81
- computeSection(section: Section);
82
- computeEdge(edge: LineEdge);
75
+ tick(): Promise<void>;
76
+ funcTypeTrans(mF: MathFunctionType): Promise<StringFunctionType>;
77
+ isTextNodeLogic(node: TextNode | { _: "TextNode" | string }): Promise<boolean>;
78
+ isSectionLogic(section: Section | { _: "Section" | string }): Promise<boolean>;
79
+ sortEntityByLocation(entities: ConnectableEntity[]): Promise<ConnectableEntity>[];
80
+ computeTextNode(node: TextNode | { _: "TextNode" | string }): Promise<void>;
81
+ computeSection(section: Section | { _: "Section" | string }): Promise<void>;
82
+ computeEdge(edge: LineEdge | { _: "LineEdge" | string }): Promise<void>;
83
83
  }
84
84
 
85
85
  declare class AutoComputeUtils {
86
- constructor(project: Project);
87
- getParentTextNodes(node: TextNode): TextNode[];
88
- getParentEntities(node: TextNode): ConnectableEntity[];
89
- getChildTextNodes(node: TextNode): TextNode[];
90
- getNodeOneResult(node: TextNode, resultText: string);
91
- getSectionOneResult(section: Section, resultText: string);
92
- getSectionMultiResult(section: Section, resultTextList: string[]);
93
- generateMultiResult(node: TextNode, resultTextList: string[]);
94
- stringToNumber(str: string);
95
- isNodeConnectedWithLogicNode(node: ConnectableEntity): boolean;
96
- isNameIsLogicNode(name: string): boolean;
86
+ constructor(project: Project | { _: "Project" | string });
87
+ getParentTextNodes(node: TextNode | { _: "TextNode" | string }): Promise<TextNode>[];
88
+ getParentEntities(node: TextNode | { _: "TextNode" | string }): Promise<ConnectableEntity>[];
89
+ getChildTextNodes(node: TextNode | { _: "TextNode" | string }): Promise<TextNode>[];
90
+ getNodeOneResult(node: TextNode | { _: "TextNode" | string }, resultText: string): Promise<void>;
91
+ getSectionOneResult(section: Section, resultText: string): Promise<void>;
92
+ getSectionMultiResult(section: Section, resultTextList: string[]): Promise<void>;
93
+ generateMultiResult(node: TextNode | { _: "TextNode" | string }, resultTextList: string[]): Promise<void>;
94
+ stringToNumber(str: string): Promise<void>;
95
+ isNodeConnectedWithLogicNode(node: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<boolean>;
96
+ isNameIsLogicNode(name: string): Promise<boolean>;
97
97
  }
98
98
 
99
99
  declare class AutoLayout {
100
- constructor(project: Project);
101
- isGravityLayoutStart: boolean;
102
- tick();
103
- setGravityLayoutStart();
104
- setGravityLayoutEnd();
105
- getDAGLayoutInput(entities: ConnectableEntity[]): {
100
+ constructor(project: Project | { _: "Project" | string });
101
+ isGravityLayoutStart: Promise<boolean>;
102
+ tick(): Promise<void>;
103
+ setGravityLayoutStart(): Promise<void>;
104
+ setGravityLayoutEnd(): Promise<void>;
105
+ getDAGLayoutInput(entities: ConnectableEntity[]): Promise<{
106
106
  nodes: Array<{ id: string; rectangle: Rectangle }>;
107
107
  edges: Array<{ from: string; to: string }>;
108
- };
108
+ }>;
109
109
  computeDAGLayout(input: {
110
110
  nodes: Array<{ id: string; rectangle: Rectangle }>;
111
111
  edges: Array<{ from: string; to: string }>;
112
- }): { [nodeId: string]: Vector };
113
- topologicalSort(nodes: Array<{ id: string; rectangle: Rectangle }>, edges: Array<{ from: string; to: string }>): { order: string[]; levels: Map<string, number> };
114
- autoLayoutDAG(entities: ConnectableEntity[]);
115
- gravityLayoutTick();
112
+ }): Promise<{ [nodeId: string]: Vector }>;
113
+ topologicalSort(nodes: Array<{ id: string; rectangle: Rectangle }>, edges: Array<{ from: string; to: string }>): Promise<{ order: string[]; levels: Map<string, number> }>;
114
+ autoLayoutDAG(entities: ConnectableEntity[]): Promise<void>;
115
+ gravityLayoutTick(): Promise<void>;
116
116
  }
117
117
 
118
118
  declare class AutoLayoutFastTree {
119
- constructor(project: Project);
120
- getTreeBoundingRectangle(node: ConnectableEntity, skipDashed = false): Rectangle;
121
- moveTreeRectTo(treeRoot: ConnectableEntity, targetLocation: Vector, skipDashed = false);
122
- getSortedChildNodes(_node: ConnectableEntity, childNodes: ConnectableEntity[], direction: "col" | "row" = "col"): ConnectableEntity[];
123
- alignTrees(trees: ConnectableEntity[], direction: "top" | "bottom" | "left" | "right", gap = 10, skipDashed = false);
124
- adjustChildrenTreesByRootNodeLocation(rootNode: ConnectableEntity, childList: ConnectableEntity[], gap = 100, position: "rightCenter" | "leftCenter" | "bottomCenter" | "topCenter" = "rightCenter", skipDashed = false);
125
- resolveSubtreeOverlaps(rootNode: ConnectableEntity, directionGroups: {
119
+ constructor(project: Project | { _: "Project" | string });
120
+ getTreeBoundingRectangle(node: ConnectableEntity | { _: "ConnectableEntity" | string }, skipDashed = false): Promise<Rectangle>;
121
+ moveTreeRectTo(treeRoot: ConnectableEntity | { _: "ConnectableEntity" | string }, targetLocation: Vector | { _: "Vector" | string }, skipDashed = false): Promise<void>;
122
+ getSortedChildNodes(_node: ConnectableEntity | { _: "ConnectableEntity" | string }, childNodes: ConnectableEntity[], direction: "col" | "row" = "col"): Promise<ConnectableEntity>[];
123
+ alignTrees(trees: ConnectableEntity[], direction: "top" | "bottom" | "left" | "right", gap = 10, skipDashed = false): Promise<void>;
124
+ adjustChildrenTreesByRootNodeLocation(rootNode: ConnectableEntity | { _: "ConnectableEntity" | string }, childList: ConnectableEntity[], gap = 100, position: "rightCenter" | "leftCenter" | "bottomCenter" | "topCenter" = "rightCenter", skipDashed = false): Promise<void>;
125
+ resolveSubtreeOverlaps(rootNode: ConnectableEntity | { _: "ConnectableEntity" | string }, directionGroups: {
126
126
  right?: ConnectableEntity[];
127
127
  left?: ConnectableEntity[];
128
128
  bottom?: ConnectableEntity[];
129
129
  top?: ConnectableEntity[];
130
- }, skipDashed = false);
131
- hasOverlapOrLineIntersection(rootNode: ConnectableEntity, group1: ConnectableEntity[], group2: ConnectableEntity[], dir1: "left" | "right" | "top" | "bottom", dir2: "left" | "right" | "top" | "bottom", skipDashed = false): boolean;
132
- autoLayoutFastTreeMode(rootNode: ConnectableEntity);
133
- treeReverseX(selectedRootEntity: ConnectableEntity);
134
- treeReverseY(selectedRootEntity: ConnectableEntity);
135
- treeReverse(selectedRootEntity: ConnectableEntity, direction: "X" | "Y");
130
+ }, skipDashed = false): Promise<void>;
131
+ hasOverlapOrLineIntersection(rootNode: ConnectableEntity | { _: "ConnectableEntity" | string }, group1: ConnectableEntity[], group2: ConnectableEntity[], dir1: "left" | "right" | "top" | "bottom", dir2: "left" | "right" | "top" | "bottom", skipDashed = false): Promise<boolean>;
132
+ autoLayoutFastTreeMode(rootNode: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<void>;
133
+ treeReverseX(selectedRootEntity: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<void>;
134
+ treeReverseY(selectedRootEntity: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<void>;
135
+ treeReverse(selectedRootEntity: ConnectableEntity | { _: "ConnectableEntity" | string }, direction: "X" | "Y"): Promise<void>;
136
136
  }
137
137
 
138
138
  declare class AutoSaveBackupService {
139
139
  lastBackupTime;
140
140
  lastBackupHash;
141
141
  lastSaveTime;
142
- constructor(project: Project);
143
- tick();
144
- autoSave();
145
- autoBackup();
146
- manualBackup();
142
+ constructor(project: Project | { _: "Project" | string });
143
+ tick(): Promise<void>;
144
+ autoSave(): Promise<void>;
145
+ autoBackup(): Promise<void>;
146
+ manualBackup(): Promise<void>;
147
147
  resolveAutoBackupDir(candidate: { kind: "custom"; path: string } | { kind: "default" }): Promise<string | null>;
148
148
  tryBackupToDir(backupDir: string): Promise<boolean>;
149
149
  backupCurrentProject(backupDir: string): Promise<boolean>;
150
- generateBackupFileName(): string;
151
- getOriginalFileName(): string;
150
+ generateBackupFileName(): Promise<string>;
151
+ getOriginalFileName(): Promise<string>;
152
152
  createBackupFile(backupFilePath: string): Promise<void>;
153
153
  manageBackupFiles(backupDir: string): Promise<void>;
154
154
  }
155
155
 
156
156
  declare class BackgroundRenderer {
157
- constructor(project: Project);
158
- renderDotBackground(viewRect: Rectangle);
159
- renderHorizonBackground(viewRect: Rectangle);
160
- renderVerticalBackground(viewRect: Rectangle);
161
- renderCartesianBackground(viewRect: Rectangle);
162
- getCurrentGap(): number;
163
- getLocationXIterator(viewRect: Rectangle, currentGap: number): IterableIterator<number>;
164
- getLocationYIterator(viewRect: Rectangle, currentGap: number): IterableIterator<number>;
157
+ constructor(project: Project | { _: "Project" | string });
158
+ renderDotBackground(viewRect: Rectangle | { _: "Rectangle" | string }): Promise<void>;
159
+ renderHorizonBackground(viewRect: Rectangle | { _: "Rectangle" | string }): Promise<void>;
160
+ renderVerticalBackground(viewRect: Rectangle | { _: "Rectangle" | string }): Promise<void>;
161
+ renderCartesianBackground(viewRect: Rectangle | { _: "Rectangle" | string }): Promise<void>;
162
+ getCurrentGap(): Promise<number>;
163
+ getLocationXIterator(viewRect: Rectangle | { _: "Rectangle" | string }, currentGap: number): Promise<IterableIterator<number>>;
164
+ getLocationYIterator(viewRect: Rectangle | { _: "Rectangle" | string }, currentGap: number): Promise<IterableIterator<number>>;
165
165
  }
166
166
 
167
167
  declare class BaseExporter {
168
- constructor(project: Project);
169
- getTreeTypeString(textNode: TextNode, nodeToStringFunc: (node: TextNode, level: number) => string);
170
- getNodeChildrenArray(node: TextNode): ConnectableEntity[];
168
+ constructor(project: Project | { _: "Project" | string });
169
+ getTreeTypeString(textNode: TextNode | { _: "TextNode" | string }, nodeToStringFunc: (node: TextNode, level: number) => string): Promise<void>;
170
+ getNodeChildrenArray(node: TextNode | { _: "TextNode" | string }): Promise<ConnectableEntity>[];
171
171
  }
172
172
 
173
173
  declare class BaseImporter {
174
- constructor(project: Project);
174
+ constructor(project: Project | { _: "Project" | string });
175
175
  }
176
176
 
177
177
  declare class Camera {
178
178
  frictionExponent;
179
- location: Vector;
180
- targetLocationByScale: Vector;
181
- speed: Vector;
182
- accelerateCommander: Vector;
183
- currentScale: number;
184
- targetScale: number;
185
- shakeLocation: Vector;
186
- savedCameraState: { location: Vector; scale: number } | null;
179
+ location: Promise<Vector>;
180
+ targetLocationByScale: Promise<Vector>;
181
+ speed: Promise<Vector>;
182
+ accelerateCommander: Promise<Vector>;
183
+ currentScale: Promise<number>;
184
+ targetScale: Promise<number>;
185
+ shakeLocation: Promise<Vector>;
186
+ savedCameraState: Promise<{ location: Vector; scale: number } | null>;
187
187
  shockMoveDiffLocationsQueue;
188
- pageMove(direction: Direction);
189
- bombMove(targetLocation: Vector, frameCount = 40);
190
- tick();
188
+ pageMove(direction: Direction): Promise<void>;
189
+ bombMove(targetLocation: Vector | { _: "Vector" | string }, frameCount = 40): Promise<void>;
190
+ tick(): Promise<void>;
191
191
  tickNumber;
192
192
  allowScaleFollowMouseLocationTicks;
193
- setAllowScaleFollowMouseLocationTicks(ticks: number);
194
- zoomInByKeyboardPress();
195
- zoomOutByKeyboardPress();
196
- addScaleFollowMouseLocationTime(sec: number);
197
- isStartZoomIn: boolean;
198
- isStartZoomOut: boolean;
199
- dealCycleSpace();
200
- setLocationByOtherLocation(otherWorldLocation: Vector, viewLocation: Vector);
201
- clearMoveCommander();
202
- stopImmediately();
203
- dealCameraScaleInTick();
204
- constructor(project: Project);
205
- reset();
206
- resetBySelected();
207
- resetByRectangle(viewRectangle: Rectangle);
208
- resetScale();
209
- resetLocationToZero();
210
- saveCameraState();
211
- restoreCameraState();
193
+ setAllowScaleFollowMouseLocationTicks(ticks: number): Promise<void>;
194
+ zoomInByKeyboardPress(): Promise<void>;
195
+ zoomOutByKeyboardPress(): Promise<void>;
196
+ addScaleFollowMouseLocationTime(sec: number): Promise<void>;
197
+ isStartZoomIn: Promise<boolean>;
198
+ isStartZoomOut: Promise<boolean>;
199
+ dealCycleSpace(): Promise<void>;
200
+ setLocationByOtherLocation(otherWorldLocation: Vector | { _: "Vector" | string }, viewLocation: Vector | { _: "Vector" | string }): Promise<void>;
201
+ clearMoveCommander(): Promise<void>;
202
+ stopImmediately(): Promise<void>;
203
+ dealCameraScaleInTick(): Promise<void>;
204
+ constructor(project: Project | { _: "Project" | string });
205
+ reset(): Promise<void>;
206
+ resetBySelected(): Promise<void>;
207
+ resetByRectangle(viewRectangle: Rectangle | { _: "Rectangle" | string }): Promise<void>;
208
+ resetScale(): Promise<void>;
209
+ resetLocationToZero(): Promise<void>;
210
+ saveCameraState(): Promise<void>;
211
+ restoreCameraState(): Promise<void>;
212
212
  }
213
213
 
214
214
  declare class Canvas {
215
- ctx: CanvasRenderingContext2D;
216
- constructor(project: Project, element: HTMLCanvasElement = document.createElement("canvas"));
217
- mount(wrapper: HTMLDivElement);
218
- dispose();
215
+ ctx: Promise<CanvasRenderingContext2D>;
216
+ constructor(project: Project | { _: "Project" | string }, element: HTMLCanvasElement = document.createElement("canvas"));
217
+ mount(wrapper: HTMLDivElement): Promise<void>;
218
+ dispose(): Promise<void>;
219
219
  }
220
220
 
221
221
  declare interface ClickEventPayload {
222
- relativeWorldX: number;
223
- relativeWorldY: number;
224
- worldX: number;
225
- worldY: number;
222
+ relativeWorldX: Promise<number>;
223
+ relativeWorldY: Promise<number>;
224
+ worldX: Promise<number>;
225
+ worldY: Promise<number>;
226
226
  customData: any;
227
- uuid: string;
227
+ uuid: Promise<string>;
228
228
  }
229
229
 
230
230
  declare class CollisionBox {
231
- shapes: Shape[];
231
+ shapes: Promise<Shape>[];
232
232
  constructor(shapes: Shape[]);
233
233
  updateShapeList(shapes: Shape[]): void;
234
- isContainsPoint(location: Vector): boolean;
235
- isIntersectsWithRectangle(rectangle: Rectangle): boolean;
236
- isContainedByRectangle(rectangle: Rectangle): boolean;
237
- isIntersectsWithLine(line: Line): boolean;
238
- getRectangle(): Rectangle;
234
+ isContainsPoint(location: Vector | { _: "Vector" | string }): Promise<boolean>;
235
+ isIntersectsWithRectangle(rectangle: Rectangle | { _: "Rectangle" | string }): Promise<boolean>;
236
+ isContainedByRectangle(rectangle: Rectangle | { _: "Rectangle" | string }): Promise<boolean>;
237
+ isIntersectsWithLine(line: Line | { _: "Line" | string }): Promise<boolean>;
238
+ getRectangle(): Promise<Rectangle>;
239
239
  }
240
240
 
241
241
  declare class CollisionBoxRenderer {
242
- constructor(project: Project);
243
- render(collideBox: CollisionBox, color: Color);
242
+ constructor(project: Project | { _: "Project" | string });
243
+ render(collideBox: CollisionBox | { _: "CollisionBox" | string }, color: Color | { _: "Color" | string }): Promise<void>;
244
244
  }
245
245
 
246
246
  declare class ComplexityDetector {
247
- constructor(project: Project);
248
- detectorCurrentStage(): CountResultObject;
247
+ constructor(project: Project | { _: "Project" | string });
248
+ detectorCurrentStage(): Promise<CountResultObject>;
249
249
  }
250
250
 
251
251
  declare class ConnectableAssociation extends Association {
252
- associationList: ConnectableEntity[];
253
- reverse();
254
- get target(): ConnectableEntity;
252
+ associationList: Promise<ConnectableEntity>[];
253
+ reverse(): Promise<void>;
254
+ get target(): Promise<ConnectableEntity>;
255
255
  set target(value: ConnectableEntity);
256
- get source(): ConnectableEntity;
256
+ get source(): Promise<ConnectableEntity>;
257
257
  set source(value: ConnectableEntity);
258
258
  }
259
259
 
260
260
  declare class ConnectableEntity extends Entity {
261
- geometryCenter: Vector;
261
+ geometryCenter: Promise<Vector>;
262
262
  unknown;
263
263
  }
264
264
 
265
265
  declare class ConnectPoint extends ConnectableEntity {
266
266
  CONNECT_POINT_SHRINK_RADIUS;
267
267
  CONNECT_POINT_EXPAND_RADIUS;
268
- get geometryCenter(): Vector;
269
- isHiddenBySectionCollapse: boolean;
270
- collisionBox: CollisionBox;
271
- uuid: string;
272
- get radius(): number;
273
- _isSelected: boolean;
274
- get isSelected(): any;
268
+ get geometryCenter(): Promise<Vector>;
269
+ isHiddenBySectionCollapse: Promise<boolean>;
270
+ collisionBox: Promise<CollisionBox>;
271
+ uuid: Promise<string>;
272
+ get radius(): Promise<number>;
273
+ _isSelected: Promise<boolean>;
274
+ get isSelected(): Promise<any>;
275
275
  set isSelected(value: boolean);
276
- constructor(project: Project, {
276
+ constructor(project: Project | { _: "Project" | string }, {
277
277
  uuid = crypto.randomUUID() as string,
278
278
  collisionBox = new CollisionBox([
279
279
  new Rectangle(Vector.getZero(), Vector.same(ConnectPoint.CONNECT_POINT_SHRINK_RADIUS * 2)),
280
280
  ]),
281
281
  details = [],
282
282
  }, unknown = false);
283
- move(delta: Vector): void;
284
- moveTo(location: Vector): void;
283
+ move(delta: Vector | { _: "Vector" | string }): void;
284
+ moveTo(location: Vector | { _: "Vector" | string }): void;
285
285
  }
286
286
 
287
287
  declare class ContentSearch {
288
- constructor(project: Project);
289
- searchResultNodes: StageObject[];
288
+ constructor(project: Project | { _: "Project" | string });
289
+ searchResultNodes: Promise<StageObject>[];
290
290
  isCaseSensitive;
291
291
  searchScope;
292
292
  currentSearchResultIndex;
293
- getStageObjectText(stageObject: StageObject): string;
294
- getSelectedObjectsBounds(): Rectangle | null;
295
- isObjectInBounds(obj: StageObject, bounds: Rectangle): boolean;
296
- startSearch(searchString: string, autoFocus = true): boolean;
297
- nextSearchResult();
298
- previousSearchResult();
293
+ getStageObjectText(stageObject: StageObject | { _: "StageObject" | string }): Promise<string>;
294
+ getSelectedObjectsBounds(): Promise<Rectangle | null>;
295
+ isObjectInBounds(obj: StageObject | { _: "StageObject" | string }, bounds: Rectangle | { _: "Rectangle" | string }): Promise<boolean>;
296
+ startSearch(searchString: string, autoFocus = true): Promise<boolean>;
297
+ nextSearchResult(): Promise<void>;
298
+ previousSearchResult(): Promise<void>;
299
299
  }
300
300
 
301
301
  declare class Controller {
302
- setCursorNameHook: (_: CursorNameEnum) => void;
303
- pressingKeySet: Set<string>;
304
- pressingKeysString(): string;
302
+ setCursorNameHook: Promise<(_: CursorNameEnum) => void>;
303
+ pressingKeySet: Promise<Set<string>>;
304
+ pressingKeysString(): Promise<string>;
305
305
  isMovingEdge;
306
306
  lastMoveLocation;
307
307
  mouseLocation;
308
308
  isCameraLocked;
309
- lastSelectedEntityUUID: Set<string>;
310
- lastSelectedEdgeUUID: Set<string>;
309
+ lastSelectedEntityUUID: Promise<Set<string>>;
310
+ lastSelectedEdgeUUID: Promise<Set<string>>;
311
311
  touchStartLocation;
312
312
  touchStartDistance;
313
313
  touchDelta;
314
314
  lastClickTime;
315
315
  lastClickLocation;
316
- isMouseDown: boolean[];
316
+ isMouseDown: Promise<boolean>[];
317
317
  lastManipulateTime;
318
- resetCountdownTimer();
319
- isManipulateOverTime();
318
+ resetCountdownTimer(): Promise<void>;
319
+ isManipulateOverTime(): Promise<void>;
320
320
  edgeHoverTolerance;
321
- constructor(project: Project);
322
- dispose();
323
- mousedown(event: MouseEvent);
324
- mouseup(event: MouseEvent);
325
- mousewheel(event: WheelEvent);
326
- handleMousedown(button: number, _x: number, _y: number);
327
- handleMouseup(button: number, x: number, y: number);
328
- keydown(event: KeyboardEvent);
329
- keyup(event: KeyboardEvent);
330
- touchstart(e: TouchEvent);
331
- touchmove(e: TouchEvent);
332
- touchend(e: TouchEvent);
333
- associationReshape: ControllerAssociationReshapeClass;
334
- camera: ControllerCameraClass;
335
- cutting: ControllerCuttingClass;
336
- edgeEdit: ControllerEdgeEditClass;
337
- entityClickSelectAndMove: ControllerEntityClickSelectAndMoveClass;
338
- entityCreate: ControllerEntityCreateClass;
339
- extensionEntityClick: ControllerExtensionEntityClickClass;
340
- layerMoving: ControllerLayerMovingClass;
341
- entityResize: ControllerEntityResizeClass;
342
- nodeConnection: ControllerNodeConnectionClass;
343
- nodeEdit: ControllerNodeEditClass;
344
- penStrokeControl: ControllerPenStrokeControlClass;
345
- penStrokeDrawing: ControllerPenStrokeDrawingClass;
346
- rectangleSelect: ControllerRectangleSelectClass;
347
- sectionEdit: ControllerSectionEditClass;
348
- imageScale: ControllerImageScaleClass;
321
+ constructor(project: Project | { _: "Project" | string });
322
+ dispose(): Promise<void>;
323
+ mousedown(event: MouseEvent): Promise<void>;
324
+ mouseup(event: MouseEvent): Promise<void>;
325
+ mousewheel(event: WheelEvent): Promise<void>;
326
+ handleMousedown(button: number, _x: number, _y: number): Promise<void>;
327
+ handleMouseup(button: number, x: number, y: number): Promise<void>;
328
+ keydown(event: KeyboardEvent): Promise<void>;
329
+ keyup(event: KeyboardEvent): Promise<void>;
330
+ touchstart(e: TouchEvent): Promise<void>;
331
+ touchmove(e: TouchEvent): Promise<void>;
332
+ touchend(e: TouchEvent): Promise<void>;
333
+ associationReshape: Promise<ControllerAssociationReshapeClass>;
334
+ camera: Promise<ControllerCameraClass>;
335
+ cutting: Promise<ControllerCuttingClass>;
336
+ edgeEdit: Promise<ControllerEdgeEditClass>;
337
+ entityClickSelectAndMove: Promise<ControllerEntityClickSelectAndMoveClass>;
338
+ entityCreate: Promise<ControllerEntityCreateClass>;
339
+ extensionEntityClick: Promise<ControllerExtensionEntityClickClass>;
340
+ layerMoving: Promise<ControllerLayerMovingClass>;
341
+ entityResize: Promise<ControllerEntityResizeClass>;
342
+ nodeConnection: Promise<ControllerNodeConnectionClass>;
343
+ nodeEdit: Promise<ControllerNodeEditClass>;
344
+ penStrokeControl: Promise<ControllerPenStrokeControlClass>;
345
+ penStrokeDrawing: Promise<ControllerPenStrokeDrawingClass>;
346
+ rectangleSelect: Promise<ControllerRectangleSelectClass>;
347
+ sectionEdit: Promise<ControllerSectionEditClass>;
348
+ imageScale: Promise<ControllerImageScaleClass>;
349
349
  }
350
350
 
351
351
  declare class ControllerAssociationReshapeClass extends ControllerClass {
352
- mousewheel: (event: WheelEvent) => void;
353
- lastMoveLocation: Vector;
354
- mousedown: (event: MouseEvent) => void;
355
- mousemove: (event: MouseEvent) => void;
356
- mouseup: (event: MouseEvent) => void;
352
+ mousewheel: Promise<(event: WheelEvent) => void>;
353
+ lastMoveLocation: Promise<Vector>;
354
+ mousedown: Promise<(event: MouseEvent) => void>;
355
+ mousemove: Promise<(event: MouseEvent) => void>;
356
+ mouseup: Promise<(event: MouseEvent) => void>;
357
357
  }
358
358
 
359
359
  declare class ControllerCameraClass extends ControllerClass {
360
360
  isUsingMouseGrabMove;
361
- lastMousePressLocation: Vector[];
361
+ lastMousePressLocation: Promise<Vector>[];
362
362
  isPreGrabbingWhenSpace;
363
363
  mac;
364
- keydown: (event: KeyboardEvent) => void;
365
- keyup: (event: KeyboardEvent) => void;
364
+ keydown: Promise<(event: KeyboardEvent) => void>;
365
+ keyup: Promise<(event: KeyboardEvent) => void>;
366
366
  mousedown;
367
- mousemove: (event: MouseEvent) => void;
368
- mouseMoveOutWindowForcedShutdown(vectorObject: Vector);
367
+ mousemove: Promise<(event: MouseEvent) => void>;
368
+ mouseMoveOutWindowForcedShutdown(vectorObject: Vector | { _: "Vector" | string }): Promise<void>;
369
369
  mouseup;
370
370
  mousewheel;
371
- dealStealthMode(event: WheelEvent);
372
- mousewheelFunction(event: WheelEvent);
373
- mouseDoubleClick: (event: MouseEvent) => void;
374
- moveCameraByMouseMove(x: number, y: number, mouseIndex: number);
375
- moveCameraByTouchPadTwoFingerMove(event: WheelEvent);
376
- zoomCameraByMouseWheel(event: WheelEvent);
377
- moveYCameraByMouseWheel(event: WheelEvent);
378
- moveCameraByMouseSideWheel(event: WheelEvent);
379
- zoomCameraByMouseSideWheel(event: WheelEvent);
380
- moveYCameraByMouseSideWheel(event: WheelEvent);
381
- moveXCameraByMouseWheel(event: WheelEvent);
382
- moveXCameraByMouseSideWheel(event: WheelEvent);
383
- isMouseWheel(event: WheelEvent): boolean;
384
- addDistanceNumberAndDetect(distance: number): boolean;
385
- detectDeltaY: LimitLengthQueue<number>;
386
- importantNumbers: Set<number>;
371
+ dealStealthMode(event: WheelEvent): Promise<void>;
372
+ mousewheelFunction(event: WheelEvent): Promise<void>;
373
+ mouseDoubleClick: Promise<(event: MouseEvent) => void>;
374
+ moveCameraByMouseMove(x: number, y: number, mouseIndex: number): Promise<void>;
375
+ moveCameraByTouchPadTwoFingerMove(event: WheelEvent): Promise<void>;
376
+ zoomCameraByMouseWheel(event: WheelEvent): Promise<void>;
377
+ moveYCameraByMouseWheel(event: WheelEvent): Promise<void>;
378
+ moveCameraByMouseSideWheel(event: WheelEvent): Promise<void>;
379
+ zoomCameraByMouseSideWheel(event: WheelEvent): Promise<void>;
380
+ moveYCameraByMouseSideWheel(event: WheelEvent): Promise<void>;
381
+ moveXCameraByMouseWheel(event: WheelEvent): Promise<void>;
382
+ moveXCameraByMouseSideWheel(event: WheelEvent): Promise<void>;
383
+ isMouseWheel(event: WheelEvent): Promise<boolean>;
384
+ addDistanceNumberAndDetect(distance: number): Promise<boolean>;
385
+ detectDeltaY: Promise<LimitLengthQueue<number>>;
386
+ importantNumbers: Promise<Set<number>>;
387
387
  }
388
388
 
389
389
  declare class ControllerClass {
390
- constructor(project: Project);
391
- lastMoveLocation: Vector;
392
- lastClickTime: number;
393
- lastClickLocation: Vector;
394
- keydown: (event: KeyboardEvent) => void;
395
- keyup: (event: KeyboardEvent) => void;
396
- mousedown: (event: PointerEvent) => void;
397
- mouseup: (event: PointerEvent) => void;
398
- mousemove: (event: PointerEvent) => void;
399
- mousewheel: (event: WheelEvent) => void;
400
- mouseDoubleClick: (event: PointerEvent) => void;
401
- touchstart: (event: TouchEvent) => void;
402
- touchmove: (event: TouchEvent) => void;
403
- touchend: (event: TouchEvent) => void;
404
- dispose();
390
+ constructor(project: Project | { _: "Project" | string });
391
+ lastMoveLocation: Promise<Vector>;
392
+ lastClickTime: Promise<number>;
393
+ lastClickLocation: Promise<Vector>;
394
+ keydown: Promise<(event: KeyboardEvent) => void>;
395
+ keyup: Promise<(event: KeyboardEvent) => void>;
396
+ mousedown: Promise<(event: PointerEvent) => void>;
397
+ mouseup: Promise<(event: PointerEvent) => void>;
398
+ mousemove: Promise<(event: PointerEvent) => void>;
399
+ mousewheel: Promise<(event: WheelEvent) => void>;
400
+ mouseDoubleClick: Promise<(event: PointerEvent) => void>;
401
+ touchstart: Promise<(event: TouchEvent) => void>;
402
+ touchmove: Promise<(event: TouchEvent) => void>;
403
+ touchend: Promise<(event: TouchEvent) => void>;
404
+ dispose(): Promise<void>;
405
405
  _mouseup;
406
406
  _touchstart;
407
407
  _touchmove;
408
- onePointTouchMoveLocation: Vector;
408
+ onePointTouchMoveLocation: Promise<Vector>;
409
409
  _touchend;
410
- mouseMoveOutWindowForcedShutdown(_outsideLocation: Vector);
410
+ mouseMoveOutWindowForcedShutdown(_outsideLocation: Vector | { _: "Vector" | string }): Promise<void>;
411
411
  }
412
412
 
413
413
  declare class ControllerCuttingClass extends ControllerClass {
@@ -415,32 +415,32 @@ declare class ControllerCuttingClass extends ControllerClass {
415
415
  _isControlKeyDown;
416
416
  onControlKeyDown;
417
417
  onControlKeyUp;
418
- registerControlKeyEvents();
419
- unregisterControlKeyEvents();
420
- constructor(project: Project);
421
- dispose();
422
- cuttingLine: Line;
418
+ registerControlKeyEvents(): Promise<void>;
419
+ unregisterControlKeyEvents(): Promise<void>;
420
+ constructor(project: Project | { _: "Project" | string });
421
+ dispose(): Promise<void>;
422
+ cuttingLine: Promise<Line>;
423
423
  lastMoveLocation;
424
- warningEntity: Entity[];
425
- warningSections: Section[];
426
- warningAssociations: Association[];
424
+ warningEntity: Promise<Entity>[];
425
+ warningSections: Promise<Section>[];
426
+ warningAssociations: Promise<Association>[];
427
427
  isUsing;
428
- twoPointsMap: Record<string, Vector[]>;
428
+ twoPointsMap: Promise<Record<string, Vector[]>>;
429
429
  cuttingStartLocation;
430
- mousedown: (event: MouseEvent) => void;
431
- mouseDownEvent(event: MouseEvent);
432
- mousemove: (event: MouseEvent) => void;
433
- clearIsolationPoint();
434
- mouseUpFunction(mouseUpWindowLocation: Vector);
435
- mouseup: (event: MouseEvent) => void;
436
- mouseMoveOutWindowForcedShutdown(outsideLocation: Vector);
437
- updateWarningObjectByCuttingLine();
438
- addEffectByWarningEntity();
430
+ mousedown: Promise<(event: MouseEvent) => void>;
431
+ mouseDownEvent(event: MouseEvent): Promise<void>;
432
+ mousemove: Promise<(event: MouseEvent) => void>;
433
+ clearIsolationPoint(): Promise<void>;
434
+ mouseUpFunction(mouseUpWindowLocation: Vector | { _: "Vector" | string }): Promise<void>;
435
+ mouseup: Promise<(event: MouseEvent) => void>;
436
+ mouseMoveOutWindowForcedShutdown(outsideLocation: Vector | { _: "Vector" | string }): Promise<void>;
437
+ updateWarningObjectByCuttingLine(): Promise<void>;
438
+ addEffectByWarningEntity(): Promise<void>;
439
439
  }
440
440
 
441
441
  declare class ControllerEdgeEditClass extends ControllerClass {
442
- editEdgeText(clickedLineEdge: Edge, selectAll = true);
443
- editMultiTargetEdgeText(clickedEdge: MultiTargetUndirectedEdge, selectAll = true);
442
+ editEdgeText(clickedLineEdge: Edge | { _: "Edge" | string }, selectAll = true): Promise<void>;
443
+ editMultiTargetEdgeText(clickedEdge: MultiTargetUndirectedEdge | { _: "MultiTargetUndirectedEdge" | string }, selectAll = true): Promise<void>;
444
444
  mouseDoubleClick;
445
445
  keydown;
446
446
  }
@@ -449,29 +449,29 @@ declare class ControllerEntityClickSelectAndMoveClass extends ControllerClass {
449
449
  isMovingEntity;
450
450
  mouseDownViewLocation;
451
451
  shakeDetector;
452
- shiftAxisLock: "x" | "y" | null;
452
+ shiftAxisLock: Promise<"x" | "y" | null>;
453
453
  shiftAccumulatedDelta;
454
- mousedown: (event: MouseEvent) => void;
455
- mousemove: (event: MouseEvent) => void;
456
- mouseup: (event: MouseEvent) => void;
457
- mouseMoveOutWindowForcedShutdown(_outsideLocation: Vector): void;
454
+ mousedown: Promise<(event: MouseEvent) => void>;
455
+ mousemove: Promise<(event: MouseEvent) => void>;
456
+ mouseup: Promise<(event: MouseEvent) => void>;
457
+ mouseMoveOutWindowForcedShutdown(_outsideLocation: Vector | { _: "Vector" | string }): void;
458
458
  }
459
459
 
460
460
  declare class ControllerEntityCreateClass extends ControllerClass {
461
- constructor(project: Project);
461
+ constructor(project: Project | { _: "Project" | string });
462
462
  mouseDoubleClick;
463
- createConnectPoint(pressLocation: Vector, addToSections: Section[]);
463
+ createConnectPoint(pressLocation: Vector | { _: "Vector" | string }, addToSections: Section[]): Promise<void>;
464
464
  }
465
465
 
466
466
  declare class ControllerEntityResizeClass extends ControllerClass {
467
- changeSizeEntity: Entity | null;
468
- mousedown: (event: MouseEvent) => void;
469
- mousemove: (event: MouseEvent) => void;
470
- mouseup: (event: MouseEvent) => void;
467
+ changeSizeEntity: Promise<Entity | null>;
468
+ mousedown: Promise<(event: MouseEvent) => void>;
469
+ mousemove: Promise<(event: MouseEvent) => void>;
470
+ mouseup: Promise<(event: MouseEvent) => void>;
471
471
  }
472
472
 
473
473
  declare class ControllerExtensionEntityClickClass extends ControllerClass {
474
- constructor(project: Project);
474
+ constructor(project: Project | { _: "Project" | string });
475
475
  mousedown;
476
476
  }
477
477
 
@@ -480,9 +480,9 @@ declare class ControllerImageScaleClass extends ControllerClass {
480
480
  }
481
481
 
482
482
  declare class ControllerLayerMovingClass extends ControllerClass {
483
- get isEnabled(): boolean;
484
- mousemove: (event: MouseEvent) => void;
485
- mouseup: (event: MouseEvent) => void;
483
+ get isEnabled(): Promise<boolean>;
484
+ mousemove: Promise<(event: MouseEvent) => void>;
485
+ mouseup: Promise<(event: MouseEvent) => void>;
486
486
  }
487
487
 
488
488
  declare class ControllerNodeConnectionClass extends ControllerClass {
@@ -490,161 +490,161 @@ declare class ControllerNodeConnectionClass extends ControllerClass {
490
490
  _controlKeyEventRegistered;
491
491
  onControlKeyDown;
492
492
  onControlKeyUp;
493
- registerControlKeyEvents();
494
- unregisterControlKeyEvents();
495
- _lastRightMousePressLocation: Vector;
496
- _isUsing: boolean;
497
- get isUsing(): boolean;
498
- constructor(project: Project);
499
- dispose();
500
- connectFromEntities: ConnectableEntity[];
501
- connectToEntity: ConnectableEntity | null;
502
- mouseLocations: Vector[];
503
- getMouseLocationsPoints(): Vector[];
504
- createConnectPointWhenConnect();
505
- mousedown: (event: MouseEvent) => void;
506
- _startImageLocation: Map<string, Vector>;
507
- _endImageLocation: Vector | null;
508
- _hoverImageLocation: Vector | null;
509
- _previewSourceDirection: Direction | null;
510
- _previewTargetDirection: Direction | null;
511
- getHoverImageNode(): ImageNode | null;
512
- getHoverImageLocation(): Vector | null;
513
- onMouseDown(event: MouseEvent);
493
+ registerControlKeyEvents(): Promise<void>;
494
+ unregisterControlKeyEvents(): Promise<void>;
495
+ _lastRightMousePressLocation: Promise<Vector>;
496
+ _isUsing: Promise<boolean>;
497
+ get isUsing(): Promise<boolean>;
498
+ constructor(project: Project | { _: "Project" | string });
499
+ dispose(): Promise<void>;
500
+ connectFromEntities: Promise<ConnectableEntity>[];
501
+ connectToEntity: Promise<ConnectableEntity | null>;
502
+ mouseLocations: Promise<Vector>[];
503
+ getMouseLocationsPoints(): Promise<Vector>[];
504
+ createConnectPointWhenConnect(): Promise<void>;
505
+ mousedown: Promise<(event: MouseEvent) => void>;
506
+ _startImageLocation: Promise<Map<string, Vector>>;
507
+ _endImageLocation: Promise<Vector | null>;
508
+ _hoverImageLocation: Promise<Vector | null>;
509
+ _previewSourceDirection: Promise<Direction | null>;
510
+ _previewTargetDirection: Promise<Direction | null>;
511
+ getHoverImageNode(): Promise<ImageNode | null>;
512
+ getHoverImageLocation(): Promise<Vector | null>;
513
+ onMouseDown(event: MouseEvent): Promise<void>;
514
514
  isMouseHoverOnTarget;
515
- mousemove: (event: MouseEvent) => void;
516
- mouseMove(event: MouseEvent);
517
- mouseup: (event: MouseEvent) => void;
518
- mouseUp(event: MouseEvent);
519
- getConnectDirectionByMouseTrack(): [Direction | null, Direction | null];
515
+ mousemove: Promise<(event: MouseEvent) => void>;
516
+ mouseMove(event: MouseEvent): Promise<void>;
517
+ mouseup: Promise<(event: MouseEvent) => void>;
518
+ mouseUp(event: MouseEvent): Promise<void>;
519
+ getConnectDirectionByMouseTrack(): Promise<[Direction | null, Direction | null]>;
520
520
  _hasSourceSparkTriggered;
521
521
  _hasTargetSparkTriggered;
522
- getOppositeDirection(direction: Direction): Direction;
523
- clickMultiConnect(releaseWorldLocation: Vector);
524
- clear();
525
- updatePreviewDirections();
526
- directionToRate(direction: Direction | null): Vector;
527
- getPreviewSourceRectangleRate(): Vector;
528
- getPreviewTargetRectangleRate(): Vector;
529
- dragMultiConnect(connectToEntity: ConnectableEntity, sourceDirection: Direction | null = null, targetDirection: Direction | null = null);
530
- isConnecting();
531
- addConnectEffect(from: ConnectableEntity, to: ConnectableEntity, sourceRectRate?: Vector, targetRectRate?: Vector);
522
+ getOppositeDirection(direction: Direction): Promise<Direction>;
523
+ clickMultiConnect(releaseWorldLocation: Vector | { _: "Vector" | string }): Promise<void>;
524
+ clear(): Promise<void>;
525
+ updatePreviewDirections(): Promise<void>;
526
+ directionToRate(direction: Direction | null): Promise<Vector>;
527
+ getPreviewSourceRectangleRate(): Promise<Vector>;
528
+ getPreviewTargetRectangleRate(): Promise<Vector>;
529
+ dragMultiConnect(connectToEntity: ConnectableEntity | { _: "ConnectableEntity" | string }, sourceDirection: Direction | null = null, targetDirection: Direction | null = null): Promise<void>;
530
+ isConnecting(): Promise<void>;
531
+ addConnectEffect(from: ConnectableEntity | { _: "ConnectableEntity" | string }, to: ConnectableEntity | { _: "ConnectableEntity" | string }, sourceRectRate?: Vector | { _: "Vector" | string }, targetRectRate?: Vector | { _: "Vector" | string }): Promise<void>;
532
532
  }
533
533
 
534
534
  declare class ControllerNodeEditClass extends ControllerClass {
535
- constructor(project: Project);
535
+ constructor(project: Project | { _: "Project" | string });
536
536
  mouseDoubleClick;
537
537
  mouseup;
538
538
  mousemove;
539
- editUrlNodeTitle(clickedUrlNode: UrlNode);
540
- editLatexNode(node: LatexNode);
539
+ editUrlNodeTitle(clickedUrlNode: UrlNode | { _: "UrlNode" | string }): Promise<void>;
540
+ editLatexNode(node: LatexNode | { _: "LatexNode" | string }): Promise<void>;
541
541
  }
542
542
 
543
543
  declare class ControllerPenStrokeControlClass extends ControllerClass {
544
544
  isAdjusting;
545
- startAdjustWidthLocation: Vector;
546
- lastAdjustWidthLocation: Vector;
547
- mousedown: (event: MouseEvent) => void;
548
- mousemove: (event: MouseEvent) => void;
549
- mouseup: (event: MouseEvent) => void;
545
+ startAdjustWidthLocation: Promise<Vector>;
546
+ lastAdjustWidthLocation: Promise<Vector>;
547
+ mousedown: Promise<(event: MouseEvent) => void>;
548
+ mousemove: Promise<(event: MouseEvent) => void>;
549
+ mouseup: Promise<(event: MouseEvent) => void>;
550
550
  onMouseMoveWhenAdjusting;
551
551
  }
552
552
 
553
553
  declare class ControllerPenStrokeDrawingClass extends ControllerClass {
554
- _isUsing: boolean;
555
- currentSegments: PenStrokeSegment[];
554
+ _isUsing: Promise<boolean>;
555
+ currentSegments: Promise<PenStrokeSegment>[];
556
556
  isDrawingLine;
557
- currentStrokeWidth: number;
558
- constructor(project: Project);
557
+ currentStrokeWidth: Promise<number>;
558
+ constructor(project: Project | { _: "Project" | string });
559
559
  mousedown;
560
560
  mousemove;
561
561
  mouseup;
562
- releaseMouseAndClear();
563
- mousewheel: (event: WheelEvent) => void;
564
- getCurrentStrokeColor();
565
- changeCurrentStrokeColorAlpha(dAlpha: number);
562
+ releaseMouseAndClear(): Promise<void>;
563
+ mousewheel: Promise<(event: WheelEvent) => void>;
564
+ getCurrentStrokeColor(): Promise<void>;
565
+ changeCurrentStrokeColorAlpha(dAlpha: number): Promise<void>;
566
566
  }
567
567
 
568
568
  declare class ControllerRectangleSelectClass extends ControllerClass {
569
- _isUsing: boolean;
570
- selectingRectangle: Rectangle | null;
571
- get isUsing(): any;
572
- shutDown();
573
- mouseMoveOutWindowForcedShutdown(mouseLocation: Vector);
574
- mousedown: (event: MouseEvent) => void;
575
- mousemove: (event: MouseEvent) => void;
569
+ _isUsing: Promise<boolean>;
570
+ selectingRectangle: Promise<Rectangle | null>;
571
+ get isUsing(): Promise<any>;
572
+ shutDown(): Promise<void>;
573
+ mouseMoveOutWindowForcedShutdown(mouseLocation: Vector | { _: "Vector" | string }): Promise<void>;
574
+ mousedown: Promise<(event: MouseEvent) => void>;
575
+ mousemove: Promise<(event: MouseEvent) => void>;
576
576
  isSelectDirectionRight;
577
- getSelectMode(): "contain" | "intersect";
577
+ getSelectMode(): Promise<"contain" | "intersect">;
578
578
  mouseup;
579
579
  }
580
580
 
581
581
  declare class ControllerSectionEditClass extends ControllerClass {
582
- constructor(project: Project);
582
+ constructor(project: Project | { _: "Project" | string });
583
583
  mouseDoubleClick;
584
584
  mousemove;
585
585
  keydown;
586
- editSectionTitle(section: Section);
586
+ editSectionTitle(section: Section | { _: "Section" | string }): Promise<void>;
587
587
  }
588
588
 
589
589
  declare class ControllerUtils {
590
- autoComplete: AutoCompleteManager;
591
- constructor(project: Project);
592
- editTextNode(clickedNode: TextNode, selectAll = true);
593
- editNodeDetailsByKeyboard();
594
- editNodeDetails(clickedNode: Entity);
595
- addTextNodeByLocation(location: Vector, selectCurrent: boolean = false, autoEdit: boolean = false);
596
- createConnectPoint(location: Vector);
597
- addTextNodeFromCurrentSelectedNode(direction: Direction, selectCurrent = false);
598
- textNodeInEditModeByUUID(uuid: string);
599
- getClickedStageObject(clickedLocation: Vector);
600
- isClickedResizeRect(clickedLocation: Vector): boolean;
601
- selectedEntityNormalizing();
590
+ autoComplete: Promise<AutoCompleteManager>;
591
+ constructor(project: Project | { _: "Project" | string });
592
+ editTextNode(clickedNode: TextNode, selectAll = true): Promise<void>;
593
+ editNodeDetailsByKeyboard(): Promise<void>;
594
+ editNodeDetails(clickedNode: Entity): Promise<void>;
595
+ addTextNodeByLocation(location: Vector | { _: "Vector" | string }, selectCurrent: boolean = false, autoEdit: boolean = false): Promise<void>;
596
+ createConnectPoint(location: Vector | { _: "Vector" | string }): Promise<void>;
597
+ addTextNodeFromCurrentSelectedNode(direction: Direction, selectCurrent = false): Promise<void>;
598
+ textNodeInEditModeByUUID(uuid: string): Promise<void>;
599
+ getClickedStageObject(clickedLocation: Vector | { _: "Vector" | string }): Promise<void>;
600
+ isClickedResizeRect(clickedLocation: Vector | { _: "Vector" | string }): Promise<boolean>;
601
+ selectedEntityNormalizing(): Promise<void>;
602
602
  }
603
603
 
604
604
  declare class CopyEngine {
605
- copyEngineImage: CopyEngineImage;
606
- copyEngineText: CopyEngineText;
607
- constructor(project: Project);
608
- copy();
609
- paste();
610
- virtualClipboardPaste();
611
- cut();
612
- readSystemClipboardAndPaste();
605
+ copyEngineImage: Promise<CopyEngineImage>;
606
+ copyEngineText: Promise<CopyEngineText>;
607
+ constructor(project: Project | { _: "Project" | string });
608
+ copy(): Promise<void>;
609
+ paste(): Promise<void>;
610
+ virtualClipboardPaste(): Promise<void>;
611
+ cut(): Promise<void>;
612
+ readSystemClipboardAndPaste(): Promise<void>;
613
613
  }
614
614
 
615
615
  declare class CopyEngineImage {
616
- constructor(project: Project);
617
- processClipboardImage();
618
- processImageStandard();
619
- copyEnginePasteImage(item: Blob);
616
+ constructor(project: Project | { _: "Project" | string });
617
+ processClipboardImage(): Promise<void>;
618
+ processImageStandard(): Promise<void>;
619
+ copyEnginePasteImage(item: Blob): Promise<void>;
620
620
  debugImageData(imageData: any): void;
621
- fixImageData(data: Uint8ClampedArray): Uint8ClampedArray;
622
- processImageWindowsCompat();
623
- ensureImageDataFormat(data: any, width: number, height: number): Uint8ClampedArray;
621
+ fixImageData(data: Uint8ClampedArray): Promise<Uint8ClampedArray>;
622
+ processImageWindowsCompat(): Promise<void>;
623
+ ensureImageDataFormat(data: any, width: number, height: number): Promise<Uint8ClampedArray>;
624
624
  validateCanvasContent(ctx: CanvasRenderingContext2D, width: number, height: number): void;
625
625
  createBlobFromCanvas(canvas: HTMLCanvasElement): Promise<Blob>;
626
626
  }
627
627
 
628
628
  declare class CopyEngineText {
629
- constructor(project: Project);
630
- copyEnginePastePlainText(item: string);
629
+ constructor(project: Project | { _: "Project" | string });
630
+ copyEnginePastePlainText(item: string): Promise<void>;
631
631
  }
632
632
 
633
633
  declare class CubicCatmullRomSplineEdge extends Edge {
634
- uuid: string;
635
- text: string;
636
- _source: ConnectableEntity;
637
- _target: ConnectableEntity;
638
- color: Color;
634
+ uuid: Promise<string>;
635
+ text: Promise<string>;
636
+ _source: Promise<ConnectableEntity>;
637
+ _target: Promise<ConnectableEntity>;
638
+ color: Promise<Color>;
639
639
  alpha;
640
640
  tension;
641
- controlPoints: Vector[];
642
- getControlPoints(): Vector[];
643
- addControlPoint();
644
- _collisionBox: CollisionBox;
645
- get collisionBox(): CollisionBox;
646
- fromTwoEntity(project: Project, source: ConnectableEntity, target: ConnectableEntity): CubicCatmullRomSplineEdge;
647
- constructor(project: Project, {
641
+ controlPoints: Promise<Vector>[];
642
+ getControlPoints(): Promise<Vector>[];
643
+ addControlPoint(): Promise<void>;
644
+ _collisionBox: Promise<CollisionBox>;
645
+ get collisionBox(): Promise<CollisionBox>;
646
+ fromTwoEntity(project: Project | { _: "Project" | string }, source: ConnectableEntity | { _: "ConnectableEntity" | string }, target: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<CubicCatmullRomSplineEdge>;
647
+ constructor(project: Project | { _: "Project" | string }, {
648
648
  uuid,
649
649
  source,
650
650
  target,
@@ -656,10 +656,10 @@ declare class CubicCatmullRomSplineEdge extends Edge {
656
656
  sourceRectRate,
657
657
  targetRectRate,
658
658
  }: Serialized.CubicCatmullRomSplineEdge, unknown = false);
659
- getShape(): CubicCatmullRomSpline;
660
- get textRectangle(): Rectangle;
661
- autoUpdateControlPoints();
662
- getArrowHead(): { location: Vector; direction: Vector };
659
+ getShape(): Promise<CubicCatmullRomSpline>;
660
+ get textRectangle(): Promise<Rectangle>;
661
+ autoUpdateControlPoints(): Promise<void>;
662
+ getArrowHead(): Promise<{ location: Vector; direction: Vector }>;
663
663
  adjustSizeByText(): void;
664
664
  }
665
665
 
@@ -698,43 +698,43 @@ declare enum CursorNameEnum {
698
698
  }
699
699
 
700
700
  declare class CurveRenderer {
701
- constructor(project: Project);
702
- renderSolidLine(start: Vector, end: Vector, color: Color, width: number): void;
703
- renderSolidLineMultiple(locations: Vector[], color: Color, width: number): void;
704
- renderPenStroke(stroke: PenStrokeSegment[], color: Color): void;
705
- renderSolidLineMultipleSmoothly(locations: Vector[], color: Color, width: number): void;
706
- smoothPoints(points: Vector[], tension = 0.5);
707
- renderSolidLineMultipleWithWidth(locations: Vector[], color: Color, widthList: number[]): void;
708
- renderSolidLineMultipleWithShadow(locations: Vector[], color: Color, width: number, shadowColor: Color, shadowBlur: number): void;
709
- renderDashedLine(start: Vector, end: Vector, color: Color, width: number, dashLength: number): void;
710
- renderDoubleLine(start: Vector, end: Vector, color: Color, width: number, gap: number): void;
711
- renderBezierCurve(curve: CubicBezierCurve, color: Color, width: number): void;
712
- renderDashedBezierCurve(curve: CubicBezierCurve, color: Color, width: number, dashLength: number): void;
713
- renderDoubleBezierCurve(curve: CubicBezierCurve, color: Color, width: number, gap: number): void;
714
- renderSymmetryCurve(curve: SymmetryCurve, color: Color, width: number): void;
715
- renderGradientLine(start: Vector, end: Vector, startColor: Color, endColor: Color, width: number): void;
716
- renderGradientBezierCurve(curve: CubicBezierCurve, startColor: Color, endColor: Color, width: number): void;
701
+ constructor(project: Project | { _: "Project" | string });
702
+ renderSolidLine(start: Vector | { _: "Vector" | string }, end: Vector | { _: "Vector" | string }, color: Color | { _: "Color" | string }, width: number): void;
703
+ renderSolidLineMultiple(locations: Vector[], color: Color | { _: "Color" | string }, width: number): void;
704
+ renderPenStroke(stroke: PenStrokeSegment[], color: Color | { _: "Color" | string }): void;
705
+ renderSolidLineMultipleSmoothly(locations: Vector[], color: Color | { _: "Color" | string }, width: number): void;
706
+ smoothPoints(points: Vector[], tension = 0.5): Promise<void>;
707
+ renderSolidLineMultipleWithWidth(locations: Vector[], color: Color | { _: "Color" | string }, widthList: number[]): void;
708
+ renderSolidLineMultipleWithShadow(locations: Vector[], color: Color | { _: "Color" | string }, width: number, shadowColor: Color | { _: "Color" | string }, shadowBlur: number): void;
709
+ renderDashedLine(start: Vector | { _: "Vector" | string }, end: Vector | { _: "Vector" | string }, color: Color | { _: "Color" | string }, width: number, dashLength: number): void;
710
+ renderDoubleLine(start: Vector | { _: "Vector" | string }, end: Vector | { _: "Vector" | string }, color: Color | { _: "Color" | string }, width: number, gap: number): void;
711
+ renderBezierCurve(curve: CubicBezierCurve | { _: "CubicBezierCurve" | string }, color: Color | { _: "Color" | string }, width: number): void;
712
+ renderDashedBezierCurve(curve: CubicBezierCurve | { _: "CubicBezierCurve" | string }, color: Color | { _: "Color" | string }, width: number, dashLength: number): void;
713
+ renderDoubleBezierCurve(curve: CubicBezierCurve | { _: "CubicBezierCurve" | string }, color: Color | { _: "Color" | string }, width: number, gap: number): void;
714
+ renderSymmetryCurve(curve: SymmetryCurve | { _: "SymmetryCurve" | string }, color: Color | { _: "Color" | string }, width: number): void;
715
+ renderGradientLine(start: Vector | { _: "Vector" | string }, end: Vector | { _: "Vector" | string }, startColor: Color | { _: "Color" | string }, endColor: Color | { _: "Color" | string }, width: number): void;
716
+ renderGradientBezierCurve(curve: CubicBezierCurve | { _: "CubicBezierCurve" | string }, startColor: Color | { _: "Color" | string }, endColor: Color | { _: "Color" | string }, width: number): void;
717
717
  }
718
718
 
719
719
  declare class DeleteManager {
720
720
  deleteHandlers;
721
- registerHandler<T extends StageObject>(constructor: Constructor<T>, handler: DeleteHandler<T>);
722
- constructor(project: Project);
723
- deleteEntities(deleteNodes: Entity[]);
724
- findDeleteHandler(object: StageObject);
725
- deleteSvgNode(entity: SvgNode);
726
- deleteLatexNode(entity: LatexNode);
727
- deleteReferenceBlockNode(entity: ReferenceBlockNode);
728
- deleteExtensionEntity(entity: ExtensionEntity);
729
- deletePenStroke(penStroke: PenStroke);
730
- deleteSection(entity: Section);
731
- deleteImageNode(entity: ImageNode);
732
- deleteUrlNode(entity: UrlNode);
733
- deleteConnectPoint(entity: ConnectPoint);
734
- deleteTextNode(entity: TextNode);
735
- deleteEntityAfterClearAssociation(entity: ConnectableEntity);
736
- deleteEdge(deleteEdge: Edge): boolean;
737
- deleteMultiTargetUndirectedEdge(edge: MultiTargetUndirectedEdge);
721
+ registerHandler<T extends StageObject>(constructor: Constructor<T>, handler: DeleteHandler<T>): Promise<void>;
722
+ constructor(project: Project | { _: "Project" | string });
723
+ deleteEntities(deleteNodes: Entity[]): Promise<void>;
724
+ findDeleteHandler(object: StageObject | { _: "StageObject" | string }): Promise<void>;
725
+ deleteSvgNode(entity: SvgNode | { _: "SvgNode" | string }): Promise<void>;
726
+ deleteLatexNode(entity: LatexNode | { _: "LatexNode" | string }): Promise<void>;
727
+ deleteReferenceBlockNode(entity: ReferenceBlockNode): Promise<void>;
728
+ deleteExtensionEntity(entity: ExtensionEntity): Promise<void>;
729
+ deletePenStroke(penStroke: PenStroke | { _: "PenStroke" | string }): Promise<void>;
730
+ deleteSection(entity: Section | { _: "Section" | string }): Promise<void>;
731
+ deleteImageNode(entity: ImageNode | { _: "ImageNode" | string }): Promise<void>;
732
+ deleteUrlNode(entity: UrlNode | { _: "UrlNode" | string }): Promise<void>;
733
+ deleteConnectPoint(entity: ConnectPoint | { _: "ConnectPoint" | string }): Promise<void>;
734
+ deleteTextNode(entity: TextNode | { _: "TextNode" | string }): Promise<void>;
735
+ deleteEntityAfterClearAssociation(entity: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<void>;
736
+ deleteEdge(deleteEdge: Edge | { _: "Edge" | string }): Promise<boolean>;
737
+ deleteMultiTargetUndirectedEdge(edge: MultiTargetUndirectedEdge | { _: "MultiTargetUndirectedEdge" | string }): Promise<void>;
738
738
  }
739
739
 
740
740
  declare function Dialog({ ...props }: React.ComponentProps<typeof DialogPrimitive.Root>);
@@ -757,173 +757,192 @@ declare enum Direction {
757
757
  }
758
758
 
759
759
  declare class DrawingControllerRenderer {
760
- constructor(project: Project);
761
- renderTempDrawing();
762
- renderTrace(currentStrokeColor: Color);
763
- renderMouse(currentStrokeColor: Color);
764
- renderAdjusting(currentStrokeColor: Color);
765
- renderAxisMouse();
760
+ constructor(project: Project | { _: "Project" | string });
761
+ renderTempDrawing(): Promise<void>;
762
+ renderTrace(currentStrokeColor: Color | { _: "Color" | string }): Promise<void>;
763
+ renderMouse(currentStrokeColor: Color | { _: "Color" | string }): Promise<void>;
764
+ renderAdjusting(currentStrokeColor: Color | { _: "Color" | string }): Promise<void>;
765
+ renderAxisMouse(): Promise<void>;
766
766
  diffAngle;
767
- rotateUpAngle();
768
- rotateDownAngle();
769
- renderAngleMouse(mouseLocation: Vector);
770
- renderLine(lineStart: Vector, lineEnd: Vector);
767
+ rotateUpAngle(): Promise<void>;
768
+ rotateDownAngle(): Promise<void>;
769
+ renderAngleMouse(mouseLocation: Vector | { _: "Vector" | string }): Promise<void>;
770
+ renderLine(lineStart: Vector | { _: "Vector" | string }, lineEnd: Vector | { _: "Vector" | string }): Promise<void>;
771
771
  }
772
772
 
773
773
  declare class Edge extends ConnectableAssociation {
774
- uuid: string;
775
- text: string;
776
- collisionBox: CollisionBox;
777
- get isHiddenBySectionCollapse(): boolean;
778
- _isSelected: boolean;
779
- get isSelected(): boolean;
774
+ uuid: Promise<string>;
775
+ text: Promise<string>;
776
+ collisionBox: Promise<CollisionBox>;
777
+ get isHiddenBySectionCollapse(): Promise<boolean>;
778
+ _isSelected: Promise<boolean>;
779
+ get isSelected(): Promise<boolean>;
780
780
  set isSelected(value: boolean);
781
- get textRectangle(): Rectangle;
782
- get bodyLine(): Line;
783
- get sourceLocation(): Vector;
784
- get targetLocation(): Vector;
785
- targetRectangleRate: Vector;
786
- sourceRectangleRate: Vector;
787
- getCenterLine(source: ConnectableEntity, target: ConnectableEntity): Line;
788
- getNormalVectorByRate(rate: Vector): Vector | null;
789
- getExactEdgePositionByRate(rect: Rectangle, rate: Vector): Vector | null;
781
+ get textRectangle(): Promise<Rectangle>;
782
+ get bodyLine(): Promise<Line>;
783
+ get sourceLocation(): Promise<Vector>;
784
+ get targetLocation(): Promise<Vector>;
785
+ targetRectangleRate: Promise<Vector>;
786
+ sourceRectangleRate: Promise<Vector>;
787
+ getCenterLine(source: ConnectableEntity | { _: "ConnectableEntity" | string }, target: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<Line>;
788
+ getNormalVectorByRate(rate: Vector | { _: "Vector" | string }): Promise<Vector | null>;
789
+ getExactEdgePositionByRate(rect: Rectangle | { _: "Rectangle" | string }, rate: Vector | { _: "Vector" | string }): Promise<Vector | null>;
790
790
  adjustSizeByText(): void;
791
- rename(text: string);
792
- isIntersectsWithRectangle(rectangle: Rectangle): boolean;
793
- isIntersectsWithLocation(location: Vector): boolean;
794
- isIntersectsWithLine(line: Line): boolean;
795
- isLeftToRight(): boolean;
796
- isRightToLeft(): boolean;
797
- isTopToBottom(): boolean;
798
- isBottomToTop(): boolean;
799
- isUnknownDirection(): boolean;
791
+ rename(text: string): Promise<void>;
792
+ isIntersectsWithRectangle(rectangle: Rectangle | { _: "Rectangle" | string }): Promise<boolean>;
793
+ isIntersectsWithLocation(location: Vector | { _: "Vector" | string }): Promise<boolean>;
794
+ isIntersectsWithLine(line: Line | { _: "Line" | string }): Promise<boolean>;
795
+ isLeftToRight(): Promise<boolean>;
796
+ isRightToLeft(): Promise<boolean>;
797
+ isTopToBottom(): Promise<boolean>;
798
+ isBottomToTop(): Promise<boolean>;
799
+ isUnknownDirection(): Promise<boolean>;
800
800
  }
801
801
 
802
802
  declare class EdgeRenderer {
803
- currentRenderer: EdgeRendererClass;
804
- constructor(project: Project);
805
- checkRendererBySettings(lineStyle: Settings["lineStyle"]);
806
- updateRenderer(style: Settings["lineStyle"]);
807
- renderLineEdge(edge: LineEdge);
808
- renderCrEdge(edge: CubicCatmullRomSplineEdge);
809
- getMinNonCollapseParentSection(innerEntity: ConnectableEntity): Section;
810
- getEdgeView(edge: LineEdge): LineEdge;
811
- getEdgeSvg(edge: LineEdge): React.ReactNode;
812
- renderVirtualEdge(startNode: ConnectableEntity, mouseLocation: Vector, sourceRectangleRate?: Vector);
813
- renderVirtualConfirmedEdge(startNode: ConnectableEntity, endNode: ConnectableEntity, sourceRectangleRate?: Vector, targetRectangleRate?: Vector);
814
- getCuttingEffects(edge: Edge);
815
- getConnectedEffects(startNode: ConnectableEntity, toNode: ConnectableEntity, sourceRectangleRate?: Vector, targetRectangleRate?: Vector);
816
- renderArrowHead(endPoint: Vector, direction: Vector, size: number, color: Color);
817
- generateArrowHeadSvg(endPoint: Vector, direction: Vector, size: number, edgeColor: Color): React.ReactNode;
803
+ currentRenderer: Promise<EdgeRendererClass>;
804
+ constructor(project: Project | { _: "Project" | string });
805
+ checkRendererBySettings(lineStyle: Settings["lineStyle"]): Promise<void>;
806
+ updateRenderer(style: Settings["lineStyle"]): Promise<void>;
807
+ renderLineEdge(edge: LineEdge | { _: "LineEdge" | string }): Promise<void>;
808
+ renderCrEdge(edge: CubicCatmullRomSplineEdge | { _: "CubicCatmullRomSplineEdge" | string }): Promise<void>;
809
+ getMinNonCollapseParentSection(innerEntity: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<Section>;
810
+ getEdgeView(edge: LineEdge | { _: "LineEdge" | string }): Promise<LineEdge>;
811
+ getEdgeSvg(edge: LineEdge | { _: "LineEdge" | string }): Promise<React.ReactNode>;
812
+ renderVirtualEdge(startNode: ConnectableEntity | { _: "ConnectableEntity" | string }, mouseLocation: Vector | { _: "Vector" | string }, sourceRectangleRate?: Vector | { _: "Vector" | string }): Promise<void>;
813
+ renderVirtualConfirmedEdge(startNode: ConnectableEntity | { _: "ConnectableEntity" | string }, endNode: ConnectableEntity | { _: "ConnectableEntity" | string }, sourceRectangleRate?: Vector | { _: "Vector" | string }, targetRectangleRate?: Vector | { _: "Vector" | string }): Promise<void>;
814
+ getCuttingEffects(edge: Edge | { _: "Edge" | string }): Promise<void>;
815
+ getConnectedEffects(startNode: ConnectableEntity | { _: "ConnectableEntity" | string }, toNode: ConnectableEntity | { _: "ConnectableEntity" | string }, sourceRectangleRate?: Vector | { _: "Vector" | string }, targetRectangleRate?: Vector | { _: "Vector" | string }): Promise<void>;
816
+ renderArrowHead(endPoint: Vector | { _: "Vector" | string }, direction: Vector | { _: "Vector" | string }, size: number, color: Color | { _: "Color" | string }): Promise<void>;
817
+ generateArrowHeadSvg(endPoint: Vector | { _: "Vector" | string }, direction: Vector | { _: "Vector" | string }, size: number, edgeColor: Color | { _: "Color" | string }): Promise<React.ReactNode>;
818
818
  }
819
819
 
820
820
  declare class EdgeRendererClass {
821
821
  constructor();
822
- isCycleState(edge: LineEdge): boolean;
823
- isNormalState(edge: LineEdge): boolean;
824
- renderNormalState(edge: LineEdge): void;
825
- renderShiftingState(edge: LineEdge): void;
826
- renderCycleState(edge: LineEdge): void;
827
- getNormalStageSvg(edge: LineEdge): React.ReactNode;
828
- getShiftingStageSvg(edge: LineEdge): React.ReactNode;
829
- getCycleStageSvg(edge: LineEdge): React.ReactNode;
830
- renderVirtualEdge(startNode: ConnectableEntity, mouseLocation: Vector, sourceRectangleRate?: Vector): void;
831
- renderVirtualConfirmedEdge(startNode: ConnectableEntity, endNode: ConnectableEntity, sourceRectangleRate?: Vector, targetRectangleRate?: Vector): void;
832
- getCuttingEffects(edge: Edge): Effect[];
833
- getConnectedEffects(startNode: ConnectableEntity, toNode: ConnectableEntity, sourceRectangleRate?: Vector, targetRectangleRate?: Vector): Effect[];
822
+ isCycleState(edge: LineEdge | { _: "LineEdge" | string }): Promise<boolean>;
823
+ isNormalState(edge: LineEdge | { _: "LineEdge" | string }): Promise<boolean>;
824
+ renderNormalState(edge: LineEdge | { _: "LineEdge" | string }): void;
825
+ renderShiftingState(edge: LineEdge | { _: "LineEdge" | string }): void;
826
+ renderCycleState(edge: LineEdge | { _: "LineEdge" | string }): void;
827
+ getNormalStageSvg(edge: LineEdge | { _: "LineEdge" | string }): Promise<React.ReactNode>;
828
+ getShiftingStageSvg(edge: LineEdge | { _: "LineEdge" | string }): Promise<React.ReactNode>;
829
+ getCycleStageSvg(edge: LineEdge | { _: "LineEdge" | string }): Promise<React.ReactNode>;
830
+ renderVirtualEdge(startNode: ConnectableEntity | { _: "ConnectableEntity" | string }, mouseLocation: Vector | { _: "Vector" | string }, sourceRectangleRate?: Vector | { _: "Vector" | string }): void;
831
+ renderVirtualConfirmedEdge(startNode: ConnectableEntity | { _: "ConnectableEntity" | string }, endNode: ConnectableEntity | { _: "ConnectableEntity" | string }, sourceRectangleRate?: Vector | { _: "Vector" | string }, targetRectangleRate?: Vector | { _: "Vector" | string }): void;
832
+ getCuttingEffects(edge: Edge | { _: "Edge" | string }): Promise<Effect>[];
833
+ getConnectedEffects(startNode: ConnectableEntity | { _: "ConnectableEntity" | string }, toNode: ConnectableEntity | { _: "ConnectableEntity" | string }, sourceRectangleRate?: Vector | { _: "Vector" | string }, targetRectangleRate?: Vector | { _: "Vector" | string }): Promise<Effect>[];
834
834
  }
835
835
 
836
836
  declare class Effect {
837
- constructor(timeProgress: ProgressNumber, delay: number = 0);
838
- subEffects: Effect[];
839
- tick(project: Project): void;
840
- render(project: Project): void;
837
+ constructor(timeProgress: ProgressNumber | { _: "ProgressNumber" | string }, delay: number = 0);
838
+ subEffects: Promise<Effect>[];
839
+ tick(project: Project | { _: "Project" | string }): void;
840
+ render(project: Project | { _: "Project" | string }): void;
841
841
  }
842
842
 
843
843
  declare class Effects {
844
- constructor(project: Project);
845
- effects: Effect[];
846
- addEffect(effect: Effect);
847
- get effectsCount(): any;
848
- addEffects(effects: Effect[]);
849
- tick();
844
+ constructor(project: Project | { _: "Project" | string });
845
+ effects: Promise<Effect>[];
846
+ addEffect(effect: Effect): Promise<void>;
847
+ get effectsCount(): Promise<any>;
848
+ addEffects(effects: Effect[]): Promise<void>;
849
+ tick(): Promise<void>;
850
850
  }
851
851
 
852
852
  declare class Entity extends StageObject {
853
- move(delta: Vector): void;
853
+ move(delta: Vector | { _: "Vector" | string }): void;
854
854
  isAlignExcluded;
855
- moveTo(location: Vector): void;
856
- details: Value;
857
- isMouseHover: boolean;
858
- detailsButtonRectangle(): Rectangle;
859
- isMouseInDetailsButton(mouseWorldLocation: Vector): boolean;
860
- referenceButtonCircle(): Circle;
861
- isMouseInReferenceButton(mouseWorldLocation: Vector): boolean;
862
- updateFatherSectionByMove();
863
- updateOtherEntityLocationByMove();
864
- collideWithOtherEntity(other: Entity);
865
- isHiddenBySectionCollapse: boolean;
855
+ moveTo(location: Vector | { _: "Vector" | string }): void;
856
+ details: Promise<Value>;
857
+ isMouseHover: Promise<boolean>;
858
+ detailsButtonRectangle(): Promise<Rectangle>;
859
+ isMouseInDetailsButton(mouseWorldLocation: Vector | { _: "Vector" | string }): Promise<boolean>;
860
+ referenceButtonCircle(): Promise<Circle>;
861
+ isMouseInReferenceButton(mouseWorldLocation: Vector | { _: "Vector" | string }): Promise<boolean>;
862
+ updateFatherSectionByMove(): Promise<void>;
863
+ updateOtherEntityLocationByMove(): Promise<void>;
864
+ collideWithOtherEntity(other: Entity): Promise<void>;
865
+ isHiddenBySectionCollapse: Promise<boolean>;
866
866
  detailsManager;
867
867
  }
868
868
 
869
869
  declare class EntityDetailsButtonRenderer {
870
- constructor(project: Project);
871
- render(entity: Entity);
870
+ constructor(project: Project | { _: "Project" | string });
871
+ render(entity: Entity | { _: "Entity" | string }): Promise<void>;
872
872
  }
873
873
 
874
874
  declare class EntityMoveManager {
875
- constructor(project: Project);
876
- moveAccelerateCommander: Vector;
877
- moveSpeed: Vector;
875
+ constructor(project: Project | { _: "Project" | string });
876
+ moveAccelerateCommander: Promise<Vector>;
877
+ moveSpeed: Promise<Vector>;
878
878
  frictionExponent;
879
- tick();
880
- continuousMoveKeyPress(direction: Vector);
881
- continuousMoveKeyRelease(direction: Vector);
882
- stopImmediately();
883
- canMoveEntity(entity: Entity): boolean;
884
- moveEntityUtils(entity: Entity, delta: Vector, isAutoAdjustSection: boolean = true);
885
- jumpMoveEntityUtils(entity: Entity, delta: Vector);
886
- moveEntityToUtils(entity: Entity, location: Vector);
887
- moveSelectedEntities(delta: Vector, isAutoAdjustSection: boolean = true);
888
- jumpMoveSelectedConnectableEntities(delta: Vector);
889
- moveEntitiesWithChildren(delta: Vector, skipDashed = true);
890
- moveWithChildren(node: ConnectableEntity, delta: Vector, skipDashed = false);
879
+ tick(): Promise<void>;
880
+ continuousMoveKeyPress(direction: Vector | { _: "Vector" | string }): Promise<void>;
881
+ continuousMoveKeyRelease(direction: Vector | { _: "Vector" | string }): Promise<void>;
882
+ stopImmediately(): Promise<void>;
883
+ canMoveEntity(entity: Entity | { _: "Entity" | string }): Promise<boolean>;
884
+ moveEntityUtils(entity: Entity | { _: "Entity" | string }, delta: Vector | { _: "Vector" | string }, isAutoAdjustSection: boolean = true): Promise<void>;
885
+ jumpMoveEntityUtils(entity: Entity | { _: "Entity" | string }, delta: Vector | { _: "Vector" | string }): Promise<void>;
886
+ moveEntityToUtils(entity: Entity | { _: "Entity" | string }, location: Vector | { _: "Vector" | string }): Promise<void>;
887
+ moveSelectedEntities(delta: Vector | { _: "Vector" | string }, isAutoAdjustSection: boolean = true): Promise<void>;
888
+ jumpMoveSelectedConnectableEntities(delta: Vector | { _: "Vector" | string }): Promise<void>;
889
+ moveEntitiesWithChildren(delta: Vector | { _: "Vector" | string }, skipDashed = true): Promise<void>;
890
+ moveWithChildren(node: ConnectableEntity | { _: "ConnectableEntity" | string }, delta: Vector | { _: "Vector" | string }, skipDashed = false): Promise<void>;
891
891
  }
892
892
 
893
893
  declare class EntityRenderer {
894
- sectionSortedZIndex: Section[];
895
- extensionEntityRenderer: ExtensionEntityRenderer;
896
- constructor(project: Project);
897
- sortSectionsByZIndex();
894
+ sectionSortedZIndex: Promise<Section>[];
895
+ extensionEntityRenderer: Promise<ExtensionEntityRenderer>;
896
+ constructor(project: Project | { _: "Project" | string });
897
+ sortSectionsByZIndex(): Promise<void>;
898
898
  tickNumber;
899
- renderAllSectionsBackground(viewRectangle: Rectangle);
900
- renderAllSectionsBigTitle(viewRectangle: Rectangle);
901
- shouldSkipEntity(entity: Entity, viewRectangle: Rectangle): boolean;
902
- isBackgroundImageNode(entity: Entity): boolean;
903
- renderAllEntities(viewRectangle: Rectangle);
904
- renderEntity(entity: Entity);
905
- renderEntityDebug(entity: Entity);
906
- renderConnectPoint(connectPoint: ConnectPoint);
907
- renderImageNode(imageNode: ImageNode);
908
- renderPenStroke(penStroke: PenStroke);
909
- renderEntityDetails(entity: Entity);
910
- _renderEntityDetails(entity: Entity, limitLiens: number);
911
- renderEntityTagShap(entity: Entity);
899
+ renderAllSectionsBackground(viewRectangle: Rectangle | { _: "Rectangle" | string }): Promise<void>;
900
+ renderAllSectionsBigTitle(viewRectangle: Rectangle | { _: "Rectangle" | string }): Promise<void>;
901
+ shouldSkipEntity(entity: Entity | { _: "Entity" | string }, viewRectangle: Rectangle | { _: "Rectangle" | string }): Promise<boolean>;
902
+ isBackgroundImageNode(entity: Entity | { _: "Entity" | string }): Promise<boolean>;
903
+ renderAllEntities(viewRectangle: Rectangle | { _: "Rectangle" | string }): Promise<void>;
904
+ renderEntity(entity: Entity | { _: "Entity" | string }): Promise<void>;
905
+ renderEntityDebug(entity: Entity | { _: "Entity" | string }): Promise<void>;
906
+ renderConnectPoint(connectPoint: ConnectPoint | { _: "ConnectPoint" | string }): Promise<void>;
907
+ renderImageNode(imageNode: ImageNode | { _: "ImageNode" | string }): Promise<void>;
908
+ renderPenStroke(penStroke: PenStroke | { _: "PenStroke" | string }): Promise<void>;
909
+ renderEntityDetails(entity: Entity | { _: "Entity" | string }): Promise<void>;
910
+ _renderEntityDetails(entity: Entity | { _: "Entity" | string }, limitLiens: number): Promise<void>;
911
+ renderEntityTagShap(entity: Entity | { _: "Entity" | string }): Promise<void>;
912
+ }
913
+
914
+ declare class Extension extends Tab {
915
+ metadata: Promise<PrgMetadata>;
916
+ readmeContent: Promise<string>;
917
+ code: Promise<string>;
918
+ iconBlobUrl: Promise<string | null>;
919
+ iconRawData: Promise<Uint8Array | null>;
920
+ iconFileName: Promise<string | null>;
921
+ stage: Promise<any>[];
922
+ _uri: Promise<URI>;
923
+ _component: Promise<React.ComponentType | null>;
924
+ constructor(uri: URI);
925
+ get uri(): Promise<any>;
926
+ init(): Promise<void>;
927
+ getComponent(): Promise<React.ComponentType>;
928
+ render(): Promise<React.ReactNode>;
929
+ get icon(): Promise<any>;
930
+ get title(): Promise<any>;
912
931
  }
913
932
 
914
933
  declare class ExtensionEntity extends ConnectableEntity {
915
- get geometryCenter(): Vector;
916
- uuid: string;
934
+ get geometryCenter(): Promise<Vector>;
935
+ uuid: Promise<string>;
917
936
  extensionId;
918
937
  typeName;
919
938
  customData: any;
920
- collisionBox: CollisionBox;
939
+ collisionBox: Promise<CollisionBox>;
921
940
  isHiddenBySectionCollapse;
922
- _bitmapCache: ImageBitmap | null;
941
+ _bitmapCache: Promise<ImageBitmap | null>;
923
942
  _isDirty;
924
943
  _isRendering;
925
944
  _renderFailed;
926
- constructor(project: Project, {
945
+ constructor(project: Project | { _: "Project" | string }, {
927
946
  uuid = crypto.randomUUID(),
928
947
  extensionId = "",
929
948
  typeName = "",
@@ -936,28 +955,28 @@ declare class ExtensionEntity extends ConnectableEntity {
936
955
  customData?: any;
937
956
  collisionBox?: CollisionBox;
938
957
  } = {});
939
- get rectangle(): Rectangle;
940
- get location(): Vector;
958
+ get rectangle(): Promise<Rectangle>;
959
+ get location(): Promise<Vector>;
941
960
  set location(v: Vector);
942
- move(delta: Vector): void;
943
- moveTo(location: Vector): void;
944
- markDirty();
945
- setCustomData(data: any);
961
+ move(delta: Vector | { _: "Vector" | string }): void;
962
+ moveTo(location: Vector | { _: "Vector" | string }): void;
963
+ markDirty(): Promise<void>;
964
+ setCustomData(data: any): Promise<void>;
946
965
  }
947
966
 
948
967
  declare interface ExtensionEntityConfig {
949
968
  initialData: any;
950
- collisionBox: CollisionBox;
969
+ collisionBox: Promise<CollisionBox>;
951
970
  }
952
971
 
953
972
  declare class ExtensionEntityRenderer {
954
- constructor(project: Project);
955
- render(entity: ExtensionEntity);
956
- drawPendingBox(ctx: CanvasRenderingContext2D, x: number, y: number, w: number, h: number);
957
- drawErrorBox(ctx: CanvasRenderingContext2D, x: number, y: number, w: number, h: number, text: string, extensionId: string, color: string);
958
- drawCollisionBox(ctx: CanvasRenderingContext2D, entity: ExtensionEntity, scale: number);
959
- renderSelectionOutline(ctx: CanvasRenderingContext2D, entity: ExtensionEntity, scale: number);
960
- triggerWorkerRender(entity: ExtensionEntity);
973
+ constructor(project: Project | { _: "Project" | string });
974
+ render(entity: ExtensionEntity | { _: "ExtensionEntity" | string }): Promise<void>;
975
+ drawPendingBox(ctx: CanvasRenderingContext2D, x: number, y: number, w: number, h: number): Promise<void>;
976
+ drawErrorBox(ctx: CanvasRenderingContext2D, x: number, y: number, w: number, h: number, text: string, extensionId: string, color: string): Promise<void>;
977
+ drawCollisionBox(ctx: CanvasRenderingContext2D, entity: ExtensionEntity | { _: "ExtensionEntity" | string }, scale: number): Promise<void>;
978
+ renderSelectionOutline(ctx: CanvasRenderingContext2D, entity: ExtensionEntity | { _: "ExtensionEntity" | string }, scale: number): Promise<void>;
979
+ triggerWorkerRender(entity: ExtensionEntity | { _: "ExtensionEntity" | string }): Promise<void>;
961
980
  }
962
981
 
963
982
  declare interface FileSystemProvider {
@@ -971,72 +990,72 @@ declare interface FileSystemProvider {
971
990
  }
972
991
 
973
992
  declare class GenerateFromFolder {
974
- constructor(project: Project);
993
+ constructor(project: Project | { _: "Project" | string });
975
994
  generateFromFolder(folderPath: string): Promise<void>;
976
995
  generateTreeFromFolder(folderPath: string): Promise<void>;
977
- getColorByPath(path: string): Color;
978
- fileExtColorMap: Record<string, string>;
996
+ getColorByPath(path: string): Promise<Color>;
997
+ fileExtColorMap: Promise<Record<string, string>>;
979
998
  }
980
999
 
981
1000
  declare class GraphImporter extends BaseImporter {
982
- constructor(project: Project);
983
- import(text: string, diffLocation: Vector = Vector.getZero()): void;
1001
+ constructor(project: Project | { _: "Project" | string });
1002
+ import(text: string, diffLocation: Vector | { _: "Vector" | string } = Vector.getZero()): void;
984
1003
  }
985
1004
 
986
1005
  declare class GraphMethods {
987
- constructor(project: Project);
988
- isTree(node: ConnectableEntity, skipDashed = false): boolean;
989
- getNodeDisplayName(node: ConnectableEntity): string;
990
- validateTreeStructure(rootNode: ConnectableEntity, skipDashed = false): TreeValidationResult;
991
- nodeChildrenArray(node: ConnectableEntity, skipDashed = false): ConnectableEntity[];
992
- nodeParentArray(node: ConnectableEntity, skipDashed = false): ConnectableEntity[];
993
- edgeChildrenArray(node: ConnectableEntity): Edge[];
994
- edgeParentArray(node: ConnectableEntity): Edge[];
995
- getReversedEdgeDict(skipDashed = false): Record<string, string>;
996
- isCurrentNodeInTreeStructAndNotRoot(node: ConnectableEntity): boolean;
997
- getRoots(node: ConnectableEntity, skipDashed = false): ConnectableEntity[];
998
- isConnected(node: ConnectableEntity, target: ConnectableEntity): boolean;
999
- getSuccessorSet(node: ConnectableEntity, isHaveSelf: boolean = true, skipDashed = false): ConnectableEntity[];
1000
- getOneStepSuccessorSet(node: ConnectableEntity): ConnectableEntity[];
1001
- getEdgesBetween(node1: ConnectableEntity, node2: ConnectableEntity): Edge[];
1002
- getEdgeFromTwoEntity(fromNode: ConnectableEntity, toNode: ConnectableEntity): Edge | null;
1003
- getHyperEdgesByNode(node: ConnectableEntity): MultiTargetUndirectedEdge[];
1004
- getOutgoingEdges(node: ConnectableEntity): Edge[];
1005
- getIncomingEdges(node: ConnectableEntity): Edge[];
1006
- getNodesConnectedByHyperEdges(node: ConnectableEntity): ConnectableEntity[];
1007
- nodeChildrenArrayWithinSet(node: ConnectableEntity, nodeSet: Set<string>): ConnectableEntity[];
1008
- nodeParentArrayWithinSet(node: ConnectableEntity, nodeSet: Set<string>): ConnectableEntity[];
1009
- getTreeRootByNodes(nodes: ConnectableEntity[]): ConnectableEntity | null;
1010
- isTreeByNodes(nodes: ConnectableEntity[]): boolean;
1011
- isDAGByNodes(nodes: ConnectableEntity[]): boolean;
1006
+ constructor(project: Project | { _: "Project" | string });
1007
+ isTree(node: ConnectableEntity | { _: "ConnectableEntity" | string }, skipDashed = false): Promise<boolean>;
1008
+ getNodeDisplayName(node: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<string>;
1009
+ validateTreeStructure(rootNode: ConnectableEntity | { _: "ConnectableEntity" | string }, skipDashed = false): Promise<TreeValidationResult>;
1010
+ nodeChildrenArray(node: ConnectableEntity | { _: "ConnectableEntity" | string }, skipDashed = false): Promise<ConnectableEntity>[];
1011
+ nodeParentArray(node: ConnectableEntity | { _: "ConnectableEntity" | string }, skipDashed = false): Promise<ConnectableEntity>[];
1012
+ edgeChildrenArray(node: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<Edge>[];
1013
+ edgeParentArray(node: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<Edge>[];
1014
+ getReversedEdgeDict(skipDashed = false): Promise<Record<string, string>>;
1015
+ isCurrentNodeInTreeStructAndNotRoot(node: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<boolean>;
1016
+ getRoots(node: ConnectableEntity | { _: "ConnectableEntity" | string }, skipDashed = false): Promise<ConnectableEntity>[];
1017
+ isConnected(node: ConnectableEntity | { _: "ConnectableEntity" | string }, target: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<boolean>;
1018
+ getSuccessorSet(node: ConnectableEntity | { _: "ConnectableEntity" | string }, isHaveSelf: boolean = true, skipDashed = false): Promise<ConnectableEntity>[];
1019
+ getOneStepSuccessorSet(node: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<ConnectableEntity>[];
1020
+ getEdgesBetween(node1: ConnectableEntity | { _: "ConnectableEntity" | string }, node2: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<Edge>[];
1021
+ getEdgeFromTwoEntity(fromNode: ConnectableEntity | { _: "ConnectableEntity" | string }, toNode: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<Edge | null>;
1022
+ getHyperEdgesByNode(node: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<MultiTargetUndirectedEdge>[];
1023
+ getOutgoingEdges(node: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<Edge>[];
1024
+ getIncomingEdges(node: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<Edge>[];
1025
+ getNodesConnectedByHyperEdges(node: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<ConnectableEntity>[];
1026
+ nodeChildrenArrayWithinSet(node: ConnectableEntity | { _: "ConnectableEntity" | string }, nodeSet: Set<string>): Promise<ConnectableEntity>[];
1027
+ nodeParentArrayWithinSet(node: ConnectableEntity | { _: "ConnectableEntity" | string }, nodeSet: Set<string>): Promise<ConnectableEntity>[];
1028
+ getTreeRootByNodes(nodes: ConnectableEntity[]): Promise<ConnectableEntity | null>;
1029
+ isTreeByNodes(nodes: ConnectableEntity[]): Promise<boolean>;
1030
+ isDAGByNodes(nodes: ConnectableEntity[]): Promise<boolean>;
1012
1031
  }
1013
1032
 
1014
1033
  declare class HistoryManager extends HistoryManagerAbs {
1015
- memoryEfficient: HistoryManagerAbs;
1016
- timeEfficient: HistoryManagerAbs;
1017
- currentManager: HistoryManagerAbs;
1018
- constructor(project: Project);
1034
+ memoryEfficient: Promise<HistoryManagerAbs>;
1035
+ timeEfficient: Promise<HistoryManagerAbs>;
1036
+ currentManager: Promise<HistoryManagerAbs>;
1037
+ constructor(project: Project | { _: "Project" | string });
1019
1038
  recordStep(): void;
1020
1039
  undo(): void;
1021
1040
  redo(): void;
1022
- get(index: number): Record<string, any>[];
1041
+ get(index: number): Promise<Record<string, any>>[];
1023
1042
  clearHistory(): void;
1024
1043
  switchMode(useTimeEfficient: boolean): void;
1025
1044
  }
1026
1045
 
1027
1046
  declare class ImageNode extends ConnectableEntity implements ResizeAble {
1028
- isHiddenBySectionCollapse: boolean;
1029
- uuid: string;
1030
- collisionBox: CollisionBox;
1031
- attachmentId: string;
1032
- scale: number;
1033
- isBackground: boolean;
1034
- _isSelected: boolean;
1035
- get isSelected(): any;
1047
+ isHiddenBySectionCollapse: Promise<boolean>;
1048
+ uuid: Promise<string>;
1049
+ collisionBox: Promise<CollisionBox>;
1050
+ attachmentId: Promise<string>;
1051
+ scale: Promise<number>;
1052
+ isBackground: Promise<boolean>;
1053
+ _isSelected: Promise<boolean>;
1054
+ get isSelected(): Promise<any>;
1036
1055
  set isSelected(value: boolean);
1037
- bitmap: ImageBitmap | undefined;
1038
- state: "loading" | "success" | "notFound";
1039
- constructor(project: Project, {
1056
+ bitmap: Promise<ImageBitmap | undefined>;
1057
+ state: Promise<"loading" | "success" | "notFound">;
1058
+ constructor(project: Project | { _: "Project" | string }, {
1040
1059
  uuid = crypto.randomUUID() as string,
1041
1060
  collisionBox = new CollisionBox([new Rectangle(Vector.getZero(), Vector.getZero())]),
1042
1061
  details = [],
@@ -1044,59 +1063,59 @@ declare class ImageNode extends ConnectableEntity implements ResizeAble {
1044
1063
  scale = 1,
1045
1064
  isBackground = false,
1046
1065
  }, unknown = false);
1047
- scaleUpdate(scaleDiff: number);
1048
- get rectangle(): Rectangle;
1049
- get geometryCenter(): any;
1050
- move(delta: Vector): void;
1051
- moveTo(location: Vector): void;
1052
- reverseColors();
1053
- swapRedBlueChannels();
1054
- resizeHandle(delta: Vector);
1055
- getResizeHandleRect(): Rectangle;
1066
+ scaleUpdate(scaleDiff: number): Promise<void>;
1067
+ get rectangle(): Promise<Rectangle>;
1068
+ get geometryCenter(): Promise<any>;
1069
+ move(delta: Vector | { _: "Vector" | string }): void;
1070
+ moveTo(location: Vector | { _: "Vector" | string }): void;
1071
+ reverseColors(): Promise<void>;
1072
+ swapRedBlueChannels(): Promise<void>;
1073
+ resizeHandle(delta: Vector | { _: "Vector" | string }): Promise<void>;
1074
+ getResizeHandleRect(): Promise<Rectangle>;
1056
1075
  }
1057
1076
 
1058
1077
  declare class ImageRenderer {
1059
- constructor(project: Project);
1060
- renderImageElement(source: Exclude<CanvasImageSource, VideoFrame | SVGElement>, location: Vector, scale: number = 1 / (window.devicePixelRatio || 1));
1061
- renderImageBitmap(bitmap: ImageBitmap | undefined, location: Vector, scale: number = 1 / (window.devicePixelRatio || 1));
1078
+ constructor(project: Project | { _: "Project" | string });
1079
+ renderImageElement(source: Exclude<CanvasImageSource, VideoFrame | SVGElement>, location: Vector | { _: "Vector" | string }, scale: number = 1 / (window.devicePixelRatio || 1)): Promise<void>;
1080
+ renderImageBitmap(bitmap: ImageBitmap | undefined, location: Vector | { _: "Vector" | string }, scale: number = 1 / (window.devicePixelRatio || 1)): Promise<void>;
1062
1081
  }
1063
1082
 
1064
1083
  declare class InputElement {
1065
- input(location: Vector, defaultValue: string, onChange: (value: string) => void = () => {}, style: Partial<CSSStyleDeclaration> = {}): Promise<string>;
1084
+ input(location: Vector | { _: "Vector" | string }, defaultValue: string, onChange: (value: string) => void = () => {}, style: Partial<CSSStyleDeclaration> = {}): Promise<string>;
1066
1085
  textarea(defaultValue: string, onChange: (value: string, element: HTMLTextAreaElement) => void = () => {}, style: Partial<CSSStyleDeclaration> = {}, selectAllWhenCreated = true): Promise<string>;
1067
- addSuccessEffect();
1068
- addFailEffect(withToast = true);
1069
- constructor(project: Project);
1086
+ addSuccessEffect(): Promise<void>;
1087
+ addFailEffect(withToast = true): Promise<void>;
1088
+ constructor(project: Project | { _: "Project" | string });
1070
1089
  }
1071
1090
 
1072
1091
  declare class KeyBindHintEngine {
1073
- constructor(project: Project);
1092
+ constructor(project: Project | { _: "Project" | string });
1074
1093
  ITEMS_PER_PAGE;
1075
1094
  currentPage;
1076
- currentModifierCombo: string;
1077
- lastModifierCombo: string;
1095
+ currentModifierCombo: Promise<string>;
1096
+ lastModifierCombo: Promise<string>;
1078
1097
  isShowingHint;
1079
1098
  hasOtherKeyPressed;
1080
1099
  hasModifierReleased;
1081
- cachedKeyBinds: Array<{
1100
+ cachedKeyBinds: Promise<Array<{
1082
1101
  id: string;
1083
1102
  key: string;
1084
1103
  displayKey: string;
1085
1104
  title: string;
1086
- }>;
1087
- getCurrentModifierCombo(): string;
1088
- isOnlyModifiersPressed(): boolean;
1089
- convertModifierComboForMatching(combo: string): string;
1090
- isKeyBindMatchModifier(key: string, modifierCombo: string): boolean;
1091
- getMatchingKeyBinds(modifierCombo: string): Array<{
1105
+ }>>;
1106
+ getCurrentModifierCombo(): Promise<string>;
1107
+ isOnlyModifiersPressed(): Promise<boolean>;
1108
+ convertModifierComboForMatching(combo: string): Promise<string>;
1109
+ isKeyBindMatchModifier(key: string, modifierCombo: string): Promise<boolean>;
1110
+ getMatchingKeyBinds(modifierCombo: string): Promise<Array<{
1092
1111
  id: string;
1093
1112
  key: string;
1094
1113
  displayKey: string;
1095
1114
  title: string;
1096
- }>;
1097
- getKeyBindTitle(id: string): string;
1098
- update();
1099
- render();
1115
+ }>>;
1116
+ getKeyBindTitle(id: string): Promise<string>;
1117
+ update(): Promise<void>;
1118
+ render(): Promise<void>;
1100
1119
  }
1101
1120
 
1102
1121
  declare type KeyBindIcon = ForwardRefExoticComponent<Omit<LucideProps, "ref"> & RefAttributes<SVGSVGElement>>;
@@ -1104,70 +1123,70 @@ declare type KeyBindIcon = ForwardRefExoticComponent<Omit<LucideProps, "ref"> &
1104
1123
  declare type KeyBindWhen = (project?: Project) => boolean | Promise<boolean>;
1105
1124
 
1106
1125
  declare class KeyboardOnlyEngine {
1107
- constructor(project: Project);
1126
+ constructor(project: Project | { _: "Project" | string });
1108
1127
  openning;
1109
- setOpenning(value: boolean);
1110
- isOpenning();
1111
- dispose();
1128
+ setOpenning(value: boolean): Promise<void>;
1129
+ isOpenning(): Promise<void>;
1130
+ dispose(): Promise<void>;
1112
1131
  startEditNode;
1113
1132
  onKeyUp;
1114
1133
  onKeyDown;
1115
- addSuccessEffect();
1116
- addFailEffect();
1134
+ addSuccessEffect(): Promise<void>;
1135
+ addFailEffect(): Promise<void>;
1117
1136
  }
1118
1137
 
1119
1138
  declare class KeyboardOnlyGraphEngine {
1120
1139
  targetLocationController;
1121
- virtualTargetLocation(): Vector;
1122
- tick();
1123
- constructor(project: Project);
1124
- isEnableVirtualCreate(): boolean;
1140
+ virtualTargetLocation(): Promise<Vector>;
1141
+ tick(): Promise<void>;
1142
+ constructor(project: Project | { _: "Project" | string });
1143
+ isEnableVirtualCreate(): Promise<boolean>;
1125
1144
  _isCreating;
1126
- _creatingFromUUID: string | null;
1127
- creatingFromUUID(): string | null;
1128
- isCreating(): boolean;
1145
+ _creatingFromUUID: Promise<string | null>;
1146
+ creatingFromUUID(): Promise<string | null>;
1147
+ isCreating(): Promise<boolean>;
1129
1148
  createStart(): void;
1130
1149
  lastPressTabTime;
1131
- getPressTabTimeInterval(): number;
1132
- createFinished();
1133
- moveVirtualTarget(delta: Vector): void;
1150
+ getPressTabTimeInterval(): Promise<number>;
1151
+ createFinished(): Promise<void>;
1152
+ moveVirtualTarget(delta: Vector | { _: "Vector" | string }): void;
1134
1153
  createCancel(): void;
1135
- isTargetLocationHaveEntity(): boolean;
1154
+ isTargetLocationHaveEntity(): Promise<boolean>;
1136
1155
  }
1137
1156
 
1138
1157
  declare class KeyboardOnlyTreeEngine {
1139
- constructor(project: Project);
1140
- getNodePreDirection(node: ConnectableEntity): "right" | "left" | "down" | "up";
1141
- preDirectionCacheMap: Map<string, "right" | "left" | "down" | "up">;
1142
- getGrowthLineStart(node: ConnectableEntity, direction: "right" | "left" | "down" | "up"): Vector;
1143
- getGrowthLineEnd(node: ConnectableEntity, direction: "right" | "left" | "down" | "up"): Vector;
1144
- findConnectTargetByGrowthLine(node: ConnectableEntity, direction: "right" | "left" | "down" | "up"): ConnectableEntity | null;
1158
+ constructor(project: Project | { _: "Project" | string });
1159
+ getNodePreDirection(node: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<"right" | "left" | "down" | "up">;
1160
+ preDirectionCacheMap: Promise<Map<string, "right" | "left" | "down" | "up">>;
1161
+ getGrowthLineStart(node: ConnectableEntity | { _: "ConnectableEntity" | string }, direction: "right" | "left" | "down" | "up"): Promise<Vector>;
1162
+ getGrowthLineEnd(node: ConnectableEntity | { _: "ConnectableEntity" | string }, direction: "right" | "left" | "down" | "up"): Promise<Vector>;
1163
+ findConnectTargetByGrowthLine(node: ConnectableEntity | { _: "ConnectableEntity" | string }, direction: "right" | "left" | "down" | "up"): Promise<ConnectableEntity | null>;
1145
1164
  changePreDirection(nodes: ConnectableEntity[], direction: "right" | "left" | "down" | "up"): void;
1146
- addNodeEffectByPreDirection(node: ConnectableEntity): void;
1147
- onDeepGenerateNode(defaultText = "新节点", selectAll = true);
1148
- onBroadGenerateNode();
1149
- adjustTreeNode(entity: ConnectableEntity, withEffect = true);
1150
- onDeleteCurrentNode();
1151
- calculateNewNodeFontScaleLevel(parentNode: ConnectableEntity, preDirection: "right" | "left" | "down" | "up"): number;
1165
+ addNodeEffectByPreDirection(node: ConnectableEntity | { _: "ConnectableEntity" | string }): void;
1166
+ onDeepGenerateNode(defaultText = "新节点", selectAll = true): Promise<void>;
1167
+ onBroadGenerateNode(): Promise<void>;
1168
+ adjustTreeNode(entity: ConnectableEntity | { _: "ConnectableEntity" | string }, withEffect = true): Promise<void>;
1169
+ onDeleteCurrentNode(): Promise<void>;
1170
+ calculateNewNodeFontScaleLevel(parentNode: ConnectableEntity | { _: "ConnectableEntity" | string }, preDirection: "right" | "left" | "down" | "up"): Promise<number>;
1152
1171
  }
1153
1172
 
1154
1173
  declare class LatexNode extends ConnectableEntity {
1155
- uuid: string;
1156
- latexSource: string;
1157
- collisionBox: CollisionBox;
1158
- color: Color;
1159
- fontScaleLevel: number;
1160
- isHiddenBySectionCollapse: boolean;
1161
- image: HTMLImageElement;
1162
- svgOriginalSize: Vector;
1163
- state: "loading" | "success" | "error";
1164
- currentRenderedColorCss: string;
1165
- _isSelected: boolean;
1166
- get isSelected(): any;
1174
+ uuid: Promise<string>;
1175
+ latexSource: Promise<string>;
1176
+ collisionBox: Promise<CollisionBox>;
1177
+ color: Promise<Color>;
1178
+ fontScaleLevel: Promise<number>;
1179
+ isHiddenBySectionCollapse: Promise<boolean>;
1180
+ image: Promise<HTMLImageElement>;
1181
+ svgOriginalSize: Promise<Vector>;
1182
+ state: Promise<"loading" | "success" | "error">;
1183
+ currentRenderedColorCss: Promise<string>;
1184
+ _isSelected: Promise<boolean>;
1185
+ get isSelected(): Promise<any>;
1167
1186
  set isSelected(value: boolean);
1168
- get rectangle(): Rectangle;
1169
- get geometryCenter(): Vector;
1170
- constructor(project: Project, {
1187
+ get rectangle(): Promise<Rectangle>;
1188
+ get geometryCenter(): Promise<Vector>;
1189
+ constructor(project: Project | { _: "Project" | string }, {
1171
1190
  uuid = crypto.randomUUID(),
1172
1191
  details = [],
1173
1192
  latexSource = "",
@@ -1182,52 +1201,52 @@ declare class LatexNode extends ConnectableEntity {
1182
1201
  color?: Color;
1183
1202
  fontScaleLevel?: number;
1184
1203
  });
1185
- getScale(): number;
1186
- increaseFontSize(anchorRate?: Vector): void;
1187
- decreaseFontSize(anchorRate?: Vector): void;
1188
- updateCollisionBoxByScale(anchorRate?: Vector): void;
1189
- _adjustLocationToKeepAnchor(oldRect: Rectangle, anchorRate: Vector): void;
1204
+ getScale(): Promise<number>;
1205
+ increaseFontSize(anchorRate?: Vector | { _: "Vector" | string }): void;
1206
+ decreaseFontSize(anchorRate?: Vector | { _: "Vector" | string }): void;
1207
+ updateCollisionBoxByScale(anchorRate?: Vector | { _: "Vector" | string }): void;
1208
+ _adjustLocationToKeepAnchor(oldRect: Rectangle | { _: "Rectangle" | string }, anchorRate: Vector | { _: "Vector" | string }): void;
1190
1209
  updateLatex(newLatex: string, colorCss?: string): Promise<void>;
1191
1210
  reRenderWithColor(colorCss: string): Promise<void>;
1192
1211
  renderLatexToImage(latex: string, colorCss: string = "#000000"): Promise<void>;
1193
- move(delta: Vector): void;
1194
- moveTo(location: Vector): void;
1212
+ move(delta: Vector | { _: "Vector" | string }): void;
1213
+ moveTo(location: Vector | { _: "Vector" | string }): void;
1195
1214
  }
1196
1215
 
1197
1216
  declare class LatexNodeRenderer {
1198
- constructor(project: Project);
1199
- getTargetColorCss(node: LatexNode): string;
1200
- render(node: LatexNode);
1217
+ constructor(project: Project | { _: "Project" | string });
1218
+ getTargetColorCss(node: LatexNode | { _: "LatexNode" | string }): Promise<string>;
1219
+ render(node: LatexNode | { _: "LatexNode" | string }): Promise<void>;
1201
1220
  }
1202
1221
 
1203
1222
  declare class LayoutManager {
1204
- constructor(project: Project);
1205
- alignLeft();
1206
- alignRight();
1207
- alignTop();
1208
- alignBottom();
1209
- alignCenterHorizontal();
1210
- alignCenterVertical();
1211
- alignHorizontalSpaceBetween();
1212
- alignVerticalSpaceBetween();
1213
- alignLeftToRightNoSpace();
1214
- alignTopToBottomNoSpace();
1215
- layoutBySelected(layoutFunction: (entities: Entity[]) => void, isDeep: boolean);
1216
- adjustSelectedTextNodeWidth(mode: "maxWidth" | "minWidth" | "average");
1217
- layoutToSquare(entities: Entity[]);
1218
- layoutToTightSquare(entities: Entity[]);
1223
+ constructor(project: Project | { _: "Project" | string });
1224
+ alignLeft(): Promise<void>;
1225
+ alignRight(): Promise<void>;
1226
+ alignTop(): Promise<void>;
1227
+ alignBottom(): Promise<void>;
1228
+ alignCenterHorizontal(): Promise<void>;
1229
+ alignCenterVertical(): Promise<void>;
1230
+ alignHorizontalSpaceBetween(): Promise<void>;
1231
+ alignVerticalSpaceBetween(): Promise<void>;
1232
+ alignLeftToRightNoSpace(): Promise<void>;
1233
+ alignTopToBottomNoSpace(): Promise<void>;
1234
+ layoutBySelected(layoutFunction: (entities: Entity[]) => void, isDeep: boolean): Promise<void>;
1235
+ adjustSelectedTextNodeWidth(mode: "maxWidth" | "minWidth" | "average"): Promise<void>;
1236
+ layoutToSquare(entities: Entity[]): Promise<void>;
1237
+ layoutToTightSquare(entities: Entity[]): Promise<void>;
1219
1238
  }
1220
1239
 
1221
1240
  declare class LineEdge extends Edge {
1222
- uuid: string;
1223
- text: string;
1224
- color: Color;
1225
- lineType: string;
1226
- get collisionBox(): CollisionBox;
1227
- get shiftingIndex(): number;
1241
+ uuid: Promise<string>;
1242
+ text: Promise<string>;
1243
+ color: Promise<Color>;
1244
+ lineType: Promise<string>;
1245
+ get collisionBox(): Promise<CollisionBox>;
1246
+ get shiftingIndex(): Promise<number>;
1228
1247
  set shiftingIndex(value: number);
1229
- _shiftingIndex: number;
1230
- constructor(project: Project, {
1248
+ _shiftingIndex: Promise<number>;
1249
+ constructor(project: Project | { _: "Project" | string }, {
1231
1250
  associationList = [] as ConnectableEntity[],
1232
1251
  text = "",
1233
1252
  uuid = crypto.randomUUID() as string,
@@ -1236,12 +1255,12 @@ declare class LineEdge extends Edge {
1236
1255
  targetRectangleRate = Vector.same(0.5),
1237
1256
  lineType = "solid",
1238
1257
  }, unknown = false);
1239
- fromTwoEntity(project: Project, source: ConnectableEntity, target: ConnectableEntity): LineEdge;
1240
- rename(text: string);
1241
- get edgeWidth(): number;
1242
- get textFontSize(): number;
1243
- get textRectangle(): Rectangle;
1244
- get shiftingMidPoint(): Vector;
1258
+ fromTwoEntity(project: Project | { _: "Project" | string }, source: ConnectableEntity | { _: "ConnectableEntity" | string }, target: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<LineEdge>;
1259
+ rename(text: string): Promise<void>;
1260
+ get edgeWidth(): Promise<number>;
1261
+ get textFontSize(): Promise<number>;
1262
+ get textRectangle(): Promise<Rectangle>;
1263
+ get shiftingMidPoint(): Promise<Vector>;
1245
1264
  adjustSizeByText(): void;
1246
1265
  }
1247
1266
 
@@ -1333,68 +1352,68 @@ declare enum LogicNodeNameEnum {
1333
1352
  }
1334
1353
 
1335
1354
  declare class MarkdownExporter extends BaseExporter {
1336
- export(textNode: TextNode): string;
1337
- getNodeMarkdown(node: TextNode, level: number): string;
1355
+ export(textNode: TextNode | { _: "TextNode" | string }): Promise<string>;
1356
+ getNodeMarkdown(node: TextNode | { _: "TextNode" | string }, level: number): Promise<string>;
1338
1357
  }
1339
1358
 
1340
1359
  declare class MarkdownImporter extends BaseImporter {
1341
- constructor(project: Project);
1342
- import(markdownText: string, diffLocation: Vector = Vector.getZero(), autoLayout = true): void;
1360
+ constructor(project: Project | { _: "Project" | string });
1361
+ import(markdownText: string, diffLocation: Vector | { _: "Vector" | string } = Vector.getZero(), autoLayout = true): void;
1343
1362
  }
1344
1363
 
1345
1364
  declare interface MarkdownNode {
1346
- title: string;
1347
- content: string;
1348
- children: MarkdownNode[];
1365
+ title: Promise<string>;
1366
+ content: Promise<string>;
1367
+ children: Promise<MarkdownNode>[];
1349
1368
  }
1350
1369
 
1351
1370
  declare class MermaidExporter {
1352
- constructor(project: Project);
1353
- export(entities: Entity[]): string;
1371
+ constructor(project: Project | { _: "Project" | string });
1372
+ export(entities: Entity[]): Promise<string>;
1354
1373
  }
1355
1374
 
1356
1375
  declare class MermaidImporter extends BaseImporter {
1357
- constructor(project: Project);
1358
- import(text: string, diffLocation: Vector = Vector.getZero()): void;
1359
- normalizeLine(line: string): string;
1360
- decodeMermaidText(value: string): string;
1361
- sanitizeLabel(raw: string | undefined): string | undefined;
1362
- parseNodeToken(token: string): MermaidNodeToken;
1376
+ constructor(project: Project | { _: "Project" | string });
1377
+ import(text: string, diffLocation: Vector | { _: "Vector" | string } = Vector.getZero()): void;
1378
+ normalizeLine(line: string): Promise<string>;
1379
+ decodeMermaidText(value: string): Promise<string>;
1380
+ sanitizeLabel(raw: string | undefined): Promise<string | undefined>;
1381
+ parseNodeToken(token: string): Promise<MermaidNodeToken>;
1363
1382
  }
1364
1383
 
1365
1384
  declare class MouseInteraction {
1366
- constructor(project: Project);
1367
- _hoverEdges: Edge[];
1368
- _hoverSections: Section[];
1369
- _hoverConnectPoints: ConnectPoint[];
1370
- _hoverMultiTargetEdges: MultiTargetUndirectedEdge[];
1371
- get hoverEdges(): Edge[];
1372
- get firstHoverEdge(): Edge | undefined;
1373
- get hoverSections(): Section[];
1374
- get hoverConnectPoints(): ConnectPoint[];
1375
- get firstHoverSection(): Section | undefined;
1376
- get hoverMultiTargetEdges(): MultiTargetUndirectedEdge[];
1377
- get firstHoverMultiTargetEdge(): MultiTargetUndirectedEdge | undefined;
1378
- updateByMouseMove(mouseWorldLocation: Vector): void;
1385
+ constructor(project: Project | { _: "Project" | string });
1386
+ _hoverEdges: Promise<Edge>[];
1387
+ _hoverSections: Promise<Section>[];
1388
+ _hoverConnectPoints: Promise<ConnectPoint>[];
1389
+ _hoverMultiTargetEdges: Promise<MultiTargetUndirectedEdge>[];
1390
+ get hoverEdges(): Promise<Edge>[];
1391
+ get firstHoverEdge(): Promise<Edge | undefined>;
1392
+ get hoverSections(): Promise<Section>[];
1393
+ get hoverConnectPoints(): Promise<ConnectPoint>[];
1394
+ get firstHoverSection(): Promise<Section | undefined>;
1395
+ get hoverMultiTargetEdges(): Promise<MultiTargetUndirectedEdge>[];
1396
+ get firstHoverMultiTargetEdge(): Promise<MultiTargetUndirectedEdge | undefined>;
1397
+ updateByMouseMove(mouseWorldLocation: Vector | { _: "Vector" | string }): void;
1379
1398
  }
1380
1399
 
1381
1400
  declare class MultiTargetEdgeMove {
1382
- constructor(project: Project);
1383
- moveMultiTargetEdge(diffLocation: Vector);
1401
+ constructor(project: Project | { _: "Project" | string });
1402
+ moveMultiTargetEdge(diffLocation: Vector | { _: "Vector" | string }): Promise<void>;
1384
1403
  }
1385
1404
 
1386
1405
  declare class MultiTargetUndirectedEdge extends ConnectableAssociation {
1387
- uuid: string;
1388
- get collisionBox(): CollisionBox;
1389
- text: string;
1390
- color: Color;
1391
- rectRates: Vector[];
1392
- centerRate: Vector;
1393
- arrow: UndirectedEdgeArrowType;
1394
- renderType: MultiTargetUndirectedEdgeRenderType;
1395
- padding: number;
1396
- rename(text: string);
1397
- constructor(project: Project, {
1406
+ uuid: Promise<string>;
1407
+ get collisionBox(): Promise<CollisionBox>;
1408
+ text: Promise<string>;
1409
+ color: Promise<Color>;
1410
+ rectRates: Promise<Vector>[];
1411
+ centerRate: Promise<Vector>;
1412
+ arrow: Promise<UndirectedEdgeArrowType>;
1413
+ renderType: Promise<MultiTargetUndirectedEdgeRenderType>;
1414
+ padding: Promise<number>;
1415
+ rename(text: string): Promise<void>;
1416
+ constructor(project: Project | { _: "Project" | string }, {
1398
1417
  associationList = [] as ConnectableEntity[],
1399
1418
  text = "",
1400
1419
  uuid = crypto.randomUUID() as string,
@@ -1415,95 +1434,95 @@ declare class MultiTargetUndirectedEdge extends ConnectableAssociation {
1415
1434
  padding?: number;
1416
1435
  renderType?: MultiTargetUndirectedEdgeRenderType;
1417
1436
  }, unknown = false);
1418
- get centerLocation(): Vector;
1419
- get textRectangle(): Rectangle;
1420
- createFromSomeEntity(project: Project, entities: ConnectableEntity[]);
1421
- _isSelected: boolean;
1422
- get isSelected(): boolean;
1437
+ get centerLocation(): Promise<Vector>;
1438
+ get textRectangle(): Promise<Rectangle>;
1439
+ createFromSomeEntity(project: Project | { _: "Project" | string }, entities: ConnectableEntity[]): Promise<void>;
1440
+ _isSelected: Promise<boolean>;
1441
+ get isSelected(): Promise<boolean>;
1423
1442
  set isSelected(value: boolean);
1424
1443
  }
1425
1444
 
1426
1445
  declare class MultiTargetUndirectedEdgeRenderer {
1427
- constructor(project: Project);
1428
- render(edge: MultiTargetUndirectedEdge);
1429
- renderLineShape(edge: MultiTargetUndirectedEdge, edgeColor: Color, centerLocation: Vector): void;
1430
- renderConvexShape(edge: MultiTargetUndirectedEdge, edgeColor: Color): void;
1431
- renderCircle(edge: MultiTargetUndirectedEdge, edgeColor: Color): void;
1446
+ constructor(project: Project | { _: "Project" | string });
1447
+ render(edge: MultiTargetUndirectedEdge | { _: "MultiTargetUndirectedEdge" | string }): Promise<void>;
1448
+ renderLineShape(edge: MultiTargetUndirectedEdge | { _: "MultiTargetUndirectedEdge" | string }, edgeColor: Color | { _: "Color" | string }, centerLocation: Vector | { _: "Vector" | string }): void;
1449
+ renderConvexShape(edge: MultiTargetUndirectedEdge | { _: "MultiTargetUndirectedEdge" | string }, edgeColor: Color | { _: "Color" | string }): void;
1450
+ renderCircle(edge: MultiTargetUndirectedEdge | { _: "MultiTargetUndirectedEdge" | string }, edgeColor: Color | { _: "Color" | string }): void;
1432
1451
  }
1433
1452
 
1434
1453
  declare class NodeAdder {
1435
- constructor(project: Project);
1436
- addTextNodeByClick(clickWorldLocation: Vector, addToSections: Section[], selectCurrent = false, shouldRecordHistory = true, options?: {
1454
+ constructor(project: Project | { _: "Project" | string });
1455
+ addTextNodeByClick(clickWorldLocation: Vector | { _: "Vector" | string }, addToSections: Section[], selectCurrent = false, shouldRecordHistory = true, options?: {
1437
1456
  overrideFontScaleLevel?: number;
1438
1457
  }): Promise<string>;
1439
1458
  addTextNodeFromCurrentSelectedNode(direction: Direction, addToSections: Section[], selectCurrent = false): Promise<string>;
1440
1459
  getAutoName(): Promise<string>;
1441
- getAutoColor(): Color;
1442
- addConnectPoint(clickWorldLocation: Vector, addToSections: Section[]): string;
1443
- addNodeGraphByText(text: string, diffLocation: Vector = Vector.getZero()): void;
1444
- addNodeTreeByText(text: string, indention: number, diffLocation: Vector = Vector.getZero()): void;
1445
- addNodeMermaidByText(text: string, diffLocation: Vector = Vector.getZero()): void;
1446
- addNodeByMarkdown(markdownText: string, diffLocation: Vector = Vector.getZero(), autoLayout = true);
1447
- getIndentLevel(line: string, indention: number): number;
1460
+ getAutoColor(): Promise<Color>;
1461
+ addConnectPoint(clickWorldLocation: Vector | { _: "Vector" | string }, addToSections: Section[]): Promise<string>;
1462
+ addNodeGraphByText(text: string, diffLocation: Vector | { _: "Vector" | string } = Vector.getZero()): void;
1463
+ addNodeTreeByText(text: string, indention: number, diffLocation: Vector | { _: "Vector" | string } = Vector.getZero()): void;
1464
+ addNodeMermaidByText(text: string, diffLocation: Vector | { _: "Vector" | string } = Vector.getZero()): void;
1465
+ addNodeByMarkdown(markdownText: string, diffLocation: Vector | { _: "Vector" | string } = Vector.getZero(), autoLayout = true): Promise<void>;
1466
+ getIndentLevel(line: string, indention: number): Promise<number>;
1448
1467
  }
1449
1468
 
1450
1469
  declare class NodeConnector {
1451
- constructor(project: Project);
1452
- isConnectable(fromNode: ConnectableEntity, toNode: ConnectableEntity): boolean;
1453
- connectConnectableEntity(fromNode: ConnectableEntity, toNode: ConnectableEntity, text: string = "", targetRectRate?: [number, number], sourceRectRate?: [number, number]): void;
1454
- connectEntityFast(fromNode: ConnectableEntity, toNode: ConnectableEntity, text: string = ""): void;
1455
- addCrEdge(fromNode: ConnectableEntity, toNode: ConnectableEntity): void;
1456
- reverseEdges(edges: LineEdge[]);
1457
- changeEdgeTarget(edge: LineEdge, newTarget: ConnectableEntity);
1458
- changeEdgeSource(edge: LineEdge, newSource: ConnectableEntity);
1459
- changeSelectedEdgeTarget(newTarget: ConnectableEntity);
1460
- changeSelectedEdgeSource(newSource: ConnectableEntity);
1470
+ constructor(project: Project | { _: "Project" | string });
1471
+ isConnectable(fromNode: ConnectableEntity | { _: "ConnectableEntity" | string }, toNode: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<boolean>;
1472
+ connectConnectableEntity(fromNode: ConnectableEntity | { _: "ConnectableEntity" | string }, toNode: ConnectableEntity | { _: "ConnectableEntity" | string }, text: string = "", targetRectRate?: [number, number], sourceRectRate?: [number, number]): void;
1473
+ connectEntityFast(fromNode: ConnectableEntity | { _: "ConnectableEntity" | string }, toNode: ConnectableEntity | { _: "ConnectableEntity" | string }, text: string = ""): void;
1474
+ addCrEdge(fromNode: ConnectableEntity | { _: "ConnectableEntity" | string }, toNode: ConnectableEntity | { _: "ConnectableEntity" | string }): void;
1475
+ reverseEdges(edges: LineEdge[]): Promise<void>;
1476
+ changeEdgeTarget(edge: LineEdge | { _: "LineEdge" | string }, newTarget: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<void>;
1477
+ changeEdgeSource(edge: LineEdge | { _: "LineEdge" | string }, newSource: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<void>;
1478
+ changeSelectedEdgeTarget(newTarget: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<void>;
1479
+ changeSelectedEdgeSource(newSource: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<void>;
1461
1480
  }
1462
1481
 
1463
1482
  declare class PenStroke extends Entity {
1464
- isAlignExcluded: boolean;
1465
- isHiddenBySectionCollapse: boolean;
1466
- collisionBox: CollisionBox;
1467
- uuid: string;
1468
- move(delta: Vector): void;
1469
- moveTo(location: Vector): void;
1470
- updateCollisionBoxBySegmentList();
1471
- segments: PenStrokeSegment[];
1472
- color: Color;
1473
- getPath(): Vector[];
1474
- constructor(project: Project, { uuid = crypto.randomUUID() as string, segments = [] as PenStrokeSegment[], color = Color.White });
1475
- getCollisionBoxFromSegmentList(segmentList: PenStrokeSegment[]): CollisionBox;
1483
+ isAlignExcluded: Promise<boolean>;
1484
+ isHiddenBySectionCollapse: Promise<boolean>;
1485
+ collisionBox: Promise<CollisionBox>;
1486
+ uuid: Promise<string>;
1487
+ move(delta: Vector | { _: "Vector" | string }): void;
1488
+ moveTo(location: Vector | { _: "Vector" | string }): void;
1489
+ updateCollisionBoxBySegmentList(): Promise<void>;
1490
+ segments: Promise<PenStrokeSegment>[];
1491
+ color: Promise<Color>;
1492
+ getPath(): Promise<Vector>[];
1493
+ constructor(project: Project | { _: "Project" | string }, { uuid = crypto.randomUUID() as string, segments = [] as PenStrokeSegment[], color = Color.White });
1494
+ getCollisionBoxFromSegmentList(segmentList: PenStrokeSegment[]): Promise<CollisionBox>;
1476
1495
  }
1477
1496
 
1478
1497
  declare class PenStrokeSegment {
1479
- location: Vector;
1480
- pressure: number;
1481
- constructor(location: Vector, pressure: number);
1498
+ location: Promise<Vector>;
1499
+ pressure: Promise<number>;
1500
+ constructor(location: Vector | { _: "Vector" | string }, pressure: number);
1482
1501
  }
1483
1502
 
1484
1503
  declare class PlainTextExporter {
1485
- constructor(project: Project);
1486
- export(nodes: Entity[]): string;
1504
+ constructor(project: Project | { _: "Project" | string });
1505
+ export(nodes: Entity[]): Promise<string>;
1487
1506
  }
1488
1507
 
1489
1508
  declare interface PrgMetadata {
1490
- version: string;
1491
- extension?: ExtensionMetadata;
1509
+ version: Promise<string>;
1510
+ extension?: Promise<ExtensionMetadata>;
1492
1511
  }
1493
1512
 
1494
1513
  declare class Project extends Tab {
1495
1514
  latestVersion;
1496
- _uri: URI;
1497
- _projectState: ProjectState;
1515
+ _uri: Promise<URI>;
1516
+ _projectState: Promise<ProjectState>;
1498
1517
  _isSaving;
1499
- stage: StageObject[];
1500
- tags: string[];
1518
+ stage: Promise<StageObject>[];
1519
+ tags: Promise<string>[];
1501
1520
  attachments;
1502
1521
  encoder;
1503
1522
  decoder;
1504
1523
  constructor(uri: URI);
1505
- newDraft(): Project;
1506
- compareVersion(version1: string, version2: string): number;
1524
+ newDraft(): Promise<Project>;
1525
+ compareVersion(version1: string, version2: string): Promise<number>;
1507
1526
  checkAndConfirmUpgrade(currentVersion: string, latestVersion: string): Promise<boolean>;
1508
1527
  parseProjectFile(): Promise<{
1509
1528
  serializedStageObjects: any[];
@@ -1512,108 +1531,108 @@ declare class Project extends Tab {
1512
1531
  metadata: PrgMetadata;
1513
1532
  readme?: string;
1514
1533
  }>;
1515
- init();
1516
- get isDraft(): any;
1517
- get title(): string;
1518
- get icon(): any;
1519
- get uri(): any;
1534
+ init(): Promise<void>;
1535
+ get isDraft(): Promise<any>;
1536
+ get title(): Promise<string>;
1537
+ get icon(): Promise<any>;
1538
+ get uri(): Promise<any>;
1520
1539
  set uri(uri: URI);
1521
- stash();
1522
- save();
1523
- references: { sections: Record<string, string[]>; files: string[] };
1524
- metadata: PrgMetadata;
1525
- readme?: string;
1526
- getFileContent();
1527
- get stageHash(): any;
1528
- addAttachment(data: Blob);
1540
+ stash(): Promise<void>;
1541
+ save(): Promise<void>;
1542
+ references: Promise<{ sections: Record<string, string[]>; files: string[] }>;
1543
+ metadata: Promise<PrgMetadata>;
1544
+ readme?: Promise<string>;
1545
+ getFileContent(): Promise<void>;
1546
+ get stageHash(): Promise<any>;
1547
+ addAttachment(data: Blob): Promise<void>;
1529
1548
  set projectState(state: ProjectState);
1530
- get projectState(): ProjectState;
1549
+ get projectState(): Promise<ProjectState>;
1531
1550
  set isSaving(isSaving: boolean);
1532
- get isSaving(): boolean;
1551
+ get isSaving(): Promise<boolean>;
1533
1552
  containerRef;
1534
- loadService(service: { id?: string; new (...args: any[]): any });
1553
+ loadService(service: { id?: string; new (...args: any[]): any }): Promise<void>;
1535
1554
  componentDidMount(): void;
1536
- currentComponent: React.ComponentType | null;
1537
- getComponent(): React.ComponentType;
1538
- render(): React.ReactNode;
1539
- canvas: Canvas;
1540
- inputElement: InputElement;
1541
- controllerUtils: ControllerUtils;
1542
- autoComputeUtils: AutoComputeUtils;
1543
- renderUtils: RenderUtils;
1544
- worldRenderUtils: WorldRenderUtils;
1545
- historyManager: HistoryManager;
1546
- stageManager: StageManager;
1547
- camera: Camera;
1548
- effects: Effects;
1549
- autoCompute: AutoCompute;
1550
- rectangleSelect: RectangleSelect;
1551
- stageNodeRotate: StageNodeRotate;
1552
- complexityDetector: ComplexityDetector;
1553
- aiEngine: AIEngine;
1554
- copyEngine: CopyEngine;
1555
- autoLayout: AutoLayout;
1556
- autoLayoutFastTree: AutoLayoutFastTree;
1557
- layoutManager: LayoutManager;
1558
- autoAlign: AutoAlign;
1559
- mouseInteraction: MouseInteraction;
1560
- contentSearch: ContentSearch;
1561
- deleteManager: DeleteManager;
1562
- nodeAdder: NodeAdder;
1563
- entityMoveManager: EntityMoveManager;
1564
- stageUtils: StageUtils;
1565
- multiTargetEdgeMove: MultiTargetEdgeMove;
1566
- nodeConnector: NodeConnector;
1567
- stageObjectColorManager: StageObjectColorManager;
1568
- stageObjectSelectCounter: StageObjectSelectCounter;
1569
- sectionInOutManager: SectionInOutManager;
1570
- sectionPackManager: SectionPackManager;
1571
- sectionCollisionSolver: SectionCollisionSolver;
1572
- tagManager: TagManager;
1573
- syncAssociationManager: StageSyncAssociationManager;
1574
- keyboardOnlyEngine: KeyboardOnlyEngine;
1575
- keyboardOnlyGraphEngine: KeyboardOnlyGraphEngine;
1576
- keyboardOnlyTreeEngine: KeyboardOnlyTreeEngine;
1577
- selectChangeEngine: SelectChangeEngine;
1578
- textRenderer: TextRenderer;
1579
- imageRenderer: ImageRenderer;
1580
- referenceBlockRenderer: ReferenceBlockRenderer;
1581
- shapeRenderer: ShapeRenderer;
1582
- entityRenderer: EntityRenderer;
1583
- edgeRenderer: EdgeRenderer;
1584
- multiTargetUndirectedEdgeRenderer: MultiTargetUndirectedEdgeRenderer;
1585
- curveRenderer: CurveRenderer;
1586
- svgRenderer: SvgRenderer;
1587
- drawingControllerRenderer: DrawingControllerRenderer;
1588
- collisionBoxRenderer: CollisionBoxRenderer;
1589
- entityDetailsButtonRenderer: EntityDetailsButtonRenderer;
1590
- straightEdgeRenderer: StraightEdgeRenderer;
1591
- symmetryCurveEdgeRenderer: SymmetryCurveEdgeRenderer;
1592
- verticalPolyEdgeRenderer: VerticalPolyEdgeRenderer;
1593
- sectionRenderer: SectionRenderer;
1594
- svgNodeRenderer: SvgNodeRenderer;
1595
- latexNodeRenderer: LatexNodeRenderer;
1596
- textNodeRenderer: TextNodeRenderer;
1597
- urlNodeRenderer: UrlNodeRenderer;
1598
- backgroundRenderer: BackgroundRenderer;
1599
- searchContentHighlightRenderer: SearchContentHighlightRenderer;
1600
- renderer: Renderer;
1601
- controller: Controller;
1602
- stageExport: StageExport;
1603
- stageExportPng: StageExportPng;
1604
- stageExportSvg: StageExportSvg;
1605
- stageImport: StageImport;
1606
- generateFromFolder: GenerateFromFolder;
1607
- keyBindHintEngine: KeyBindHintEngine;
1608
- sectionMethods: SectionMethods;
1609
- graphMethods: GraphMethods;
1610
- stageStyleManager: StageStyleManager;
1611
- autoSaveBackup: AutoSaveBackupService;
1612
- referenceManager: ReferenceManager;
1555
+ currentComponent: Promise<React.ComponentType | null>;
1556
+ getComponent(): Promise<React.ComponentType>;
1557
+ render(): Promise<React.ReactNode>;
1558
+ canvas: Promise<Canvas>;
1559
+ inputElement: Promise<InputElement>;
1560
+ controllerUtils: Promise<ControllerUtils>;
1561
+ autoComputeUtils: Promise<AutoComputeUtils>;
1562
+ renderUtils: Promise<RenderUtils>;
1563
+ worldRenderUtils: Promise<WorldRenderUtils>;
1564
+ historyManager: Promise<HistoryManager>;
1565
+ stageManager: Promise<StageManager>;
1566
+ camera: Promise<Camera>;
1567
+ effects: Promise<Effects>;
1568
+ autoCompute: Promise<AutoCompute>;
1569
+ rectangleSelect: Promise<RectangleSelect>;
1570
+ stageNodeRotate: Promise<StageNodeRotate>;
1571
+ complexityDetector: Promise<ComplexityDetector>;
1572
+ aiEngine: Promise<AIEngine>;
1573
+ copyEngine: Promise<CopyEngine>;
1574
+ autoLayout: Promise<AutoLayout>;
1575
+ autoLayoutFastTree: Promise<AutoLayoutFastTree>;
1576
+ layoutManager: Promise<LayoutManager>;
1577
+ autoAlign: Promise<AutoAlign>;
1578
+ mouseInteraction: Promise<MouseInteraction>;
1579
+ contentSearch: Promise<ContentSearch>;
1580
+ deleteManager: Promise<DeleteManager>;
1581
+ nodeAdder: Promise<NodeAdder>;
1582
+ entityMoveManager: Promise<EntityMoveManager>;
1583
+ stageUtils: Promise<StageUtils>;
1584
+ multiTargetEdgeMove: Promise<MultiTargetEdgeMove>;
1585
+ nodeConnector: Promise<NodeConnector>;
1586
+ stageObjectColorManager: Promise<StageObjectColorManager>;
1587
+ stageObjectSelectCounter: Promise<StageObjectSelectCounter>;
1588
+ sectionInOutManager: Promise<SectionInOutManager>;
1589
+ sectionPackManager: Promise<SectionPackManager>;
1590
+ sectionCollisionSolver: Promise<SectionCollisionSolver>;
1591
+ tagManager: Promise<TagManager>;
1592
+ syncAssociationManager: Promise<StageSyncAssociationManager>;
1593
+ keyboardOnlyEngine: Promise<KeyboardOnlyEngine>;
1594
+ keyboardOnlyGraphEngine: Promise<KeyboardOnlyGraphEngine>;
1595
+ keyboardOnlyTreeEngine: Promise<KeyboardOnlyTreeEngine>;
1596
+ selectChangeEngine: Promise<SelectChangeEngine>;
1597
+ textRenderer: Promise<TextRenderer>;
1598
+ imageRenderer: Promise<ImageRenderer>;
1599
+ referenceBlockRenderer: Promise<ReferenceBlockRenderer>;
1600
+ shapeRenderer: Promise<ShapeRenderer>;
1601
+ entityRenderer: Promise<EntityRenderer>;
1602
+ edgeRenderer: Promise<EdgeRenderer>;
1603
+ multiTargetUndirectedEdgeRenderer: Promise<MultiTargetUndirectedEdgeRenderer>;
1604
+ curveRenderer: Promise<CurveRenderer>;
1605
+ svgRenderer: Promise<SvgRenderer>;
1606
+ drawingControllerRenderer: Promise<DrawingControllerRenderer>;
1607
+ collisionBoxRenderer: Promise<CollisionBoxRenderer>;
1608
+ entityDetailsButtonRenderer: Promise<EntityDetailsButtonRenderer>;
1609
+ straightEdgeRenderer: Promise<StraightEdgeRenderer>;
1610
+ symmetryCurveEdgeRenderer: Promise<SymmetryCurveEdgeRenderer>;
1611
+ verticalPolyEdgeRenderer: Promise<VerticalPolyEdgeRenderer>;
1612
+ sectionRenderer: Promise<SectionRenderer>;
1613
+ svgNodeRenderer: Promise<SvgNodeRenderer>;
1614
+ latexNodeRenderer: Promise<LatexNodeRenderer>;
1615
+ textNodeRenderer: Promise<TextNodeRenderer>;
1616
+ urlNodeRenderer: Promise<UrlNodeRenderer>;
1617
+ backgroundRenderer: Promise<BackgroundRenderer>;
1618
+ searchContentHighlightRenderer: Promise<SearchContentHighlightRenderer>;
1619
+ renderer: Promise<Renderer>;
1620
+ controller: Promise<Controller>;
1621
+ stageExport: Promise<StageExport>;
1622
+ stageExportPng: Promise<StageExportPng>;
1623
+ stageExportSvg: Promise<StageExportSvg>;
1624
+ stageImport: Promise<StageImport>;
1625
+ generateFromFolder: Promise<GenerateFromFolder>;
1626
+ keyBindHintEngine: Promise<KeyBindHintEngine>;
1627
+ sectionMethods: Promise<SectionMethods>;
1628
+ graphMethods: Promise<GraphMethods>;
1629
+ stageStyleManager: Promise<StageStyleManager>;
1630
+ autoSaveBackup: Promise<AutoSaveBackupService>;
1631
+ referenceManager: Promise<ReferenceManager>;
1613
1632
  }
1614
1633
 
1615
1634
  declare namespace RecentFileManager {
1616
- const store: Store;
1635
+ const store: Promise<Store>;
1617
1636
  declare type RecentFile = {
1618
1637
  uri: URI;
1619
1638
  /**
@@ -1621,50 +1640,50 @@ declare type RecentFile = {
1621
1640
  */
1622
1641
  time: number;
1623
1642
  };
1624
- function init();
1625
- function addRecentFile(file: RecentFile);
1626
- function addRecentFileByUri(uri: URI);
1627
- function addRecentFilesByUris(uris: URI[]);
1628
- function removeRecentFileByUri(uri: URI);
1629
- function clearAllRecentFiles();
1643
+ function init(): Promise<void>;
1644
+ function addRecentFile(file: RecentFile): Promise<void>;
1645
+ function addRecentFileByUri(uri: URI): Promise<void>;
1646
+ function addRecentFilesByUris(uris: URI[]): Promise<void>;
1647
+ function removeRecentFileByUri(uri: URI): Promise<void>;
1648
+ function clearAllRecentFiles(): Promise<void>;
1630
1649
  function getRecentFiles(): Promise<RecentFile[]>;
1631
- function validAndRefreshRecentFiles();
1632
- function sortTimeRecentFiles();
1633
- function clearRecentFiles();
1650
+ function validAndRefreshRecentFiles(): Promise<void>;
1651
+ function sortTimeRecentFiles(): Promise<void>;
1652
+ function clearRecentFiles(): Promise<void>;
1634
1653
  }
1635
1654
 
1636
1655
  declare class RectangleSelect {
1637
- constructor(project: Project);
1656
+ constructor(project: Project | { _: "Project" | string });
1638
1657
  selectStartLocation;
1639
1658
  selectEndLocation;
1640
- getSelectStartLocation(): Vector;
1641
- getSelectEndLocation(): Vector;
1642
- selectingRectangle: Rectangle | null;
1643
- limitSection: Section | null;
1659
+ getSelectStartLocation(): Promise<Vector>;
1660
+ getSelectEndLocation(): Promise<Vector>;
1661
+ selectingRectangle: Promise<Rectangle | null>;
1662
+ limitSection: Promise<Section | null>;
1644
1663
  isSelectDirectionRight;
1645
- getRectangle(): Rectangle | null;
1646
- shutDown();
1647
- startSelecting(worldLocation: Vector);
1648
- moveSelecting(newEndLocation: Vector);
1649
- endSelecting();
1650
- updateStageObjectByMove();
1651
- isSelectWithEntity(entity: StageObject);
1652
- getSelectMode(): "contain" | "intersect";
1653
- getSelectMoveDistance(): number;
1664
+ getRectangle(): Promise<Rectangle | null>;
1665
+ shutDown(): Promise<void>;
1666
+ startSelecting(worldLocation: Vector | { _: "Vector" | string }): Promise<void>;
1667
+ moveSelecting(newEndLocation: Vector | { _: "Vector" | string }): Promise<void>;
1668
+ endSelecting(): Promise<void>;
1669
+ updateStageObjectByMove(): Promise<void>;
1670
+ isSelectWithEntity(entity: StageObject | { _: "StageObject" | string }): Promise<void>;
1671
+ getSelectMode(): Promise<"contain" | "intersect">;
1672
+ getSelectMoveDistance(): Promise<number>;
1654
1673
  }
1655
1674
 
1656
1675
  declare class ReferenceBlockNode extends ConnectableEntity implements ResizeAble {
1657
- isHiddenBySectionCollapse: boolean;
1658
- uuid: string;
1659
- collisionBox: CollisionBox;
1660
- fileName: string;
1661
- sectionName: string;
1662
- scale: number;
1663
- attachmentId: string;
1664
- _isSelected: boolean;
1665
- bitmap: ImageBitmap | undefined;
1666
- state: "loading" | "success" | "notFound";
1667
- constructor(project: Project, {
1676
+ isHiddenBySectionCollapse: Promise<boolean>;
1677
+ uuid: Promise<string>;
1678
+ collisionBox: Promise<CollisionBox>;
1679
+ fileName: Promise<string>;
1680
+ sectionName: Promise<string>;
1681
+ scale: Promise<number>;
1682
+ attachmentId: Promise<string>;
1683
+ _isSelected: Promise<boolean>;
1684
+ bitmap: Promise<ImageBitmap | undefined>;
1685
+ state: Promise<"loading" | "success" | "notFound">;
1686
+ constructor(project: Project | { _: "Project" | string }, {
1668
1687
  uuid = crypto.randomUUID() as string,
1669
1688
  collisionBox = new CollisionBox([new Rectangle(Vector.getZero(), new Vector(400, 200))]),
1670
1689
  fileName = "",
@@ -1673,41 +1692,41 @@ declare class ReferenceBlockNode extends ConnectableEntity implements ResizeAble
1673
1692
  attachmentId = "",
1674
1693
  details = [],
1675
1694
  }, unknown = false);
1676
- get isSelected(): any;
1695
+ get isSelected(): Promise<any>;
1677
1696
  set isSelected(value: boolean);
1678
- loadImageFromAttachment();
1679
- generateScreenshot();
1680
- updateCollisionBox();
1681
- scaleUpdate(scaleDiff: number);
1682
- get rectangle(): Rectangle;
1683
- get geometryCenter(): any;
1684
- move(delta: Vector): void;
1685
- moveTo(location: Vector): void;
1686
- refresh();
1687
- goToSource();
1688
- focusSectionInProject(project: Project);
1689
- resizeHandle(delta: Vector);
1690
- getResizeHandleRect(): Rectangle;
1697
+ loadImageFromAttachment(): Promise<void>;
1698
+ generateScreenshot(): Promise<void>;
1699
+ updateCollisionBox(): Promise<void>;
1700
+ scaleUpdate(scaleDiff: number): Promise<void>;
1701
+ get rectangle(): Promise<Rectangle>;
1702
+ get geometryCenter(): Promise<any>;
1703
+ move(delta: Vector | { _: "Vector" | string }): void;
1704
+ moveTo(location: Vector | { _: "Vector" | string }): void;
1705
+ refresh(): Promise<void>;
1706
+ goToSource(): Promise<void>;
1707
+ focusSectionInProject(project: Project | { _: "Project" | string }): Promise<void>;
1708
+ resizeHandle(delta: Vector | { _: "Vector" | string }): Promise<void>;
1709
+ getResizeHandleRect(): Promise<Rectangle>;
1691
1710
  }
1692
1711
 
1693
1712
  declare class ReferenceBlockRenderer {
1694
- constructor(project: Project);
1695
- render(referenceBlockNode: ReferenceBlockNode);
1696
- renderBrackets(rect: Rectangle, color: Color);
1697
- renderSourceSectionBorder(section: Section, countNumber: number, color: Color = new Color(118, 78, 209));
1713
+ constructor(project: Project | { _: "Project" | string });
1714
+ render(referenceBlockNode: ReferenceBlockNode | { _: "ReferenceBlockNode" | string }): Promise<void>;
1715
+ renderBrackets(rect: Rectangle | { _: "Rectangle" | string }, color: Color | { _: "Color" | string }): Promise<void>;
1716
+ renderSourceSectionBorder(section: Section | { _: "Section" | string }, countNumber: number, color: Color | { _: "Color" | string } = new Color(118, 78, 209)): Promise<void>;
1698
1717
  }
1699
1718
 
1700
1719
  declare class ReferenceManager {
1701
- constructor(project: Project);
1702
- referenceBlockTextParser(text: string): parserResult;
1703
- onClickReferenceNumber(clickLocation: Vector);
1704
- buildSectionName2SectionMap(sectionNames: string[]): Record<string, Section>;
1705
- updateOneSectionReferenceInfo(recentFiles: RecentFileManager.RecentFile[], sectionName: string);
1706
- updateCurrentProjectReference();
1707
- checkReferenceBlockInProject(project: Project, fileName: string, sectionName: string);
1708
- insertRefDataToSourcePrgFile(fileName: string, sectionName: string);
1709
- jumpToReferenceLocation(fileName: string, referenceBlockNodeSectionName: string);
1710
- openSectionReferencePanel(section: Section);
1720
+ constructor(project: Project | { _: "Project" | string });
1721
+ referenceBlockTextParser(text: string): Promise<parserResult>;
1722
+ onClickReferenceNumber(clickLocation: Vector | { _: "Vector" | string }): Promise<void>;
1723
+ buildSectionName2SectionMap(sectionNames: string[]): Promise<Record<string, Section>>;
1724
+ updateOneSectionReferenceInfo(recentFiles: RecentFileManager.RecentFile[], sectionName: string): Promise<void>;
1725
+ updateCurrentProjectReference(): Promise<void>;
1726
+ checkReferenceBlockInProject(project: Project | { _: "Project" | string }, fileName: string, sectionName: string): Promise<void>;
1727
+ insertRefDataToSourcePrgFile(fileName: string, sectionName: string): Promise<void>;
1728
+ jumpToReferenceLocation(fileName: string, referenceBlockNodeSectionName: string): Promise<void>;
1729
+ openSectionReferencePanel(section: Section | { _: "Section" | string }): Promise<void>;
1711
1730
  }
1712
1731
 
1713
1732
  declare class Renderer {
@@ -1716,82 +1735,82 @@ declare class Renderer {
1716
1735
  NODE_ROUNDED_RADIUS;
1717
1736
  w;
1718
1737
  h;
1719
- renderedEdges: number;
1720
- timings: { [key: string]: number };
1738
+ renderedEdges: Promise<number>;
1739
+ timings: Promise<{ [key: string]: number }>;
1721
1740
  deltaTime;
1722
1741
  lastTime;
1723
1742
  frameCount;
1724
1743
  frameIndex;
1725
1744
  fps;
1726
- resizeWindow(newW: number, newH: number);
1727
- constructor(project: Project);
1728
- tick();
1729
- tick_();
1730
- renderViewElements(_viewRectangle: Rectangle);
1731
- renderZoomLevelStage();
1732
- renderMainStageElements(viewRectangle: Rectangle);
1733
- renderStageElementsWithoutReactions(viewRectangle: Rectangle);
1734
- isOverView(viewRectangle: Rectangle, entity: StageObject): boolean;
1735
- renderCenterPointer();
1736
- renderHoverCollisionBox();
1737
- renderSelectingRectangle();
1738
- renderCuttingLine();
1739
- renderConnectingLine();
1740
- renderCrosshairOnHoverImage();
1741
- renderKeyboardOnly();
1742
- rendererLayerMovingLine();
1743
- renderJumpLine(startLocation: Vector, endLocation: Vector);
1744
- renderWarningStageObjects();
1745
- renderTags();
1746
- renderEntities(viewRectangle: Rectangle);
1747
- renderEdges(viewRectangle: Rectangle);
1748
- renderBackground();
1749
- updateFPS();
1750
- renderDebugDetails();
1751
- renderSpecialKeys();
1752
- transformWorld2View(location: Vector): Vector;
1753
- transformWorld2View(rectangle: Rectangle): Rectangle;
1754
- transformWorld2View(arg1: Vector | Rectangle): Vector | Rectangle;
1755
- transformView2World(location: Vector): Vector;
1756
- transformView2World(rectangle: Rectangle): Rectangle;
1757
- transformView2World(arg1: Vector | Rectangle): Vector | Rectangle;
1758
- getCoverWorldRectangle(): Rectangle;
1745
+ resizeWindow(newW: number, newH: number): Promise<void>;
1746
+ constructor(project: Project | { _: "Project" | string });
1747
+ tick(): Promise<void>;
1748
+ tick_(): Promise<void>;
1749
+ renderViewElements(_viewRectangle: Rectangle | { _: "Rectangle" | string }): Promise<void>;
1750
+ renderZoomLevelStage(): Promise<void>;
1751
+ renderMainStageElements(viewRectangle: Rectangle | { _: "Rectangle" | string }): Promise<void>;
1752
+ renderStageElementsWithoutReactions(viewRectangle: Rectangle | { _: "Rectangle" | string }): Promise<void>;
1753
+ isOverView(viewRectangle: Rectangle | { _: "Rectangle" | string }, entity: StageObject | { _: "StageObject" | string }): Promise<boolean>;
1754
+ renderCenterPointer(): Promise<void>;
1755
+ renderHoverCollisionBox(): Promise<void>;
1756
+ renderSelectingRectangle(): Promise<void>;
1757
+ renderCuttingLine(): Promise<void>;
1758
+ renderConnectingLine(): Promise<void>;
1759
+ renderCrosshairOnHoverImage(): Promise<void>;
1760
+ renderKeyboardOnly(): Promise<void>;
1761
+ rendererLayerMovingLine(): Promise<void>;
1762
+ renderJumpLine(startLocation: Vector | { _: "Vector" | string }, endLocation: Vector | { _: "Vector" | string }): Promise<void>;
1763
+ renderWarningStageObjects(): Promise<void>;
1764
+ renderTags(): Promise<void>;
1765
+ renderEntities(viewRectangle: Rectangle | { _: "Rectangle" | string }): Promise<void>;
1766
+ renderEdges(viewRectangle: Rectangle | { _: "Rectangle" | string }): Promise<void>;
1767
+ renderBackground(): Promise<void>;
1768
+ updateFPS(): Promise<void>;
1769
+ renderDebugDetails(): Promise<void>;
1770
+ renderSpecialKeys(): Promise<void>;
1771
+ transformWorld2View(location: Vector | { _: "Vector" | string }): Promise<Vector>;
1772
+ transformWorld2View(rectangle: Rectangle | { _: "Rectangle" | string }): Promise<Rectangle>;
1773
+ transformWorld2View(arg1: Vector | Rectangle): Promise<Vector | Rectangle>;
1774
+ transformView2World(location: Vector | { _: "Vector" | string }): Promise<Vector>;
1775
+ transformView2World(rectangle: Rectangle | { _: "Rectangle" | string }): Promise<Rectangle>;
1776
+ transformView2World(arg1: Vector | Rectangle): Promise<Vector | Rectangle>;
1777
+ getCoverWorldRectangle(): Promise<Rectangle>;
1759
1778
  }
1760
1779
 
1761
1780
  declare class RenderUtils {
1762
- constructor(project: Project);
1763
- renderPixel(location: Vector, color: Color);
1764
- renderArrow(direction: Vector, location: Vector, color: Color, size: number);
1781
+ constructor(project: Project | { _: "Project" | string });
1782
+ renderPixel(location: Vector | { _: "Vector" | string }, color: Color | { _: "Color" | string }): Promise<void>;
1783
+ renderArrow(direction: Vector | { _: "Vector" | string }, location: Vector | { _: "Vector" | string }, color: Color | { _: "Color" | string }, size: number): Promise<void>;
1765
1784
  }
1766
1785
 
1767
1786
  declare interface ResizeAble {
1768
- resizeHandle(delta: Vector): void;
1769
- getResizeHandleRect(): Rectangle;
1787
+ resizeHandle(delta: Vector | { _: "Vector" | string }): void;
1788
+ getResizeHandleRect(): Promise<Rectangle>;
1770
1789
  }
1771
1790
 
1772
1791
  declare class SearchContentHighlightRenderer {
1773
- constructor(project: Project);
1774
- render(frameTickIndex: number);
1792
+ constructor(project: Project | { _: "Project" | string });
1793
+ render(frameTickIndex: number): Promise<void>;
1775
1794
  }
1776
1795
 
1777
1796
  declare class Section extends ConnectableEntity {
1778
- _isSelected: boolean;
1779
- uuid: string;
1780
- _isEditingTitle: boolean;
1781
- _collisionBoxWhenCollapsed: CollisionBox;
1782
- _collisionBoxNormal: CollisionBox;
1783
- get isEditingTitle(): any;
1797
+ _isSelected: Promise<boolean>;
1798
+ uuid: Promise<string>;
1799
+ _isEditingTitle: Promise<boolean>;
1800
+ _collisionBoxWhenCollapsed: Promise<CollisionBox>;
1801
+ _collisionBoxNormal: Promise<CollisionBox>;
1802
+ get isEditingTitle(): Promise<any>;
1784
1803
  set isEditingTitle(value: boolean);
1785
1804
  bigTitleCameraScale;
1786
- get collisionBox(): CollisionBox;
1787
- collapsedCollisionBox(): CollisionBox;
1788
- color: Color;
1789
- text: string;
1790
- children: Entity[];
1791
- isCollapsed: boolean;
1792
- locked: boolean;
1805
+ get collisionBox(): Promise<CollisionBox>;
1806
+ collapsedCollisionBox(): Promise<CollisionBox>;
1807
+ color: Promise<Color>;
1808
+ text: Promise<string>;
1809
+ children: Promise<Entity>[];
1810
+ isCollapsed: Promise<boolean>;
1811
+ locked: Promise<boolean>;
1793
1812
  isHiddenBySectionCollapse;
1794
- constructor(project: Project, {
1813
+ constructor(project: Project | { _: "Project" | string }, {
1795
1814
  uuid = crypto.randomUUID() as string,
1796
1815
  text = "",
1797
1816
  collisionBox = new CollisionBox([new Rectangle(new Vector(0, 0), new Vector(0, 0))]),
@@ -1802,107 +1821,107 @@ declare class Section extends ConnectableEntity {
1802
1821
  children = [] as Entity[],
1803
1822
  details = [] as Value,
1804
1823
  } = {}, unknown = false);
1805
- fromEntities(project: Project, entities: Entity[]): Section;
1806
- rename(newName: string);
1807
- adjustLocationAndSize();
1808
- adjustChildrenStateByCollapse(parentCollapsed = false);
1809
- get isSelected(): any;
1824
+ fromEntities(project: Project | { _: "Project" | string }, entities: Entity[]): Promise<Section>;
1825
+ rename(newName: string): Promise<void>;
1826
+ adjustLocationAndSize(): Promise<void>;
1827
+ adjustChildrenStateByCollapse(parentCollapsed = false): Promise<void>;
1828
+ get isSelected(): Promise<any>;
1810
1829
  set isSelected(value: boolean);
1811
- get rectangle(): Rectangle;
1812
- get geometryCenter(): any;
1813
- move(delta: Vector): void;
1814
- collideWithOtherEntity(other: Entity): void;
1815
- moveTo(location: Vector): void;
1830
+ get rectangle(): Promise<Rectangle>;
1831
+ get geometryCenter(): Promise<any>;
1832
+ move(delta: Vector | { _: "Vector" | string }): void;
1833
+ collideWithOtherEntity(other: Entity | { _: "Entity" | string }): void;
1834
+ moveTo(location: Vector | { _: "Vector" | string }): void;
1816
1835
  }
1817
1836
 
1818
1837
  declare class SectionCollisionSolver {
1819
- constructor(project: Project);
1820
- solveOverlaps(grownSection: Section, visited: Set<string> = new Set()): void;
1821
- updateAncestorsAfterShift(entity: Entity, visited: Set<string>): void;
1822
- getSiblingsSections(section: Section): Section[];
1823
- computePushDelta(grownRect: Rectangle, siblingRect: Rectangle): Vector;
1824
- rawShiftEntityTree(entity: Entity, delta: Vector): void;
1838
+ constructor(project: Project | { _: "Project" | string });
1839
+ solveOverlaps(grownSection: Section | { _: "Section" | string }, visited: Set<string> = new Set()): void;
1840
+ updateAncestorsAfterShift(entity: Entity | { _: "Entity" | string }, visited: Set<string>): void;
1841
+ getSiblingsSections(section: Section | { _: "Section" | string }): Promise<Section>[];
1842
+ computePushDelta(grownRect: Rectangle | { _: "Rectangle" | string }, siblingRect: Rectangle | { _: "Rectangle" | string }): Promise<Vector>;
1843
+ rawShiftEntityTree(entity: Entity | { _: "Entity" | string }, delta: Vector | { _: "Vector" | string }): void;
1825
1844
  }
1826
1845
 
1827
1846
  declare class SectionInOutManager {
1828
- constructor(project: Project);
1829
- goInSection(entities: Entity[], section: Section);
1830
- goInSections(entities: Entity[], sections: Section[]);
1831
- goOutSection(entities: Entity[], section: Section);
1832
- entityDropParent(entity: Entity);
1833
- sectionDropChild(section: Section, entity: Entity);
1834
- convertSectionToTextNode(section: Section);
1847
+ constructor(project: Project | { _: "Project" | string });
1848
+ goInSection(entities: Entity[], section: Section | { _: "Section" | string }): Promise<void>;
1849
+ goInSections(entities: Entity[], sections: Section[]): Promise<void>;
1850
+ goOutSection(entities: Entity[], section: Section | { _: "Section" | string }): Promise<void>;
1851
+ entityDropParent(entity: Entity | { _: "Entity" | string }): Promise<void>;
1852
+ sectionDropChild(section: Section | { _: "Section" | string }, entity: Entity | { _: "Entity" | string }): Promise<void>;
1853
+ convertSectionToTextNode(section: Section | { _: "Section" | string }): Promise<void>;
1835
1854
  }
1836
1855
 
1837
1856
  declare class SectionMethods {
1838
- constructor(project: Project);
1839
- getFatherSections(entity: Entity): Section[];
1840
- isObjectBeLockedBySection(object: StageObject): boolean;
1841
- getFatherSectionsList(entity: Entity): Section[];
1842
- getSectionsByInnerLocation(location: Vector): Section[];
1843
- deeperSections(sections: Section[]): Section[];
1844
- shallowerSection(sections: Section[]): Section[];
1845
- shallowerNotSectionEntities(entities: Entity[]): Entity[];
1846
- isEntityInSection(entity: Entity, section: Section): boolean;
1847
- isEntityInSection_fake(entity: Entity, section: Section): boolean;
1848
- _isEntityInSection(entity: Entity, section: Section, deep = 0): boolean;
1849
- isTreePack(rootNode: Section);
1850
- getSectionMaxDeep(section: Section): number;
1851
- getAllEntitiesInSelectedSectionsOrEntities(selectedEntities: Entity[]): Entity[];
1852
- getSortedSectionsByZ(sections: Section[]): Section[];
1857
+ constructor(project: Project | { _: "Project" | string });
1858
+ getFatherSections(entity: Entity | { _: "Entity" | string }): Promise<Section>[];
1859
+ isObjectBeLockedBySection(object: StageObject | { _: "StageObject" | string }): Promise<boolean>;
1860
+ getFatherSectionsList(entity: Entity | { _: "Entity" | string }): Promise<Section>[];
1861
+ getSectionsByInnerLocation(location: Vector | { _: "Vector" | string }): Promise<Section>[];
1862
+ deeperSections(sections: Section[]): Promise<Section>[];
1863
+ shallowerSection(sections: Section[]): Promise<Section>[];
1864
+ shallowerNotSectionEntities(entities: Entity[]): Promise<Entity>[];
1865
+ isEntityInSection(entity: Entity | { _: "Entity" | string }, section: Section | { _: "Section" | string }): Promise<boolean>;
1866
+ isEntityInSection_fake(entity: Entity | { _: "Entity" | string }, section: Section | { _: "Section" | string }): Promise<boolean>;
1867
+ _isEntityInSection(entity: Entity | { _: "Entity" | string }, section: Section | { _: "Section" | string }, deep = 0): Promise<boolean>;
1868
+ isTreePack(rootNode: Section | { _: "Section" | string }): Promise<void>;
1869
+ getSectionMaxDeep(section: Section | { _: "Section" | string }): Promise<number>;
1870
+ getAllEntitiesInSelectedSectionsOrEntities(selectedEntities: Entity[]): Promise<Entity>[];
1871
+ getSortedSectionsByZ(sections: Section[]): Promise<Section>[];
1853
1872
  }
1854
1873
 
1855
1874
  declare class SectionPackManager {
1856
- constructor(project: Project);
1875
+ constructor(project: Project | { _: "Project" | string });
1857
1876
  packSection(): void;
1858
- modifyHiddenDfs(section: Section, isCollapsed: boolean);
1877
+ modifyHiddenDfs(section: Section | { _: "Section" | string }, isCollapsed: boolean): Promise<void>;
1859
1878
  unpackSection(): void;
1860
1879
  switchCollapse(): void;
1861
1880
  textNodeToSection(): void;
1862
- textNodeTreeToSection(rootNode: TextNode): void;
1863
- textNodeTreeToSectionNoDeep(rootNode: TextNode): void;
1864
- targetTextNodeToSection(textNode: TextNode, ignoreEdges: boolean = false, addConnectPoints: boolean = false): Section;
1865
- unpackSelectedSections();
1866
- unpackSections(entities: Entity[]);
1867
- packEntityToSection(addEntities: Entity[]);
1881
+ textNodeTreeToSection(rootNode: TextNode | { _: "TextNode" | string }): void;
1882
+ textNodeTreeToSectionNoDeep(rootNode: TextNode | { _: "TextNode" | string }): void;
1883
+ targetTextNodeToSection(textNode: TextNode | { _: "TextNode" | string }, ignoreEdges: boolean = false, addConnectPoints: boolean = false): Promise<Section>;
1884
+ unpackSelectedSections(): Promise<void>;
1885
+ unpackSections(entities: Entity[]): Promise<void>;
1886
+ packEntityToSection(addEntities: Entity[]): Promise<void>;
1868
1887
  createSectionFromSelectionRectangle(): void;
1869
1888
  packSelectedEntitiesToSection(): void;
1870
- getSmartSectionTitle(addEntities: Entity[]): string;
1889
+ getSmartSectionTitle(addEntities: Entity[]): Promise<string>;
1871
1890
  }
1872
1891
 
1873
1892
  declare class SectionRenderer {
1874
- constructor(project: Project);
1875
- renderCollapsed(section: Section);
1876
- renderNoCollapse(section: Section);
1877
- renderBackgroundColor(section: Section);
1878
- renderBigCoveredTitle(section: Section);
1879
- renderTopTitle(section: Section);
1880
- render(section: Section): void;
1893
+ constructor(project: Project | { _: "Project" | string });
1894
+ renderCollapsed(section: Section | { _: "Section" | string }): Promise<void>;
1895
+ renderNoCollapse(section: Section | { _: "Section" | string }): Promise<void>;
1896
+ renderBackgroundColor(section: Section | { _: "Section" | string }): Promise<void>;
1897
+ renderBigCoveredTitle(section: Section | { _: "Section" | string }): Promise<void>;
1898
+ renderTopTitle(section: Section | { _: "Section" | string }): Promise<void>;
1899
+ render(section: Section | { _: "Section" | string }): void;
1881
1900
  }
1882
1901
 
1883
1902
  declare class SelectChangeEngine {
1884
1903
  lastSelectNodeByKeyboardUUID;
1885
- constructor(project: Project);
1886
- selectUp(addSelect = false);
1887
- selectDown(addSelect = false);
1888
- selectLeft(addSelect = false);
1889
- selectRight(addSelect = false);
1890
- navigateInDirection(selectedNode: ConnectableEntity, direction: Direction): ConnectableEntity | null;
1891
- getSameLevelCandidates(parentSection: Section, excludeNode: ConnectableEntity): ConnectableEntity[];
1892
- getTopLevelCandidates(excludeNode: ConnectableEntity): ConnectableEntity[];
1893
- expandSelect(isKeepExpand = false, reversed: boolean = false);
1894
- afterSelect(selectedNodeRect: ConnectableEntity, newSelectedConnectableEntity: ConnectableEntity | null, clearOldSelect = true);
1895
- getCurrentSelectedNode(): ConnectableEntity | null;
1896
- addEffect(selectedNodeRect: Rectangle, newSelectNodeRect: Rectangle);
1897
- getMostNearConnectableEntity(nodes: ConnectableEntity[], location: Vector): ConnectableEntity | null;
1898
- selectMostNearLocationNode(location: Vector): ConnectableEntity | null;
1899
- collectNodesInStrip(node: ConnectableEntity, direction: Direction, candidates: ConnectableEntity[]): ConnectableEntity[];
1900
- getMostNearInStripByDh(nodes: ConnectableEntity[], nodeRect: Rectangle, direction: Direction): ConnectableEntity | null;
1901
- collectFanNodes(node: ConnectableEntity, direction: Direction, candidates: ConnectableEntity[]): ConnectableEntity[];
1902
- collectTopNodes(node: ConnectableEntity, candidates?: ConnectableEntity[]): ConnectableEntity[];
1903
- collectBottomNodes(node: ConnectableEntity, candidates?: ConnectableEntity[]): ConnectableEntity[];
1904
- collectLeftNodes(node: ConnectableEntity, candidates?: ConnectableEntity[]): ConnectableEntity[];
1905
- collectRightNodes(node: ConnectableEntity, candidates?: ConnectableEntity[]): ConnectableEntity[];
1904
+ constructor(project: Project | { _: "Project" | string });
1905
+ selectUp(addSelect = false): Promise<void>;
1906
+ selectDown(addSelect = false): Promise<void>;
1907
+ selectLeft(addSelect = false): Promise<void>;
1908
+ selectRight(addSelect = false): Promise<void>;
1909
+ navigateInDirection(selectedNode: ConnectableEntity | { _: "ConnectableEntity" | string }, direction: Direction): Promise<ConnectableEntity | null>;
1910
+ getSameLevelCandidates(parentSection: Section | { _: "Section" | string }, excludeNode: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<ConnectableEntity>[];
1911
+ getTopLevelCandidates(excludeNode: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<ConnectableEntity>[];
1912
+ expandSelect(isKeepExpand = false, reversed: boolean = false): Promise<void>;
1913
+ afterSelect(selectedNodeRect: ConnectableEntity | { _: "ConnectableEntity" | string }, newSelectedConnectableEntity: ConnectableEntity | null, clearOldSelect = true): Promise<void>;
1914
+ getCurrentSelectedNode(): Promise<ConnectableEntity | null>;
1915
+ addEffect(selectedNodeRect: Rectangle | { _: "Rectangle" | string }, newSelectNodeRect: Rectangle | { _: "Rectangle" | string }): Promise<void>;
1916
+ getMostNearConnectableEntity(nodes: ConnectableEntity[], location: Vector | { _: "Vector" | string }): Promise<ConnectableEntity | null>;
1917
+ selectMostNearLocationNode(location: Vector | { _: "Vector" | string }): Promise<ConnectableEntity | null>;
1918
+ collectNodesInStrip(node: ConnectableEntity | { _: "ConnectableEntity" | string }, direction: Direction, candidates: ConnectableEntity[]): Promise<ConnectableEntity>[];
1919
+ getMostNearInStripByDh(nodes: ConnectableEntity[], nodeRect: Rectangle | { _: "Rectangle" | string }, direction: Direction): Promise<ConnectableEntity | null>;
1920
+ collectFanNodes(node: ConnectableEntity | { _: "ConnectableEntity" | string }, direction: Direction, candidates: ConnectableEntity[]): Promise<ConnectableEntity>[];
1921
+ collectTopNodes(node: ConnectableEntity | { _: "ConnectableEntity" | string }, candidates?: ConnectableEntity[]): Promise<ConnectableEntity>[];
1922
+ collectBottomNodes(node: ConnectableEntity | { _: "ConnectableEntity" | string }, candidates?: ConnectableEntity[]): Promise<ConnectableEntity>[];
1923
+ collectLeftNodes(node: ConnectableEntity | { _: "ConnectableEntity" | string }, candidates?: ConnectableEntity[]): Promise<ConnectableEntity>[];
1924
+ collectRightNodes(node: ConnectableEntity | { _: "ConnectableEntity" | string }, candidates?: ConnectableEntity[]): Promise<ConnectableEntity>[];
1906
1925
  }
1907
1926
 
1908
1927
  declare namespace Serialized {
@@ -1924,7 +1943,7 @@ declare type TextNode = Entity & {
1924
1943
  color: Color;
1925
1944
  sizeAdjust: TextNodeSizeAdjust;
1926
1945
  };
1927
- function isTextNode(obj: StageObject): obj is TextNode;
1946
+ function isTextNode(obj: StageObject | { _: "StageObject" | string }): obj is TextNode;
1928
1947
  declare type Section = Entity & {
1929
1948
  type: "core:section";
1930
1949
  size: Vector;
@@ -1935,18 +1954,18 @@ declare type Section = Entity & {
1935
1954
  isHidden: boolean;
1936
1955
  isCollapsed: boolean;
1937
1956
  };
1938
- function isSection(obj: StageObject): obj is Section;
1957
+ function isSection(obj: StageObject | { _: "StageObject" | string }): obj is Section;
1939
1958
  declare type ConnectPoint = Entity & {
1940
1959
  type: "core:connect_point";
1941
1960
  };
1942
- function isConnectPoint(obj: StageObject): obj is ConnectPoint;
1961
+ function isConnectPoint(obj: StageObject | { _: "StageObject" | string }): obj is ConnectPoint;
1943
1962
  declare type ImageNode = Entity & {
1944
1963
  path: string;
1945
1964
  size: Vector;
1946
1965
  scale: number;
1947
1966
  type: "core:image_node";
1948
1967
  };
1949
- function isImageNode(obj: StageObject): obj is ImageNode;
1968
+ function isImageNode(obj: StageObject | { _: "StageObject" | string }): obj is ImageNode;
1950
1969
  declare type UrlNode = Entity & {
1951
1970
  url: string;
1952
1971
  title: string;
@@ -1954,7 +1973,7 @@ declare type UrlNode = Entity & {
1954
1973
  color: Color;
1955
1974
  type: "core:url_node";
1956
1975
  };
1957
- function isUrlNode(obj: StageObject): obj is UrlNode;
1976
+ function isUrlNode(obj: StageObject | { _: "StageObject" | string }): obj is UrlNode;
1958
1977
  declare type PortalNode = Entity & {
1959
1978
  // 连接的文件
1960
1979
  portalFilePath: string;
@@ -1968,13 +1987,13 @@ declare type PortalNode = Entity & {
1968
1987
  color: Color;
1969
1988
  type: "core:portal_node";
1970
1989
  };
1971
- function isPortalNode(obj: StageObject): obj is PortalNode;
1990
+ function isPortalNode(obj: StageObject | { _: "StageObject" | string }): obj is PortalNode;
1972
1991
  declare type PenStroke = Entity & {
1973
1992
  type: "core:pen_stroke";
1974
1993
  content: string;
1975
1994
  color: Color;
1976
1995
  };
1977
- function isPenStroke(obj: StageObject): obj is PenStroke;
1996
+ function isPenStroke(obj: StageObject | { _: "StageObject" | string }): obj is PenStroke;
1978
1997
  declare type SvgNode = Entity & {
1979
1998
  type: "core:svg_node";
1980
1999
  content: string;
@@ -1982,7 +2001,7 @@ declare type SvgNode = Entity & {
1982
2001
  color: Color;
1983
2002
  scale: number;
1984
2003
  };
1985
- function isSvgNode(obj: StageObject): obj is SvgNode;
2004
+ function isSvgNode(obj: StageObject | { _: "StageObject" | string }): obj is SvgNode;
1986
2005
  declare type Association = StageObject & {
1987
2006
  text: string;
1988
2007
  color: Color;
@@ -1998,21 +2017,21 @@ declare type MultiTargetUndirectedEdge = Association & {
1998
2017
  padding: number;
1999
2018
  renderType: MultiTargetUndirectedEdgeRenderType;
2000
2019
  };
2001
- function isMultiTargetUndirectedEdge(obj: StageObject): obj is MultiTargetUndirectedEdge;
2020
+ function isMultiTargetUndirectedEdge(obj: StageObject | { _: "StageObject" | string }): obj is MultiTargetUndirectedEdge;
2002
2021
  declare type Edge = Association & {
2003
2022
  source: string;
2004
2023
  target: string;
2005
2024
  sourceRectRate: [number, number]; // 默认中心 0.5, 0.5
2006
2025
  targetRectRate: [number, number]; // 默认中心 0.5, 0.5
2007
2026
  };
2008
- function isEdge(obj: StageObject): obj is Edge;
2027
+ function isEdge(obj: StageObject | { _: "StageObject" | string }): obj is Edge;
2009
2028
  declare type LineEdge = Edge & {
2010
2029
  type: "core:line_edge";
2011
2030
  color: Color;
2012
2031
  text: string;
2013
2032
  };
2014
- function isLineEdge(obj: StageObject): obj is LineEdge;
2015
- function isCubicCatmullRomSplineEdge(obj: StageObject): obj is CubicCatmullRomSplineEdge;
2033
+ function isLineEdge(obj: StageObject | { _: "StageObject" | string }): obj is LineEdge;
2034
+ function isCubicCatmullRomSplineEdge(obj: StageObject | { _: "StageObject" | string }): obj is CubicCatmullRomSplineEdge;
2016
2035
  declare type CubicCatmullRomSplineEdge = Edge & {
2017
2036
  type: "core:cublic_catmull_rom_spline_edge";
2018
2037
  text: string;
@@ -2021,7 +2040,7 @@ declare type CubicCatmullRomSplineEdge = Edge & {
2021
2040
  tension: number;
2022
2041
  };
2023
2042
  declare type CoreEntity = TextNode | Section | ConnectPoint | ImageNode | UrlNode | PenStroke | PortalNode | SvgNode;
2024
- function isCoreEntity(obj: StageObject): obj is CoreEntity;
2043
+ function isCoreEntity(obj: StageObject | { _: "StageObject" | string }): obj is CoreEntity;
2025
2044
  declare type CoreAssociation = LineEdge | CubicCatmullRomSplineEdge | MultiTargetUndirectedEdge;
2026
2045
  declare type File = {
2027
2046
  version: typeof Project.latestVersion;
@@ -2033,194 +2052,194 @@ declare type File = {
2033
2052
 
2034
2053
  declare interface Service {
2035
2054
  tick(): void;
2036
- dispose(): void | Promise<void>;
2055
+ dispose(): Promise<void | Promise<void>>;
2037
2056
  }
2038
2057
 
2039
2058
  declare type Settings = z.infer<typeof settingsSchema>;
2040
2059
 
2041
2060
  declare class ShapeRenderer {
2042
- constructor(project: Project);
2043
- renderCircle(centerLocation: Vector, radius: number, color: Color, strokeColor: Color, strokeWidth: number): void;
2044
- renderArc(centerLocation: Vector, radius: number, angle1: number, angle2: number, strokeColor: Color, strokeWidth: number): void;
2045
- renderRectFromCenter(centerLocation: Vector, width: number, height: number, color: Color, strokeColor: Color, strokeWidth: number, radius: number = 0): void;
2046
- renderRect(rect: Rectangle, color: Color, strokeColor: Color, strokeWidth: number, radius: number = 0);
2047
- renderDashedRect(rect: Rectangle, color: Color, strokeColor: Color, strokeWidth: number, radius: number = 0, dashLength = 5);
2048
- renderRectWithShadow(rect: Rectangle, fillColor: Color, strokeColor: Color, strokeWidth: number, shadowColor: Color, shadowBlur: number, shadowOffsetX: number = 0, shadowOffsetY: number = 0, radius: number = 0);
2049
- renderPolygonAndFill(points: Vector[], fillColor: Color, strokeColor: Color, strokeWidth: number, lineJoin: "round" | "bevel" = "round"): void;
2050
- renderTriangleFromCenter(centerLocation: Vector, size: number, rotation: number, fillColor: Color, strokeColor: Color, strokeWidth: number): void;
2051
- renderSquareFromCenter(centerLocation: Vector, size: number, rotation: number, fillColor: Color, strokeColor: Color, strokeWidth: number): void;
2052
- renderCircleTransition(viewLocation: Vector, radius: number, centerColor: Color);
2053
- renderCameraShapeBorder(rect: Rectangle, borderColor: Color, borderWidth: number);
2054
- renderResizeArrow(rect: Rectangle, color: Color, strokeWidth: number);
2061
+ constructor(project: Project | { _: "Project" | string });
2062
+ renderCircle(centerLocation: Vector | { _: "Vector" | string }, radius: number, color: Color | { _: "Color" | string }, strokeColor: Color | { _: "Color" | string }, strokeWidth: number): void;
2063
+ renderArc(centerLocation: Vector | { _: "Vector" | string }, radius: number, angle1: number, angle2: number, strokeColor: Color | { _: "Color" | string }, strokeWidth: number): void;
2064
+ renderRectFromCenter(centerLocation: Vector | { _: "Vector" | string }, width: number, height: number, color: Color | { _: "Color" | string }, strokeColor: Color | { _: "Color" | string }, strokeWidth: number, radius: number = 0): void;
2065
+ renderRect(rect: Rectangle | { _: "Rectangle" | string }, color: Color | { _: "Color" | string }, strokeColor: Color | { _: "Color" | string }, strokeWidth: number, radius: number = 0): Promise<void>;
2066
+ renderDashedRect(rect: Rectangle | { _: "Rectangle" | string }, color: Color | { _: "Color" | string }, strokeColor: Color | { _: "Color" | string }, strokeWidth: number, radius: number = 0, dashLength = 5): Promise<void>;
2067
+ renderRectWithShadow(rect: Rectangle | { _: "Rectangle" | string }, fillColor: Color | { _: "Color" | string }, strokeColor: Color | { _: "Color" | string }, strokeWidth: number, shadowColor: Color | { _: "Color" | string }, shadowBlur: number, shadowOffsetX: number = 0, shadowOffsetY: number = 0, radius: number = 0): Promise<void>;
2068
+ renderPolygonAndFill(points: Vector[], fillColor: Color | { _: "Color" | string }, strokeColor: Color | { _: "Color" | string }, strokeWidth: number, lineJoin: "round" | "bevel" = "round"): void;
2069
+ renderTriangleFromCenter(centerLocation: Vector | { _: "Vector" | string }, size: number, rotation: number, fillColor: Color | { _: "Color" | string }, strokeColor: Color | { _: "Color" | string }, strokeWidth: number): void;
2070
+ renderSquareFromCenter(centerLocation: Vector | { _: "Vector" | string }, size: number, rotation: number, fillColor: Color | { _: "Color" | string }, strokeColor: Color | { _: "Color" | string }, strokeWidth: number): void;
2071
+ renderCircleTransition(viewLocation: Vector | { _: "Vector" | string }, radius: number, centerColor: Color | { _: "Color" | string }): Promise<void>;
2072
+ renderCameraShapeBorder(rect: Rectangle | { _: "Rectangle" | string }, borderColor: Color | { _: "Color" | string }, borderWidth: number): Promise<void>;
2073
+ renderResizeArrow(rect: Rectangle | { _: "Rectangle" | string }, color: Color | { _: "Color" | string }, strokeWidth: number): Promise<void>;
2055
2074
  }
2056
2075
 
2057
2076
  declare class StageExport {
2058
- plainTextExporter: PlainTextExporter;
2059
- markdownExporter: MarkdownExporter;
2060
- tabExporter: TabExporter;
2061
- mermaidExporter: MermaidExporter;
2062
- constructor(project: Project);
2063
- getPlainTextByEntities(nodes: Entity[]);
2064
- getMarkdownStringByTextNode(textNode: TextNode);
2065
- getTabStringByTextNode(textNode: TextNode);
2066
- getMermaidTextByEntities(entities: Entity[]): string;
2077
+ plainTextExporter: Promise<PlainTextExporter>;
2078
+ markdownExporter: Promise<MarkdownExporter>;
2079
+ tabExporter: Promise<TabExporter>;
2080
+ mermaidExporter: Promise<MermaidExporter>;
2081
+ constructor(project: Project | { _: "Project" | string });
2082
+ getPlainTextByEntities(nodes: Entity[]): Promise<void>;
2083
+ getMarkdownStringByTextNode(textNode: TextNode | { _: "TextNode" | string }): Promise<void>;
2084
+ getTabStringByTextNode(textNode: TextNode | { _: "TextNode" | string }): Promise<void>;
2085
+ getMermaidTextByEntities(entities: Entity[]): Promise<string>;
2067
2086
  }
2068
2087
 
2069
2088
  declare class StageExportPng {
2070
- constructor(project: Project);
2071
- exportStage_(emitter: EventEmitter<EventMap>, signal: AbortSignal, sleepTime: number);
2072
- exportStage(signal: AbortSignal, sleepTime: number = 2);
2073
- generateCanvasNode(): HTMLCanvasElement;
2089
+ constructor(project: Project | { _: "Project" | string });
2090
+ exportStage_(emitter: EventEmitter<EventMap>, signal: AbortSignal, sleepTime: number): Promise<void>;
2091
+ exportStage(signal: AbortSignal, sleepTime: number = 2): Promise<void>;
2092
+ generateCanvasNode(): Promise<HTMLCanvasElement>;
2074
2093
  }
2075
2094
 
2076
2095
  declare class StageExportSvg {
2077
- constructor(project: Project);
2078
- svgConfig: SvgExportConfig;
2079
- exportContext: {
2096
+ constructor(project: Project | { _: "Project" | string });
2097
+ svgConfig: Promise<SvgExportConfig>;
2098
+ exportContext: Promise<{
2080
2099
  outputDir: string;
2081
2100
  imageMap: Map<string, string>; // attachmentId -> relative file path
2082
- } | null;
2083
- setConfig(config: SvgExportConfig);
2084
- dumpNode(node: TextNode);
2085
- dumpSection(section: Section);
2086
- dumpSectionBase(section: Section);
2087
- dumpEdge(edge: LineEdge): React.ReactNode;
2088
- dumpEntityDetails(entity: Entity): React.ReactNode;
2089
- getEntityDetailsDataAttribute(entity: Entity): string | undefined;
2090
- dumpUrlNode(node: UrlNode);
2091
- dumpImageNode(node: ImageNode, svgConfigObject: SvgExportConfig);
2092
- getEntitiesOuterRectangle(entities: Entity[], padding: number): Rectangle;
2093
- dumpSelected(): React.ReactNode;
2094
- dumpStage(): React.ReactNode;
2095
- dumpStageToSVGString(): string;
2096
- dumpSelectedToSVGString(): string;
2101
+ } | null>;
2102
+ setConfig(config: SvgExportConfig): Promise<void>;
2103
+ dumpNode(node: TextNode | { _: "TextNode" | string }): Promise<void>;
2104
+ dumpSection(section: Section | { _: "Section" | string }): Promise<void>;
2105
+ dumpSectionBase(section: Section | { _: "Section" | string }): Promise<void>;
2106
+ dumpEdge(edge: LineEdge | { _: "LineEdge" | string }): Promise<React.ReactNode>;
2107
+ dumpEntityDetails(entity: Entity | { _: "Entity" | string }): Promise<React.ReactNode>;
2108
+ getEntityDetailsDataAttribute(entity: Entity | { _: "Entity" | string }): Promise<string | undefined>;
2109
+ dumpUrlNode(node: UrlNode | { _: "UrlNode" | string }): Promise<void>;
2110
+ dumpImageNode(node: ImageNode | { _: "ImageNode" | string }, svgConfigObject: SvgExportConfig): Promise<void>;
2111
+ getEntitiesOuterRectangle(entities: Entity[], padding: number): Promise<Rectangle>;
2112
+ dumpSelected(): Promise<React.ReactNode>;
2113
+ dumpStage(): Promise<React.ReactNode>;
2114
+ dumpStageToSVGString(): Promise<string>;
2115
+ dumpSelectedToSVGString(): Promise<string>;
2097
2116
  exportStageToSVGFile(filePath: string): Promise<void>;
2098
2117
  exportSelectedToSVGFile(filePath: string): Promise<void>;
2099
2118
  }
2100
2119
 
2101
2120
  declare class StageImport {
2102
- graphImporter: GraphImporter;
2103
- treeImporter: TreeImporter;
2104
- mermaidImporter: MermaidImporter;
2105
- markdownImporter: MarkdownImporter;
2106
- constructor(project: Project);
2107
- addNodeGraphByText(text: string, diffLocation: Vector = Vector.getZero());
2108
- addNodeTreeByText(text: string, indention: number, diffLocation: Vector = Vector.getZero());
2109
- addNodeTreeByTextFromNode(uuid: string, text: string, indention: number): { success: boolean; error?: string; nodeCount?: number };
2110
- addNodeMermaidByText(text: string, diffLocation: Vector = Vector.getZero());
2111
- addNodeByMarkdown(markdownText: string, diffLocation: Vector = Vector.getZero(), autoLayout = true);
2121
+ graphImporter: Promise<GraphImporter>;
2122
+ treeImporter: Promise<TreeImporter>;
2123
+ mermaidImporter: Promise<MermaidImporter>;
2124
+ markdownImporter: Promise<MarkdownImporter>;
2125
+ constructor(project: Project | { _: "Project" | string });
2126
+ addNodeGraphByText(text: string, diffLocation: Vector | { _: "Vector" | string } = Vector.getZero()): Promise<void>;
2127
+ addNodeTreeByText(text: string, indention: number, diffLocation: Vector | { _: "Vector" | string } = Vector.getZero()): Promise<void>;
2128
+ addNodeTreeByTextFromNode(uuid: string, text: string, indention: number): Promise<{ success: boolean; error?: string; nodeCount?: number }>;
2129
+ addNodeMermaidByText(text: string, diffLocation: Vector | { _: "Vector" | string } = Vector.getZero()): Promise<void>;
2130
+ addNodeByMarkdown(markdownText: string, diffLocation: Vector | { _: "Vector" | string } = Vector.getZero(), autoLayout = true): Promise<void>;
2112
2131
  }
2113
2132
 
2114
2133
  declare class StageManager {
2115
- constructor(project: Project);
2116
- get(uuid: string);
2117
- isEmpty(): boolean;
2118
- getTextNodes(): TextNode[];
2119
- getConnectableEntity(): ConnectableEntity[];
2120
- isEntityExists(uuid: string): boolean;
2121
- getSections(): Section[];
2122
- getImageNodes(): ImageNode[];
2123
- getConnectPoints(): ConnectPoint[];
2124
- getUrlNodes(): UrlNode[];
2125
- getPenStrokes(): PenStroke[];
2126
- getSvgNodes(): SvgNode[];
2127
- getLatexNodes(): LatexNode[];
2128
- getStageObjects(): StageObject[];
2129
- getEntities(): Entity[];
2130
- getEntitiesByUUIDs(uuids: string[]): Entity[];
2131
- isNoEntity(): boolean;
2132
- delete(stageObject: StageObject);
2133
- getAssociations(): Association[];
2134
- getEdges(): Edge[];
2135
- getLineEdges(): LineEdge[];
2136
- getCrEdges(): CubicCatmullRomSplineEdge[];
2137
- add(stageObject: StageObject);
2138
- updateReferences();
2139
- getTextNodeByUUID(uuid: string): TextNode | null;
2140
- getConnectableEntityByUUID(uuid: string): ConnectableEntity | null;
2141
- isSectionByUUID(uuid: string): boolean;
2142
- getSectionByUUID(uuid: string): Section | null;
2143
- getCenter(): Vector;
2144
- getSize(): Vector;
2145
- getBoundingRectangle(): Rectangle;
2146
- findTextNodeByLocation(location: Vector): TextNode | null;
2147
- findLineEdgeByLocation(location: Vector): LineEdge | null;
2148
- findAssociationByLocation(location: Vector): Association | null;
2149
- findSectionByLocation(location: Vector): Section | null;
2150
- findImageNodeByLocation(location: Vector): ImageNode | null;
2151
- findConnectableEntityByLocation(location: Vector): ConnectableEntity | null;
2152
- findEntityByLocation(location: Vector): Entity | null;
2153
- findConnectPointByLocation(location: Vector): ConnectPoint | null;
2154
- isHaveEntitySelected(): boolean;
2155
- getSelectedEntities(): Entity[];
2156
- getSelectedAssociations(): Association[];
2157
- getSelectedStageObjects(): StageObject[];
2158
- getBoundingBoxOfSelected(): Rectangle;
2159
- isEntityOnLocation(location: Vector): boolean;
2160
- isAssociationOnLocation(location: Vector): boolean;
2161
- deleteEntities(deleteNodes: Entity[]);
2162
- deleteSelectedStageObjects();
2163
- deleteAssociation(deleteAssociation: Association): boolean;
2164
- deleteEdge(deleteEdge: Edge): boolean;
2134
+ constructor(project: Project | { _: "Project" | string });
2135
+ get(uuid: string): Promise<void>;
2136
+ isEmpty(): Promise<boolean>;
2137
+ getTextNodes(): Promise<TextNode>[];
2138
+ getConnectableEntity(): Promise<ConnectableEntity>[];
2139
+ isEntityExists(uuid: string): Promise<boolean>;
2140
+ getSections(): Promise<Section>[];
2141
+ getImageNodes(): Promise<ImageNode>[];
2142
+ getConnectPoints(): Promise<ConnectPoint>[];
2143
+ getUrlNodes(): Promise<UrlNode>[];
2144
+ getPenStrokes(): Promise<PenStroke>[];
2145
+ getSvgNodes(): Promise<SvgNode>[];
2146
+ getLatexNodes(): Promise<LatexNode>[];
2147
+ getStageObjects(): Promise<StageObject>[];
2148
+ getEntities(): Promise<Entity>[];
2149
+ getEntitiesByUUIDs(uuids: string[]): Promise<Entity>[];
2150
+ isNoEntity(): Promise<boolean>;
2151
+ delete(stageObject: StageObject | { _: "StageObject" | string }): Promise<void>;
2152
+ getAssociations(): Promise<Association>[];
2153
+ getEdges(): Promise<Edge>[];
2154
+ getLineEdges(): Promise<LineEdge>[];
2155
+ getCrEdges(): Promise<CubicCatmullRomSplineEdge>[];
2156
+ add(stageObject: StageObject | { _: "StageObject" | string }): Promise<void>;
2157
+ updateReferences(): Promise<void>;
2158
+ getTextNodeByUUID(uuid: string): Promise<TextNode | null>;
2159
+ getConnectableEntityByUUID(uuid: string): Promise<ConnectableEntity | null>;
2160
+ isSectionByUUID(uuid: string): Promise<boolean>;
2161
+ getSectionByUUID(uuid: string): Promise<Section | null>;
2162
+ getCenter(): Promise<Vector>;
2163
+ getSize(): Promise<Vector>;
2164
+ getBoundingRectangle(): Promise<Rectangle>;
2165
+ findTextNodeByLocation(location: Vector | { _: "Vector" | string }): Promise<TextNode | null>;
2166
+ findLineEdgeByLocation(location: Vector | { _: "Vector" | string }): Promise<LineEdge | null>;
2167
+ findAssociationByLocation(location: Vector | { _: "Vector" | string }): Promise<Association | null>;
2168
+ findSectionByLocation(location: Vector | { _: "Vector" | string }): Promise<Section | null>;
2169
+ findImageNodeByLocation(location: Vector | { _: "Vector" | string }): Promise<ImageNode | null>;
2170
+ findConnectableEntityByLocation(location: Vector | { _: "Vector" | string }): Promise<ConnectableEntity | null>;
2171
+ findEntityByLocation(location: Vector | { _: "Vector" | string }): Promise<Entity | null>;
2172
+ findConnectPointByLocation(location: Vector | { _: "Vector" | string }): Promise<ConnectPoint | null>;
2173
+ isHaveEntitySelected(): Promise<boolean>;
2174
+ getSelectedEntities(): Promise<Entity>[];
2175
+ getSelectedAssociations(): Promise<Association>[];
2176
+ getSelectedStageObjects(): Promise<StageObject>[];
2177
+ getBoundingBoxOfSelected(): Promise<Rectangle>;
2178
+ isEntityOnLocation(location: Vector | { _: "Vector" | string }): Promise<boolean>;
2179
+ isAssociationOnLocation(location: Vector | { _: "Vector" | string }): Promise<boolean>;
2180
+ deleteEntities(deleteNodes: Entity[]): Promise<void>;
2181
+ deleteSelectedStageObjects(): Promise<void>;
2182
+ deleteAssociation(deleteAssociation: Association): Promise<boolean>;
2183
+ deleteEdge(deleteEdge: Edge): Promise<boolean>;
2165
2184
  w;
2166
- connectEntity(fromNode: ConnectableEntity, toNode: ConnectableEntity, isCrEdge: boolean = false);
2167
- connectMultipleEntities(fromNodes: ConnectableEntity[], toNode: ConnectableEntity, isCrEdge: boolean = false, sourceRectRate?: [number, number], targetRectRate?: [number, number]);
2168
- reverseNodeEdges(connectEntity: ConnectableEntity);
2169
- reverseSelectedNodeEdge();
2170
- reverseSelectedEdges();
2171
- generateNodeTreeByText(text: string, indention: number = 4, location = this.project.camera.location);
2172
- generateNodeGraphByText(text: string, location = this.project.camera.location);
2173
- generateNodeMermaidByText(text: string, location = this.project.camera.location);
2174
- generateNodeByMarkdown(text: string, location = this.project.camera.location, autoLayout = true);
2175
- packEntityToSection(addEntities: Entity[]);
2176
- packEntityToSectionBySelected();
2177
- goInSection(entities: Entity[], section: Section);
2178
- goOutSection(entities: Entity[], section: Section);
2179
- packSelectedSection();
2180
- unpackSelectedSection();
2181
- sectionSwitchCollapse();
2182
- connectEntityByCrEdge(fromNode: ConnectableEntity, toNode: ConnectableEntity);
2183
- refreshAllStageObjects();
2184
- refreshSelected();
2185
- changeSelectedEdgeConnectLocation(direction: Direction | null, isSource: boolean = false);
2186
- changeEdgesConnectLocation(edges: Edge[], direction: Direction | null, isSource: boolean = false);
2187
- switchLineEdgeToCrEdge();
2188
- switchEdgeToUndirectedEdge();
2189
- switchUndirectedEdgeToEdge();
2190
- addSelectedCREdgeControlPoint();
2191
- addSelectedCREdgeTension();
2192
- reduceSelectedCREdgeTension();
2193
- setSelectedEdgeLineType(lineType: string);
2194
- selectAll();
2195
- clearSelectAll();
2185
+ connectEntity(fromNode: ConnectableEntity | { _: "ConnectableEntity" | string }, toNode: ConnectableEntity | { _: "ConnectableEntity" | string }, isCrEdge: boolean = false): Promise<void>;
2186
+ connectMultipleEntities(fromNodes: ConnectableEntity[], toNode: ConnectableEntity | { _: "ConnectableEntity" | string }, isCrEdge: boolean = false, sourceRectRate?: [number, number], targetRectRate?: [number, number]): Promise<void>;
2187
+ reverseNodeEdges(connectEntity: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<void>;
2188
+ reverseSelectedNodeEdge(): Promise<void>;
2189
+ reverseSelectedEdges(): Promise<void>;
2190
+ generateNodeTreeByText(text: string, indention: number = 4, location = this.project.camera.location): Promise<void>;
2191
+ generateNodeGraphByText(text: string, location = this.project.camera.location): Promise<void>;
2192
+ generateNodeMermaidByText(text: string, location = this.project.camera.location): Promise<void>;
2193
+ generateNodeByMarkdown(text: string, location = this.project.camera.location, autoLayout = true): Promise<void>;
2194
+ packEntityToSection(addEntities: Entity[]): Promise<void>;
2195
+ packEntityToSectionBySelected(): Promise<void>;
2196
+ goInSection(entities: Entity[], section: Section | { _: "Section" | string }): Promise<void>;
2197
+ goOutSection(entities: Entity[], section: Section | { _: "Section" | string }): Promise<void>;
2198
+ packSelectedSection(): Promise<void>;
2199
+ unpackSelectedSection(): Promise<void>;
2200
+ sectionSwitchCollapse(): Promise<void>;
2201
+ connectEntityByCrEdge(fromNode: ConnectableEntity | { _: "ConnectableEntity" | string }, toNode: ConnectableEntity | { _: "ConnectableEntity" | string }): Promise<void>;
2202
+ refreshAllStageObjects(): Promise<void>;
2203
+ refreshSelected(): Promise<void>;
2204
+ changeSelectedEdgeConnectLocation(direction: Direction | null, isSource: boolean = false): Promise<void>;
2205
+ changeEdgesConnectLocation(edges: Edge[], direction: Direction | null, isSource: boolean = false): Promise<void>;
2206
+ switchLineEdgeToCrEdge(): Promise<void>;
2207
+ switchEdgeToUndirectedEdge(): Promise<void>;
2208
+ switchUndirectedEdgeToEdge(): Promise<void>;
2209
+ addSelectedCREdgeControlPoint(): Promise<void>;
2210
+ addSelectedCREdgeTension(): Promise<void>;
2211
+ reduceSelectedCREdgeTension(): Promise<void>;
2212
+ setSelectedEdgeLineType(lineType: string): Promise<void>;
2213
+ selectAll(): Promise<void>;
2214
+ clearSelectAll(): Promise<void>;
2196
2215
  }
2197
2216
 
2198
2217
  declare class StageNodeRotate {
2199
- constructor(project: Project);
2200
- moveEdges(lastMoveLocation: Vector, diffLocation: Vector);
2201
- rotateNodeDfs(rotateCenterNode: ConnectableEntity, currentNode: ConnectableEntity, degrees: number, visitedUUIDs: string[]): void;
2218
+ constructor(project: Project | { _: "Project" | string });
2219
+ moveEdges(lastMoveLocation: Vector | { _: "Vector" | string }, diffLocation: Vector | { _: "Vector" | string }): Promise<void>;
2220
+ rotateNodeDfs(rotateCenterNode: ConnectableEntity | { _: "ConnectableEntity" | string }, currentNode: ConnectableEntity | { _: "ConnectableEntity" | string }, degrees: number, visitedUUIDs: string[]): void;
2202
2221
  }
2203
2222
 
2204
2223
  declare class StageObject {
2205
- project: Project;
2206
- uuid: string;
2207
- collisionBox: CollisionBox;
2208
- get isPhysical(): boolean;
2209
- _isSelected: boolean;
2210
- get isSelected(): boolean;
2224
+ project: Promise<Project>;
2225
+ uuid: Promise<string>;
2226
+ collisionBox: Promise<CollisionBox>;
2227
+ get isPhysical(): Promise<boolean>;
2228
+ _isSelected: Promise<boolean>;
2229
+ get isSelected(): Promise<boolean>;
2211
2230
  set isSelected(value: boolean);
2212
- _isSyncing: boolean;
2231
+ _isSyncing: Promise<boolean>;
2213
2232
  }
2214
2233
 
2215
2234
  declare class StageObjectColorManager {
2216
- constructor(project: Project);
2217
- setSelectedStageObjectColor(color: Color);
2218
- darkenNodeColor();
2219
- lightenNodeColor();
2235
+ constructor(project: Project | { _: "Project" | string });
2236
+ setSelectedStageObjectColor(color: Color | { _: "Color" | string }): Promise<void>;
2237
+ darkenNodeColor(): Promise<void>;
2238
+ lightenNodeColor(): Promise<void>;
2220
2239
  }
2221
2240
 
2222
2241
  declare class StageObjectSelectCounter {
2223
- constructor(project: Project);
2242
+ constructor(project: Project | { _: "Project" | string });
2224
2243
  selectedStageObjectCount;
2225
2244
  selectedEntityCount;
2226
2245
  selectedAssociationCount;
@@ -2231,7 +2250,7 @@ declare class StageObjectSelectCounter {
2231
2250
  selectedSectionCount;
2232
2251
  selectedMultiTargetUndirectedEdgeCount;
2233
2252
  lastUpdateTimestamp;
2234
- update();
2253
+ update(): Promise<void>;
2235
2254
  }
2236
2255
 
2237
2256
  declare class StageStyleManager {
@@ -2240,51 +2259,51 @@ declare class StageStyleManager {
2240
2259
  }
2241
2260
 
2242
2261
  declare class StageSyncAssociationManager {
2243
- constructor(project: Project);
2262
+ constructor(project: Project | { _: "Project" | string });
2244
2263
  createTwinsFromSelectedEntities(): void;
2245
- getSyncAssociations(): SyncAssociation[];
2246
- getSyncAssociationsByMember(member: StageObject): SyncAssociation[];
2247
- getSyncSiblings(member: StageObject): StageObject[];
2248
- createTwinTextNode(source: TextNode): TextNode;
2249
- syncFrom(source: StageObject, key: SyncableKey, syncingSet: Set<string> = new Set()): void;
2250
- onStageObjectDeleted(deleted: StageObject): void;
2264
+ getSyncAssociations(): Promise<SyncAssociation>[];
2265
+ getSyncAssociationsByMember(member: StageObject | { _: "StageObject" | string }): Promise<SyncAssociation>[];
2266
+ getSyncSiblings(member: StageObject | { _: "StageObject" | string }): Promise<StageObject>[];
2267
+ createTwinTextNode(source: TextNode | { _: "TextNode" | string }): Promise<TextNode>;
2268
+ syncFrom(source: StageObject | { _: "StageObject" | string }, key: SyncableKey, syncingSet: Set<string> = new Set()): void;
2269
+ onStageObjectDeleted(deleted: StageObject | { _: "StageObject" | string }): void;
2251
2270
  }
2252
2271
 
2253
2272
  declare class StageUtils {
2254
- constructor(project: Project);
2255
- replaceAutoNameWithoutStage(template: string): string;
2256
- replaceAutoNameTemplate(currentName: string, targetStageObject: StageObject): string;
2257
- isNameConflictWithTextNodes(name: string): boolean;
2258
- isNameConflictWithSections(name: string): boolean;
2273
+ constructor(project: Project | { _: "Project" | string });
2274
+ replaceAutoNameWithoutStage(template: string): Promise<string>;
2275
+ replaceAutoNameTemplate(currentName: string, targetStageObject: StageObject | { _: "StageObject" | string }): Promise<string>;
2276
+ isNameConflictWithTextNodes(name: string): Promise<boolean>;
2277
+ isNameConflictWithSections(name: string): Promise<boolean>;
2259
2278
  }
2260
2279
 
2261
2280
  declare class StraightEdgeRenderer extends EdgeRendererClass {
2262
- constructor(project: Project);
2263
- getCuttingEffects(edge: LineEdge): Effect[];
2264
- getConnectedEffects(startNode: ConnectableEntity, toNode: ConnectableEntity, sourceRectangleRate?: Vector, targetRectangleRate?: Vector): Effect[];
2265
- renderLine(start: Vector, end: Vector, edge: LineEdge, width: number): void;
2266
- renderNormalState(edge: LineEdge): void;
2267
- getNormalStageSvg(edge: LineEdge): React.ReactNode;
2268
- getCycleStageSvg(): React.ReactNode;
2269
- getShiftingStageSvg(): React.ReactNode;
2270
- renderArrowHead(edge: LineEdge, direction: Vector, endPoint = edge.bodyLine.end.clone(), size = 15);
2271
- shouldRenderTargetArrow(edge: LineEdge): boolean;
2272
- renderShiftingState(edge: LineEdge): void;
2273
- renderCycleState(edge: LineEdge): void;
2274
- renderVirtualEdge(startNode: ConnectableEntity, mouseLocation: Vector, sourceRectangleRate?: Vector): void;
2275
- renderVirtualConfirmedEdge(startNode: ConnectableEntity, endNode: ConnectableEntity, sourceRectangleRate?: Vector, targetRectangleRate?: Vector): void;
2281
+ constructor(project: Project | { _: "Project" | string });
2282
+ getCuttingEffects(edge: LineEdge | { _: "LineEdge" | string }): Promise<Effect>[];
2283
+ getConnectedEffects(startNode: ConnectableEntity | { _: "ConnectableEntity" | string }, toNode: ConnectableEntity | { _: "ConnectableEntity" | string }, sourceRectangleRate?: Vector | { _: "Vector" | string }, targetRectangleRate?: Vector | { _: "Vector" | string }): Promise<Effect>[];
2284
+ renderLine(start: Vector | { _: "Vector" | string }, end: Vector | { _: "Vector" | string }, edge: LineEdge | { _: "LineEdge" | string }, width: number): void;
2285
+ renderNormalState(edge: LineEdge | { _: "LineEdge" | string }): void;
2286
+ getNormalStageSvg(edge: LineEdge | { _: "LineEdge" | string }): Promise<React.ReactNode>;
2287
+ getCycleStageSvg(): Promise<React.ReactNode>;
2288
+ getShiftingStageSvg(): Promise<React.ReactNode>;
2289
+ renderArrowHead(edge: LineEdge | { _: "LineEdge" | string }, direction: Vector | { _: "Vector" | string }, endPoint = edge.bodyLine.end.clone(), size = 15): Promise<void>;
2290
+ shouldRenderTargetArrow(edge: LineEdge | { _: "LineEdge" | string }): Promise<boolean>;
2291
+ renderShiftingState(edge: LineEdge | { _: "LineEdge" | string }): void;
2292
+ renderCycleState(edge: LineEdge | { _: "LineEdge" | string }): void;
2293
+ renderVirtualEdge(startNode: ConnectableEntity | { _: "ConnectableEntity" | string }, mouseLocation: Vector | { _: "Vector" | string }, sourceRectangleRate?: Vector | { _: "Vector" | string }): void;
2294
+ renderVirtualConfirmedEdge(startNode: ConnectableEntity | { _: "ConnectableEntity" | string }, endNode: ConnectableEntity | { _: "ConnectableEntity" | string }, sourceRectangleRate?: Vector | { _: "Vector" | string }, targetRectangleRate?: Vector | { _: "Vector" | string }): void;
2276
2295
  }
2277
2296
 
2278
2297
  declare class SvgNode extends ConnectableEntity implements ResizeAble {
2279
- color: Color;
2280
- uuid: string;
2281
- scale: number;
2282
- collisionBox: CollisionBox;
2283
- attachmentId: string;
2284
- isHiddenBySectionCollapse: boolean;
2285
- originalSize: Vector;
2286
- image: HTMLImageElement;
2287
- constructor(project: Project, {
2298
+ color: Promise<Color>;
2299
+ uuid: Promise<string>;
2300
+ scale: Promise<number>;
2301
+ collisionBox: Promise<CollisionBox>;
2302
+ attachmentId: Promise<string>;
2303
+ isHiddenBySectionCollapse: Promise<boolean>;
2304
+ originalSize: Promise<Vector>;
2305
+ image: Promise<HTMLImageElement>;
2306
+ constructor(project: Project | { _: "Project" | string }, {
2288
2307
  uuid = crypto.randomUUID(),
2289
2308
  details = [],
2290
2309
  attachmentId = "",
@@ -2292,58 +2311,58 @@ declare class SvgNode extends ConnectableEntity implements ResizeAble {
2292
2311
  scale = 1,
2293
2312
  color = Color.Transparent,
2294
2313
  });
2295
- get geometryCenter(): Vector;
2296
- scaleUpdate(scaleDiff: number);
2297
- move(delta: Vector): void;
2298
- moveTo(location: Vector): void;
2299
- changeColor(newColor: Color, mode: "fill" | "stroke" = "fill");
2300
- resizeHandle(delta: Vector);
2301
- getResizeHandleRect(): Rectangle;
2314
+ get geometryCenter(): Promise<Vector>;
2315
+ scaleUpdate(scaleDiff: number): Promise<void>;
2316
+ move(delta: Vector | { _: "Vector" | string }): void;
2317
+ moveTo(location: Vector | { _: "Vector" | string }): void;
2318
+ changeColor(newColor: Color | { _: "Color" | string }, mode: "fill" | "stroke" = "fill"): Promise<void>;
2319
+ resizeHandle(delta: Vector | { _: "Vector" | string }): Promise<void>;
2320
+ getResizeHandleRect(): Promise<Rectangle>;
2302
2321
  }
2303
2322
 
2304
2323
  declare class SvgNodeRenderer {
2305
- constructor(project: Project);
2306
- render(svgNode: SvgNode);
2324
+ constructor(project: Project | { _: "Project" | string });
2325
+ render(svgNode: SvgNode | { _: "SvgNode" | string }): Promise<void>;
2307
2326
  }
2308
2327
 
2309
2328
  declare class SvgRenderer {
2310
- svgCache: { [key: string]: HTMLImageElement };
2311
- constructor(project: Project);
2312
- renderSvgFromLeftTop(svg: string, location: Vector, width: number, height: number): void;
2313
- renderSvgFromCenter(svg: string, centerLocation: Vector, width: number, height: number): void;
2314
- renderSvgFromLeftTopWithoutSize(svg: string, location: Vector, scaleNumber = 1): void;
2315
- renderSvgFromCenterWithoutSize(svg: string, centerLocation: Vector): void;
2329
+ svgCache: Promise<{ [key: string]: HTMLImageElement }>;
2330
+ constructor(project: Project | { _: "Project" | string });
2331
+ renderSvgFromLeftTop(svg: string, location: Vector | { _: "Vector" | string }, width: number, height: number): void;
2332
+ renderSvgFromCenter(svg: string, centerLocation: Vector | { _: "Vector" | string }, width: number, height: number): void;
2333
+ renderSvgFromLeftTopWithoutSize(svg: string, location: Vector | { _: "Vector" | string }, scaleNumber = 1): void;
2334
+ renderSvgFromCenterWithoutSize(svg: string, centerLocation: Vector | { _: "Vector" | string }): void;
2316
2335
  }
2317
2336
 
2318
2337
  declare class SymmetryCurveEdgeRenderer extends EdgeRendererClass {
2319
- constructor(project: Project);
2320
- shouldRenderTargetArrow(edge: LineEdge): boolean;
2321
- getCuttingEffects(edge: LineEdge): Effect[];
2322
- getConnectedEffects(startNode: ConnectableEntity, toNode: ConnectableEntity, sourceRectangleRate?: Vector, targetRectangleRate?: Vector): Effect[];
2323
- renderNormalState(edge: LineEdge): void;
2324
- renderShiftingState(edge: LineEdge): void;
2325
- renderCycleState(edge: LineEdge): void;
2326
- getNormalStageSvg(edge: LineEdge): React.ReactNode;
2327
- getCycleStageSvg(): React.ReactNode;
2328
- getShiftingStageSvg(): React.ReactNode;
2329
- renderVirtualEdge(startNode: ConnectableEntity, mouseLocation: Vector, sourceRectangleRate?: Vector): void;
2330
- renderVirtualConfirmedEdge(startNode: ConnectableEntity, endNode: ConnectableEntity, sourceRectangleRate?: Vector, targetRectangleRate?: Vector): void;
2331
- renderArrowCurve(curve: SymmetryCurve, color: Color, width = 2, edge?: LineEdge): void;
2332
- renderText(curve: SymmetryCurve, edge: LineEdge): void;
2338
+ constructor(project: Project | { _: "Project" | string });
2339
+ shouldRenderTargetArrow(edge: LineEdge | { _: "LineEdge" | string }): Promise<boolean>;
2340
+ getCuttingEffects(edge: LineEdge | { _: "LineEdge" | string }): Promise<Effect>[];
2341
+ getConnectedEffects(startNode: ConnectableEntity | { _: "ConnectableEntity" | string }, toNode: ConnectableEntity | { _: "ConnectableEntity" | string }, sourceRectangleRate?: Vector | { _: "Vector" | string }, targetRectangleRate?: Vector | { _: "Vector" | string }): Promise<Effect>[];
2342
+ renderNormalState(edge: LineEdge | { _: "LineEdge" | string }): void;
2343
+ renderShiftingState(edge: LineEdge | { _: "LineEdge" | string }): void;
2344
+ renderCycleState(edge: LineEdge | { _: "LineEdge" | string }): void;
2345
+ getNormalStageSvg(edge: LineEdge | { _: "LineEdge" | string }): Promise<React.ReactNode>;
2346
+ getCycleStageSvg(): Promise<React.ReactNode>;
2347
+ getShiftingStageSvg(): Promise<React.ReactNode>;
2348
+ renderVirtualEdge(startNode: ConnectableEntity | { _: "ConnectableEntity" | string }, mouseLocation: Vector | { _: "Vector" | string }, sourceRectangleRate?: Vector | { _: "Vector" | string }): void;
2349
+ renderVirtualConfirmedEdge(startNode: ConnectableEntity | { _: "ConnectableEntity" | string }, endNode: ConnectableEntity | { _: "ConnectableEntity" | string }, sourceRectangleRate?: Vector | { _: "Vector" | string }, targetRectangleRate?: Vector | { _: "Vector" | string }): void;
2350
+ renderArrowCurve(curve: SymmetryCurve | { _: "SymmetryCurve" | string }, color: Color | { _: "Color" | string }, width = 2, edge?: LineEdge | { _: "LineEdge" | string }): void;
2351
+ renderText(curve: SymmetryCurve | { _: "SymmetryCurve" | string }, edge: LineEdge | { _: "LineEdge" | string }): void;
2333
2352
  }
2334
2353
 
2335
2354
  declare type SyncableKey = "text" | "color" | "details";
2336
2355
 
2337
2356
  declare class SyncAssociation extends Association {
2338
- uuid: string;
2339
- keys: SyncableKey[];
2340
- associationList: StageObject[];
2341
- get collisionBox(): CollisionBox;
2342
- get isPhysical(): boolean;
2343
- _isSelected: boolean;
2344
- get isSelected(): boolean;
2357
+ uuid: Promise<string>;
2358
+ keys: Promise<SyncableKey>[];
2359
+ associationList: Promise<StageObject>[];
2360
+ get collisionBox(): Promise<CollisionBox>;
2361
+ get isPhysical(): Promise<boolean>;
2362
+ _isSelected: Promise<boolean>;
2363
+ get isSelected(): Promise<boolean>;
2345
2364
  set isSelected(value: boolean);
2346
- constructor(project: Project, {
2365
+ constructor(project: Project | { _: "Project" | string }, {
2347
2366
  uuid = crypto.randomUUID() as string,
2348
2367
  keys = ["text", "color", "details"] as SyncableKey[],
2349
2368
  associationList = [] as StageObject[],
@@ -2354,75 +2373,75 @@ declare class SyncAssociation extends Association {
2354
2373
  associationList?: StageObject[];
2355
2374
  color?: Color;
2356
2375
  }, unknown = false);
2357
- applyFrom(source: StageObject): void;
2376
+ applyFrom(source: StageObject | { _: "StageObject" | string }): void;
2358
2377
  }
2359
2378
 
2360
2379
  declare class Tab extends React.Component<Record<string, never>, Record<string, never>> {
2361
2380
  eventEmitter;
2362
2381
  services;
2363
2382
  fileSystemProviders;
2364
- tickableServices: Service[];
2383
+ tickableServices: Promise<Service>[];
2365
2384
  rafHandle;
2366
- getComponent(): React.ComponentType;
2367
- get title(): string;
2368
- get icon(): React.ComponentType<any> | null;
2385
+ getComponent(): Promise<React.ComponentType>;
2386
+ get title(): Promise<string>;
2387
+ get icon(): Promise<React.ComponentType<any> | null>;
2369
2388
  constructor(props: Record<string, never>);
2370
- registerFileSystemProvider(scheme: string, provider: { new (...args: any[]): FileSystemProvider });
2371
- get fs(): FileSystemProvider;
2372
- on(event: string | symbol, listener: (...args: any[]) => void): this;
2373
- emit(event: string | symbol, ...args: any[]): boolean;
2374
- removeAllListeners(event?: string | symbol): this;
2375
- loadService(service: { id?: string; new (...args: any[]): any });
2376
- disposeService(serviceId: string);
2377
- getService<T extends keyof this & string>(serviceId: T): this[T];
2389
+ registerFileSystemProvider(scheme: string, provider: { new (...args: any[]): FileSystemProvider }): Promise<void>;
2390
+ get fs(): Promise<FileSystemProvider>;
2391
+ on(event: string | symbol, listener: (...args: any[]) => void): Promise<this>;
2392
+ emit(event: string | symbol, ...args: any[]): Promise<boolean>;
2393
+ removeAllListeners(event?: string | symbol): Promise<this>;
2394
+ loadService(service: { id?: string; new (...args: any[]): any }): Promise<void>;
2395
+ disposeService(serviceId: string): Promise<void>;
2396
+ getService<T extends keyof this & string>(serviceId: T): Promise<this[T]>;
2378
2397
  init(): Promise<void>;
2379
- loop();
2380
- pause();
2381
- tick();
2382
- dispose();
2383
- get isRunning(): boolean;
2384
- render(): React.ReactNode;
2398
+ loop(): Promise<void>;
2399
+ pause(): Promise<void>;
2400
+ tick(): Promise<void>;
2401
+ dispose(): Promise<void>;
2402
+ get isRunning(): Promise<boolean>;
2403
+ render(): Promise<React.ReactNode>;
2385
2404
  }
2386
2405
 
2387
2406
  declare class TabExporter extends BaseExporter {
2388
- export(textNode: TextNode): string;
2389
- getTabText(node: TextNode, level: number): string;
2407
+ export(textNode: TextNode | { _: "TextNode" | string }): Promise<string>;
2408
+ getTabText(node: TextNode | { _: "TextNode" | string }, level: number): Promise<string>;
2390
2409
  }
2391
2410
 
2392
2411
  declare class TagManager {
2393
- constructor(project: Project);
2394
- tagSet: Set<string>;
2395
- reset(uuids: string[]);
2396
- addTag(uuid: string);
2397
- removeTag(uuid: string);
2398
- hasTag(uuid: string): boolean;
2399
- updateTags();
2400
- moveUpTag(uuid: string);
2401
- moveDownTag(uuid: string);
2402
- changeTagBySelected();
2403
- refreshTagNamesUI();
2404
- moveCameraToTag(tagUUID: string);
2412
+ constructor(project: Project | { _: "Project" | string });
2413
+ tagSet: Promise<Set<string>>;
2414
+ reset(uuids: string[]): Promise<void>;
2415
+ addTag(uuid: string): Promise<void>;
2416
+ removeTag(uuid: string): Promise<void>;
2417
+ hasTag(uuid: string): Promise<boolean>;
2418
+ updateTags(): Promise<void>;
2419
+ moveUpTag(uuid: string): Promise<void>;
2420
+ moveDownTag(uuid: string): Promise<void>;
2421
+ changeTagBySelected(): Promise<void>;
2422
+ refreshTagNamesUI(): Promise<void>;
2423
+ moveCameraToTag(tagUUID: string): Promise<void>;
2405
2424
  }
2406
2425
 
2407
2426
  declare class TextNode extends ConnectableEntity implements ResizeAble {
2408
- uuid: string;
2409
- text: string;
2410
- collisionBox: CollisionBox;
2411
- color: Color;
2412
- isAiGenerating: boolean;
2413
- fontScaleLevel: number;
2427
+ uuid: Promise<string>;
2428
+ text: Promise<string>;
2429
+ collisionBox: Promise<CollisionBox>;
2430
+ color: Promise<Color>;
2431
+ isAiGenerating: Promise<boolean>;
2432
+ fontScaleLevel: Promise<number>;
2414
2433
  enableResizeCharCount;
2415
- sizeAdjust: string;
2416
- _isSelected: boolean;
2417
- get isSelected(): any;
2418
- get rectangle(): Rectangle;
2419
- get geometryCenter(): any;
2434
+ sizeAdjust: Promise<string>;
2435
+ _isSelected: Promise<boolean>;
2436
+ get isSelected(): Promise<any>;
2437
+ get rectangle(): Promise<Rectangle>;
2438
+ get geometryCenter(): Promise<any>;
2420
2439
  set isSelected(value: boolean);
2421
- _isEditing: boolean;
2422
- get isEditing(): any;
2440
+ _isEditing: Promise<boolean>;
2441
+ get isEditing(): Promise<any>;
2423
2442
  set isEditing(value: boolean);
2424
2443
  isHiddenBySectionCollapse;
2425
- constructor(project: Project, {
2444
+ constructor(project: Project | { _: "Project" | string }, {
2426
2445
  uuid = crypto.randomUUID() as string,
2427
2446
  text = "",
2428
2447
  details = [],
@@ -2439,102 +2458,102 @@ declare class TextNode extends ConnectableEntity implements ResizeAble {
2439
2458
  collisionBox?: CollisionBox;
2440
2459
  fontScaleLevel?: number;
2441
2460
  }, unknown = false);
2442
- fontSizeCache: number;
2443
- getFontSize(): number;
2444
- getPadding(): number;
2445
- getBorderWidth(): number;
2446
- getBorderRadius(): number;
2461
+ fontSizeCache: Promise<number>;
2462
+ getFontSize(): Promise<number>;
2463
+ getPadding(): Promise<number>;
2464
+ getBorderWidth(): Promise<number>;
2465
+ getBorderRadius(): Promise<number>;
2447
2466
  updateFontSizeCache(): void;
2448
- setFontScaleLevel(level: number);
2449
- increaseFontSize(anchorRate?: Vector): void;
2450
- decreaseFontSize(anchorRate?: Vector): void;
2451
- _adjustLocationToKeepAnchor(oldRect: Rectangle, anchorRate: Vector): void;
2452
- adjustSizeByText();
2453
- adjustHeightByText();
2454
- forceAdjustSizeByText();
2455
- rename(text: string);
2456
- resizeHandle(delta: Vector);
2457
- resizeWidthTo(width: number);
2458
- getResizeHandleRect(): Rectangle;
2459
- move(delta: Vector);
2467
+ setFontScaleLevel(level: number): Promise<void>;
2468
+ increaseFontSize(anchorRate?: Vector | { _: "Vector" | string }): void;
2469
+ decreaseFontSize(anchorRate?: Vector | { _: "Vector" | string }): void;
2470
+ _adjustLocationToKeepAnchor(oldRect: Rectangle | { _: "Rectangle" | string }, anchorRate: Vector | { _: "Vector" | string }): void;
2471
+ adjustSizeByText(): Promise<void>;
2472
+ adjustHeightByText(): Promise<void>;
2473
+ forceAdjustSizeByText(): Promise<void>;
2474
+ rename(text: string): Promise<void>;
2475
+ resizeHandle(delta: Vector | { _: "Vector" | string }): Promise<void>;
2476
+ resizeWidthTo(width: number): Promise<void>;
2477
+ getResizeHandleRect(): Promise<Rectangle>;
2478
+ move(delta: Vector | { _: "Vector" | string }): Promise<void>;
2460
2479
  collideWithOtherEntity(other: Entity): void;
2461
- moveTo(location: Vector);
2480
+ moveTo(location: Vector | { _: "Vector" | string }): Promise<void>;
2462
2481
  }
2463
2482
 
2464
2483
  declare class TextNodeRenderer {
2465
- constructor(project: Project);
2466
- renderTextNode(node: TextNode);
2467
- renderKeyboardTreeHint(node: TextNode): void;
2468
- renderLogicNodeWarningTrap(node: TextNode);
2469
- renderTextNodeTextLayer(node: TextNode);
2484
+ constructor(project: Project | { _: "Project" | string });
2485
+ renderTextNode(node: TextNode | { _: "TextNode" | string }): Promise<void>;
2486
+ renderKeyboardTreeHint(node: TextNode | { _: "TextNode" | string }): void;
2487
+ renderLogicNodeWarningTrap(node: TextNode | { _: "TextNode" | string }): Promise<void>;
2488
+ renderTextNodeTextLayer(node: TextNode | { _: "TextNode" | string }): Promise<void>;
2470
2489
  }
2471
2490
 
2472
2491
  declare class TextRenderer {
2473
2492
  cache;
2474
- constructor(project: Project);
2475
- hash(text: string, size: number): string;
2476
- getCache(text: string, size: number);
2477
- getCacheNearestSize(text: string, size: number): ImageBitmap | undefined;
2478
- buildCache(text: string, size: number, color: Color): CanvasImageSource;
2479
- renderText(text: string, location: Vector, size: number, color: Color = Color.White): void;
2480
- renderTempText(text: string, location: Vector, size: number, color: Color = Color.White): void;
2481
- renderTextFromCenter(text: string, centerLocation: Vector, size: number, color: Color = Color.White): void;
2482
- renderTempTextFromCenter(text: string, centerLocation: Vector, size: number, color: Color = Color.White): void;
2483
- renderTextInRectangle(text: string, rectangle: Rectangle, color: Color): void;
2484
- getFontSizeByRectangleSize(text: string, rectangle: Rectangle): Vector;
2485
- renderMultiLineText(text: string, location: Vector, fontSize: number, limitWidth: number, color: Color = Color.White, lineHeight: number = 1.2, limitLines: number = Infinity): void;
2486
- renderTempMultiLineText(text: string, location: Vector, fontSize: number, limitWidth: number, color: Color = Color.White, lineHeight: number = 1.2, limitLines: number = Infinity): void;
2487
- renderMultiLineTextFromCenterWithStroke(text: string, centerLocation: Vector, size: number, fillColor: Color, strokeColor: Color, limitWidth: number = Infinity, lineHeight: number = 1.2): void;
2488
- renderMultiLineTextFromCenter(text: string, centerLocation: Vector, size: number, limitWidth: number, color: Color, lineHeight: number = 1.2, limitLines: number = Infinity): void;
2489
- renderTempMultiLineTextFromCenter(text: string, centerLocation: Vector, size: number, limitWidth: number, color: Color, lineHeight: number = 1.2, limitLines: number = Infinity): void;
2490
- textArrayCache: LruCache<string, string[]>;
2491
- textToTextArrayWrapCache(text: string, fontSize: number, limitWidth: number): string[];
2492
- textToTextArray(text: string, fontSize: number, limitWidth: number): string[];
2493
- measureMultiLineTextSize(text: string, fontSize: number, limitWidth: number, lineHeight: number = 1.2): Vector;
2493
+ constructor(project: Project | { _: "Project" | string });
2494
+ hash(text: string, size: number): Promise<string>;
2495
+ getCache(text: string, size: number): Promise<void>;
2496
+ getCacheNearestSize(text: string, size: number): Promise<ImageBitmap | undefined>;
2497
+ buildCache(text: string, size: number, color: Color | { _: "Color" | string }): Promise<CanvasImageSource>;
2498
+ renderText(text: string, location: Vector | { _: "Vector" | string }, size: number, color: Color | { _: "Color" | string } = Color.White): void;
2499
+ renderTempText(text: string, location: Vector | { _: "Vector" | string }, size: number, color: Color | { _: "Color" | string } = Color.White): void;
2500
+ renderTextFromCenter(text: string, centerLocation: Vector | { _: "Vector" | string }, size: number, color: Color | { _: "Color" | string } = Color.White): void;
2501
+ renderTempTextFromCenter(text: string, centerLocation: Vector | { _: "Vector" | string }, size: number, color: Color | { _: "Color" | string } = Color.White): void;
2502
+ renderTextInRectangle(text: string, rectangle: Rectangle | { _: "Rectangle" | string }, color: Color | { _: "Color" | string }): void;
2503
+ getFontSizeByRectangleSize(text: string, rectangle: Rectangle | { _: "Rectangle" | string }): Promise<Vector>;
2504
+ renderMultiLineText(text: string, location: Vector | { _: "Vector" | string }, fontSize: number, limitWidth: number, color: Color | { _: "Color" | string } = Color.White, lineHeight: number = 1.2, limitLines: number = Infinity): void;
2505
+ renderTempMultiLineText(text: string, location: Vector | { _: "Vector" | string }, fontSize: number, limitWidth: number, color: Color | { _: "Color" | string } = Color.White, lineHeight: number = 1.2, limitLines: number = Infinity): void;
2506
+ renderMultiLineTextFromCenterWithStroke(text: string, centerLocation: Vector | { _: "Vector" | string }, size: number, fillColor: Color | { _: "Color" | string }, strokeColor: Color | { _: "Color" | string }, limitWidth: number = Infinity, lineHeight: number = 1.2): void;
2507
+ renderMultiLineTextFromCenter(text: string, centerLocation: Vector | { _: "Vector" | string }, size: number, limitWidth: number, color: Color | { _: "Color" | string }, lineHeight: number = 1.2, limitLines: number = Infinity): void;
2508
+ renderTempMultiLineTextFromCenter(text: string, centerLocation: Vector | { _: "Vector" | string }, size: number, limitWidth: number, color: Color | { _: "Color" | string }, lineHeight: number = 1.2, limitLines: number = Infinity): void;
2509
+ textArrayCache: Promise<LruCache<string, string[]>>;
2510
+ textToTextArrayWrapCache(text: string, fontSize: number, limitWidth: number): Promise<string>[];
2511
+ textToTextArray(text: string, fontSize: number, limitWidth: number): Promise<string>[];
2512
+ measureMultiLineTextSize(text: string, fontSize: number, limitWidth: number, lineHeight: number = 1.2): Promise<Vector>;
2494
2513
  }
2495
2514
 
2496
2515
  declare const transformedKeys;
2497
2516
 
2498
2517
  declare class TreeImporter extends BaseImporter {
2499
- constructor(project: Project);
2500
- import(text: string, indention: number, diffLocation: Vector = Vector.getZero()): void;
2501
- importFromNode(uuid: string, text: string, indention: number): { success: boolean; error?: string; nodeCount?: number };
2502
- getIndentLevel(line: string, indention: number): number;
2518
+ constructor(project: Project | { _: "Project" | string });
2519
+ import(text: string, indention: number, diffLocation: Vector | { _: "Vector" | string } = Vector.getZero()): void;
2520
+ importFromNode(uuid: string, text: string, indention: number): Promise<{ success: boolean; error?: string; nodeCount?: number }>;
2521
+ getIndentLevel(line: string, indention: number): Promise<number>;
2503
2522
  }
2504
2523
 
2505
2524
  declare interface UIKeyBind {
2506
- id: string;
2507
- key: string;
2508
- isEnabled: boolean;
2509
- onPress: (project?: Project) => void;
2510
- when: KeyBindWhen;
2511
- icon?: KeyBindIcon;
2512
- isContinuous?: boolean;
2513
- onRelease?: (project?: Project) => void;
2525
+ id: Promise<string>;
2526
+ key: Promise<string>;
2527
+ isEnabled: Promise<boolean>;
2528
+ onPress: Promise<(project?: Project) => void>;
2529
+ when: Promise<KeyBindWhen>;
2530
+ icon?: Promise<KeyBindIcon>;
2531
+ isContinuous?: Promise<boolean>;
2532
+ onRelease?: Promise<(project?: Project) => void>;
2514
2533
  }
2515
2534
 
2516
2535
  declare class UrlNode extends ConnectableEntity {
2517
- uuid: string;
2518
- title: string;
2519
- url: string;
2520
- color: Color;
2521
- collisionBox: CollisionBox;
2522
- width: number;
2523
- height: number;
2524
- titleHeight: number;
2525
- _isEditingTitle: boolean;
2526
- isMouseHoverTitle: boolean;
2527
- isMouseHoverUrl: boolean;
2528
- get isEditingTitle(): any;
2536
+ uuid: Promise<string>;
2537
+ title: Promise<string>;
2538
+ url: Promise<string>;
2539
+ color: Promise<Color>;
2540
+ collisionBox: Promise<CollisionBox>;
2541
+ width: Promise<number>;
2542
+ height: Promise<number>;
2543
+ titleHeight: Promise<number>;
2544
+ _isEditingTitle: Promise<boolean>;
2545
+ isMouseHoverTitle: Promise<boolean>;
2546
+ isMouseHoverUrl: Promise<boolean>;
2547
+ get isEditingTitle(): Promise<any>;
2529
2548
  set isEditingTitle(value: boolean);
2530
- get geometryCenter(): Vector;
2531
- get titleRectangle(): Rectangle;
2532
- get urlRectangle(): Rectangle;
2533
- get rectangle(): Rectangle;
2534
- move(delta: Vector): void;
2535
- moveTo(location: Vector): void;
2536
- isHiddenBySectionCollapse: boolean;
2537
- constructor(project: Project, {
2549
+ get geometryCenter(): Promise<Vector>;
2550
+ get titleRectangle(): Promise<Rectangle>;
2551
+ get urlRectangle(): Promise<Rectangle>;
2552
+ get rectangle(): Promise<Rectangle>;
2553
+ move(delta: Vector | { _: "Vector" | string }): void;
2554
+ moveTo(location: Vector | { _: "Vector" | string }): void;
2555
+ isHiddenBySectionCollapse: Promise<boolean>;
2556
+ constructor(project: Project | { _: "Project" | string }, {
2538
2557
  uuid = crypto.randomUUID() as string,
2539
2558
  title = "",
2540
2559
  details = [],
@@ -2543,66 +2562,51 @@ declare class UrlNode extends ConnectableEntity {
2543
2562
  color = Color.Transparent,
2544
2563
  });
2545
2564
  rename(title: string): void;
2546
- adjustSizeByText();
2565
+ adjustSizeByText(): Promise<void>;
2547
2566
  }
2548
2567
 
2549
2568
  declare class UrlNodeRenderer {
2550
- constructor(project: Project);
2551
- render(urlNode: UrlNode): void;
2552
- renderHoverState(urlNode: UrlNode): void;
2569
+ constructor(project: Project | { _: "Project" | string });
2570
+ render(urlNode: UrlNode | { _: "UrlNode" | string }): void;
2571
+ renderHoverState(urlNode: UrlNode | { _: "UrlNode" | string }): void;
2553
2572
  }
2554
2573
 
2555
2574
  declare class VerticalPolyEdgeRenderer extends EdgeRendererClass {
2556
- constructor(project: Project);
2557
- getCuttingEffects(edge: LineEdge): Effect[];
2558
- getConnectedEffects(startNode: ConnectableEntity, toNode: ConnectableEntity, sourceRectangleRate?: Vector, targetRectangleRate?: Vector): Effect[];
2559
- getVerticalDirection(edge: LineEdge): Vector;
2560
- fixedLength: number;
2561
- renderTest(edge: LineEdge);
2562
- gaussianFunction(x: number);
2563
- renderNormalState(edge: LineEdge): void;
2564
- renderShiftingState(edge: LineEdge): void;
2565
- shouldRenderTargetArrow(edge: LineEdge): boolean;
2566
- renderArrowHead(edge: LineEdge, direction: Vector, endPoint = edge.bodyLine.end.clone());
2567
- renderCycleState(edge: LineEdge): void;
2568
- getNormalStageSvg(edge: LineEdge): React.ReactNode;
2569
- getCycleStageSvg(): React.ReactNode;
2570
- getShiftingStageSvg(): React.ReactNode;
2571
- renderVirtualEdge(startNode: ConnectableEntity, mouseLocation: Vector, sourceRectangleRate?: Vector): void;
2572
- renderVirtualConfirmedEdge(startNode: ConnectableEntity, endNode: ConnectableEntity, sourceRectangleRate?: Vector, targetRectangleRate?: Vector): void;
2575
+ constructor(project: Project | { _: "Project" | string });
2576
+ getCuttingEffects(edge: LineEdge | { _: "LineEdge" | string }): Promise<Effect>[];
2577
+ getConnectedEffects(startNode: ConnectableEntity | { _: "ConnectableEntity" | string }, toNode: ConnectableEntity | { _: "ConnectableEntity" | string }, sourceRectangleRate?: Vector | { _: "Vector" | string }, targetRectangleRate?: Vector | { _: "Vector" | string }): Promise<Effect>[];
2578
+ getVerticalDirection(edge: LineEdge | { _: "LineEdge" | string }): Promise<Vector>;
2579
+ fixedLength: Promise<number>;
2580
+ renderTest(edge: LineEdge | { _: "LineEdge" | string }): Promise<void>;
2581
+ gaussianFunction(x: number): Promise<void>;
2582
+ renderNormalState(edge: LineEdge | { _: "LineEdge" | string }): void;
2583
+ renderShiftingState(edge: LineEdge | { _: "LineEdge" | string }): void;
2584
+ shouldRenderTargetArrow(edge: LineEdge | { _: "LineEdge" | string }): Promise<boolean>;
2585
+ renderArrowHead(edge: LineEdge | { _: "LineEdge" | string }, direction: Vector | { _: "Vector" | string }, endPoint = edge.bodyLine.end.clone()): Promise<void>;
2586
+ renderCycleState(edge: LineEdge | { _: "LineEdge" | string }): void;
2587
+ getNormalStageSvg(edge: LineEdge | { _: "LineEdge" | string }): Promise<React.ReactNode>;
2588
+ getCycleStageSvg(): Promise<React.ReactNode>;
2589
+ getShiftingStageSvg(): Promise<React.ReactNode>;
2590
+ renderVirtualEdge(startNode: ConnectableEntity | { _: "ConnectableEntity" | string }, mouseLocation: Vector | { _: "Vector" | string }, sourceRectangleRate?: Vector | { _: "Vector" | string }): void;
2591
+ renderVirtualConfirmedEdge(startNode: ConnectableEntity | { _: "ConnectableEntity" | string }, endNode: ConnectableEntity | { _: "ConnectableEntity" | string }, sourceRectangleRate?: Vector | { _: "Vector" | string }, targetRectangleRate?: Vector | { _: "Vector" | string }): void;
2573
2592
  }
2574
2593
 
2575
2594
  declare class WorldRenderUtils {
2576
- constructor(project: Project);
2577
- renderCubicCatmullRomSpline(spline: CubicCatmullRomSpline, color: Color, width: number): void;
2578
- renderBezierCurve(curve: CubicBezierCurve, color: Color, width: number): void;
2579
- renderSymmetryCurve(curve: SymmetryCurve, color: Color, width: number): void;
2580
- renderDashedSymmetryCurve(curve: SymmetryCurve, color: Color, width: number, dashLength: number): void;
2581
- renderDoubleSymmetryCurve(curve: SymmetryCurve, color: Color, width: number, gap: number): void;
2582
- renderLaser(start: Vector, end: Vector, width: number, color: Color): void;
2583
- renderPrismaticBlock(centerLocation: Vector, radius: number, color: Color, strokeColor: Color, strokeWidth: number): void;
2584
- renderRectangleFlash(rectangle: Rectangle, shadowColor: Color, shadowBlur: number, roundedRadius = 0);
2585
- renderCuttingFlash(start: Vector, end: Vector, width: number, shadowColor: Color): void;
2586
- }
2587
-
2588
- // ── Asyncify: 递归包裹所有属性和方法返回值为 Promise ──
2589
- // 用于模拟 Comlink 代理的行为，所有值访问都是异步的
2590
- type Asyncify<T> =
2591
- T extends null | undefined | void | never
2592
- ? T
2593
- : T extends (...args: infer A) => infer R
2594
- ? (...args: A) => Promise<Asyncify<Awaited<R>>>
2595
- : T extends Promise<unknown>
2596
- ? T
2597
- : T extends Array<infer U>
2598
- ? Promise<Asyncify<U>>[]
2599
- : T extends object
2600
- ? { [K in keyof T]: Asyncify<T[K]> }
2601
- : Promise<T>;
2595
+ constructor(project: Project | { _: "Project" | string });
2596
+ renderCubicCatmullRomSpline(spline: CubicCatmullRomSpline | { _: "CubicCatmullRomSpline" | string }, color: Color | { _: "Color" | string }, width: number): void;
2597
+ renderBezierCurve(curve: CubicBezierCurve | { _: "CubicBezierCurve" | string }, color: Color | { _: "Color" | string }, width: number): void;
2598
+ renderSymmetryCurve(curve: SymmetryCurve | { _: "SymmetryCurve" | string }, color: Color | { _: "Color" | string }, width: number): void;
2599
+ renderDashedSymmetryCurve(curve: SymmetryCurve | { _: "SymmetryCurve" | string }, color: Color | { _: "Color" | string }, width: number, dashLength: number): void;
2600
+ renderDoubleSymmetryCurve(curve: SymmetryCurve | { _: "SymmetryCurve" | string }, color: Color | { _: "Color" | string }, width: number, gap: number): void;
2601
+ renderLaser(start: Vector | { _: "Vector" | string }, end: Vector | { _: "Vector" | string }, width: number, color: Color | { _: "Color" | string }): void;
2602
+ renderPrismaticBlock(centerLocation: Vector | { _: "Vector" | string }, radius: number, color: Color | { _: "Color" | string }, strokeColor: Color | { _: "Color" | string }, strokeWidth: number): void;
2603
+ renderRectangleFlash(rectangle: Rectangle | { _: "Rectangle" | string }, shadowColor: Color | { _: "Color" | string }, shadowBlur: number, roundedRadius = 0): Promise<void>;
2604
+ renderCuttingFlash(start: Vector | { _: "Vector" | string }, end: Vector | { _: "Vector" | string }, width: number, shadowColor: Color | { _: "Color" | string }): void;
2605
+ }
2602
2606
 
2603
2607
  // ── 扩展宿主 API ──
2604
2608
 
2605
- export declare function extensionHostApiFactory(extension: Extension): Asyncify<{
2609
+ export declare function extensionHostApiFactory(extension: Extension | { _: "Extension" | string }): {
2606
2610
  toast(message: string): Promise<void>;
2607
2611
  toast_success(message: string): Promise<void>;
2608
2612
  toast_error(message: string): Promise<void>;
@@ -2611,32 +2615,32 @@ export declare function extensionHostApiFactory(extension: Extension): Asyncify<
2611
2615
  dialog_input: typeof Dialog.input;
2612
2616
  dialog_copy: typeof Dialog.copy;
2613
2617
  dialog_buttons: typeof Dialog.buttons;
2614
- fetch: fetch;
2615
- fetch_base64(url: string): Promise<string>;
2616
- fetch_json(url: string): Promise<unknown>;
2617
- fetch_binary(url: string): Promise<{ buffer: Uint8Array; mimeType: string }>;
2618
- shell_execute(program: string, args?: string[], stdin?: string): Promise<{ code: number | null; stdout: string; stderr: string }>;
2618
+ fetch: typeof fetch;
2619
+ fetch_base64(url: string): Promise<Promise<string>>;
2620
+ fetch_json(url: string): Promise<Promise<unknown>>;
2621
+ fetch_binary(url: string): Promise<Promise<{ buffer: Uint8Array; mimeType: string }>>;
2622
+ shell_execute(program: string, args?: string[], stdin?: string): Promise<Promise<{ code: number | null; stdout: string; stderr: string }>>;
2619
2623
  settings_getOwn(key: string): Promise<any>;
2620
2624
  settings_setOwn(key: string, value: unknown): Promise<void>;
2621
2625
  settings_getGlobal(key: string): Promise<any>;
2622
2626
  settings_setGlobal(key: string, value: unknown): Promise<any>;
2623
2627
  keybinds_register(id: string, icon: KeyBindIcon, defaultKey: string, onPress: () => void, onRelease?: () => void, isContinuous?: boolean): Promise<void>;
2624
2628
  keybinds_unregisterAll(): Promise<void>;
2625
- tabs_getAll(): Promise<Tab[]>;
2626
- tabs_getAllProjects(): Promise<Project[]>;
2627
- tabs_getCurrent(): Promise<Tab | null>;
2628
- tabs_getCurrentProject(): Promise<Project | null>;
2629
- entity_registerType(typeName: string, initialData: any, collisionBox: CollisionBox, renderFn: (data: any) => Promise<ImageBitmap>): Promise<void>;
2629
+ tabs_getAll(): Promise<Promise<Tab>[]>;
2630
+ tabs_getAllProjects(): Promise<Promise<Project>[]>;
2631
+ tabs_getCurrent(): Promise<Promise<Tab | null>>;
2632
+ tabs_getCurrentProject(): Promise<Promise<Project | null>>;
2633
+ entity_registerType(typeName: string, initialData: any, collisionBox: CollisionBox | { _: "CollisionBox" | string }, renderFn: (data: any) => Promise<ImageBitmap>): Promise<void>;
2630
2634
  entity_onClick(typeName: string, handler: (payload: ClickEventPayload) => void): Promise<void>;
2631
- entity_create(typeName: string, data: any, location: { x: number; y: number }): Promise<ExtensionEntity>;
2632
- }>;
2635
+ entity_create(typeName: string, data: any, location: { x: number; y: number }): Promise<Promise<ExtensionEntity>>;
2636
+ };
2633
2637
 
2634
2638
  declare global {
2635
- prg: Asyncify<ReturnType<typeof extensionHostApiFactory>>;
2639
+ const prg: ReturnType<typeof extensionHostApiFactory>;
2636
2640
  interface Window {
2637
- prg: Asyncify<ReturnType<typeof extensionHostApiFactory>>;
2641
+ prg: ReturnType<typeof extensionHostApiFactory>;
2638
2642
  }
2639
2643
  interface DedicatedWorkerGlobalScope {
2640
- prg: Asyncify<ReturnType<typeof extensionHostApiFactory>>;
2644
+ prg: ReturnType<typeof extensionHostApiFactory>;
2641
2645
  }
2642
2646
  }