@eightkk/vue-weave 0.0.0-stage → 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (81) hide show
  1. package/CHANGELOG.md +517 -0
  2. package/CONTRIBUTING.md +123 -0
  3. package/LICENSE +21 -0
  4. package/README.ja.md +275 -0
  5. package/README.md +272 -2
  6. package/THIRD_PARTY_NOTICES.md +25 -0
  7. package/dist/core-BH5rTsKp.js +13606 -0
  8. package/dist/core.js +1 -0
  9. package/dist/index.js +8022 -0
  10. package/dist/style.css +2 -0
  11. package/dist/types/components/GanttChart.vue.d.ts +339 -0
  12. package/dist/types/components/NetworkGraph.vue.d.ts +252 -0
  13. package/dist/types/components/types.d.ts +27 -0
  14. package/dist/types/composables/useAsyncGraphLayout.d.ts +163 -0
  15. package/dist/types/composables/useEditHistory.d.ts +13 -0
  16. package/dist/types/composables/useEditTransaction.d.ts +46 -0
  17. package/dist/types/composables/useLinkedSelection.d.ts +118 -0
  18. package/dist/types/composables/useTimelineView.d.ts +24 -0
  19. package/dist/types/composables/useWindowedData.d.ts +83 -0
  20. package/dist/types/core/actuals.d.ts +170 -0
  21. package/dist/types/core/calendarFormat.d.ts +65 -0
  22. package/dist/types/core/editTransaction.d.ts +96 -0
  23. package/dist/types/core/exportSvg.d.ts +236 -0
  24. package/dist/types/core/fieldEditing.d.ts +114 -0
  25. package/dist/types/core/graph.d.ts +196 -0
  26. package/dist/types/core/graphAlgorithms.d.ts +51 -0
  27. package/dist/types/core/graphAnalysis.d.ts +96 -0
  28. package/dist/types/core/graphCollapse.d.ts +62 -0
  29. package/dist/types/core/graphCrossings.d.ts +25 -0
  30. package/dist/types/core/graphEditing.d.ts +52 -0
  31. package/dist/types/core/graphExpansion.d.ts +71 -0
  32. package/dist/types/core/graphFlow.d.ts +184 -0
  33. package/dist/types/core/graphForce.d.ts +29 -0
  34. package/dist/types/core/graphGeometry.d.ts +31 -0
  35. package/dist/types/core/graphIncremental.d.ts +93 -0
  36. package/dist/types/core/graphLasso.d.ts +15 -0
  37. package/dist/types/core/graphLayoutRequests.d.ts +218 -0
  38. package/dist/types/core/graphLayouts.d.ts +81 -0
  39. package/dist/types/core/graphObstacleRouting.d.ts +68 -0
  40. package/dist/types/core/graphPortRules.d.ts +111 -0
  41. package/dist/types/core/graphRouting.d.ts +84 -0
  42. package/dist/types/core/graphSnapping.d.ts +34 -0
  43. package/dist/types/core/graphSpatial.d.ts +49 -0
  44. package/dist/types/core/graphSwimlanes.d.ts +77 -0
  45. package/dist/types/core/graphTraversal.d.ts +51 -0
  46. package/dist/types/core/graphView.d.ts +73 -0
  47. package/dist/types/core/index.d.ts +75 -0
  48. package/dist/types/core/interchange.d.ts +6 -0
  49. package/dist/types/core/interchangeCsv.d.ts +75 -0
  50. package/dist/types/core/interchangeICalendar.d.ts +111 -0
  51. package/dist/types/core/interchangeMsProject.d.ts +339 -0
  52. package/dist/types/core/leveling.d.ts +57 -0
  53. package/dist/types/core/pert.d.ts +62 -0
  54. package/dist/types/core/placement.d.ts +100 -0
  55. package/dist/types/core/planComparison.d.ts +275 -0
  56. package/dist/types/core/resourceLoad.d.ts +65 -0
  57. package/dist/types/core/resourceTimeline.d.ts +179 -0
  58. package/dist/types/core/rowHierarchy.d.ts +25 -0
  59. package/dist/types/core/scheduleDiagnostics.d.ts +37 -0
  60. package/dist/types/core/scheduleModel.d.ts +187 -0
  61. package/dist/types/core/scheduleTrace.d.ts +118 -0
  62. package/dist/types/core/scheduling.d.ts +194 -0
  63. package/dist/types/core/snapshot.d.ts +388 -0
  64. package/dist/types/core/statusDate.d.ts +36 -0
  65. package/dist/types/core/timeRangeTargets.d.ts +67 -0
  66. package/dist/types/core/timeline.d.ts +194 -0
  67. package/dist/types/core/timelineView.d.ts +101 -0
  68. package/dist/types/core/types.d.ts +783 -0
  69. package/dist/types/core/viewBindings.d.ts +112 -0
  70. package/dist/types/core/windowedData.d.ts +255 -0
  71. package/dist/types/core/workCalendar.d.ts +41 -0
  72. package/dist/types/core/workingTimeScale.d.ts +33 -0
  73. package/dist/types/index.d.ts +52 -0
  74. package/docs/api.md +1989 -0
  75. package/docs/architecture.md +112 -0
  76. package/docs/code-of-conduct.md +24 -0
  77. package/docs/integration.md +931 -0
  78. package/docs/scheduling.md +586 -0
  79. package/docs/security.md +26 -0
  80. package/docs/third-party-licenses.md +33 -0
  81. package/package.json +79 -4
@@ -0,0 +1,252 @@
1
+ import type { NetworkNode, GraphLabels, GraphLayoutFunction, GraphViewport, NetworkFocusOptions, NetworkGroup, NetworkNodeSlot, NetworkEdgeSlot } from '../core/types.js';
2
+ import type { GraphContextMenu, GraphFitOptions, GraphGesture, GraphGestureEnd, NetworkTooltipSlot } from '../core/types.js';
3
+ import type { GraphClipboardSelection, GraphPaste } from '../core/types.js';
4
+ import type { GraphLabelEdit, GraphSelectionMode, NetworkEdgeToolbarSlot, NetworkGroupSlot, NetworkMinimapNodeSlot, NetworkNodeToolbarSlot } from '../core/types.js';
5
+ import { type GraphEdge, type GraphLayeredLayoutOptions, type GraphPoint, type GraphNodeMove, type GraphConnection, type GraphReconnect, type GraphNodeSize } from '../core/graph.js';
6
+ import type { GraphEdgeReshape, GraphNodeResize } from '../core/types.js';
7
+ import { type GraphShownEdge, type GraphShownNode } from '../core/graphCollapse.js';
8
+ import { type GraphEdgeStyle } from '../core/graphRouting.js';
9
+ import { type GraphObstacleAvoidance } from '../core/graphObstacleRouting.js';
10
+ import { type GraphRoutingPolicy } from '../core/graphGeometry.js';
11
+ import type { RevealOptions, RevealResult, ViewTarget, ViewTargetEvent } from '../core/viewBindings.js';
12
+ import { type GraphDeletion } from '../core/graphEditing.js';
13
+ import { type GraphPortRules } from '../core/graphPortRules.js';
14
+ import type { GraphDrop } from './types.js';
15
+ import type { ChartDirection, GraphExportOptions, GraphPngExportOptions } from '../core/types.js';
16
+ import { type GraphSwimlaneBand } from '../core/graphSwimlanes.js';
17
+ import { type GraphEdgeBand } from '../core/graphFlow.js';
18
+ declare const __VLS_export: <N extends NetworkNode = NetworkNode, E extends GraphEdge = GraphEdge, G extends NetworkGroup = never>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
19
+ props: import("vue").PublicProps & __VLS_PrettifyLocal<{
20
+ /** Nodes to draw. Each has an ID, label, optional detail, tone, shape and opaque data. Required. */
21
+ nodes: readonly N[];
22
+ /** Edges between nodes. Each has an ID, `from` and `to` node IDs, and optional label, port names (`fromPort`, `toPort`), waypoints (`points`) and data. Required. */
23
+ edges: readonly E[];
24
+ /** Controlled selected node ID; supports `v-model:selected-id`. */
25
+ selectedId?: string;
26
+ /** Controlled set of selected node IDs for multiple selection. Ctrl, Meta or Shift toggles membership; a plain selection replaces the set. */
27
+ selectedIds?: ReadonlySet<string>;
28
+ /** Saved node positions as a map of node ID to absolute chart point, applied over the layout. Positions must be finite and nonnegative. */
29
+ positions?: ReadonlyMap<string, GraphPoint>;
30
+ /** Enables dragging and arrow-key movement of nodes, proposed through `node-move` and `nodes-move`. Opt-in. Default: false. */
31
+ draggable?: boolean;
32
+ /** Shows connection handles on nodes so a drag or two activations propose an edge through `connect`. Opt-in. Default: false. */
33
+ connectable?: boolean;
34
+ /** Lets a selected edge endpoint be dragged to another node or port, proposed through `reconnect`. Opt-in. Default: false. */
35
+ reconnectable?: boolean;
36
+ /** Enables Shift-drag box selection on the canvas; use with controlled `selectedIds`. Opt-in. Default: false. */
37
+ boxSelect?: boolean;
38
+ /** Groups with an ID, label, direct member `nodeIds` and optional `parentId`. Their bounds follow the member nodes. */
39
+ groups?: readonly G[];
40
+ /** Synchronous check of a connection proposal; receives the existing edge ID when reconnecting. Return `true` or nothing to accept, `false` or a reason string to reject. */
41
+ validateConnection?: (connection: GraphConnection, replacingEdgeId?: string) => boolean | string | void;
42
+ /**
43
+ * Port rules (type, direction, connection limit) checked before `validateConnection`; a broken rule rejects the
44
+ * proposal with its reason through `connect-rejected`. While a connection is in progress, handles get
45
+ * `vw-is-valid-target` or `vw-is-invalid-target`. Opt-in. Default: undefined.
46
+ */
47
+ connectionRules?: GraphPortRules;
48
+ /** Shows an overview minimap of the graph and viewport. Opt-in. Default: false. */
49
+ showMinimap?: boolean;
50
+ /** IDs of nodes to emphasize, together with the edges that join two of them. */
51
+ relatedIds?: ReadonlySet<string>;
52
+ /** Configuration of the built-in layered layout: direction, node size, gaps, padding and crossing reduction. Defaults: direction LR, 144 x 58 nodes, column gap 50, row gap 24, padding 20. */
53
+ options?: GraphLayeredLayoutOptions;
54
+ /** Custom layout function that replaces the built-in layout. It must return positive finite dimensions plus a box for every node and a path for every edge. */
55
+ layout?: GraphLayoutFunction<GraphShownNode<N, G>, GraphShownEdge<E, G>>;
56
+ /** Overrides for the English UI strings and accessible names; fields you omit keep their defaults. */
57
+ labels?: Partial<GraphLabels>;
58
+ /** Height of the SVG viewport, as a number of pixels or a CSS length. Default: 220px. */
59
+ height?: number | string;
60
+ /** Shows the zoom and fit buttons. Default: true. */
61
+ showControls?: boolean;
62
+ /** Renders only elements that intersect the viewport plus `cullOverscan`, for large graphs. Opt-in. Default: false. */
63
+ cullOffscreen?: boolean;
64
+ /** Margin in screen pixels around the viewport that stays rendered when culling. Default: 200. */
65
+ cullOverscan?: number;
66
+ /** IDs of matching nodes; nodes outside the set are dimmed. An empty set dims every node. Presentation only. */
67
+ matchIds?: ReadonlySet<string>;
68
+ /** IDs of nodes to dim explicitly; combines with `matchIds`. Presentation only. */
69
+ dimmedIds?: ReadonlySet<string>;
70
+ /** Text direction: `ltr`, `rtl` or `auto`. Mirrors the zoom tools, minimap and label alignment, not the graph geometry. Default: `ltr`. */
71
+ dir?: ChartDirection;
72
+ /** Gives every edge a focusable hit area so it can be selected by click, Enter or Space. Opt-in. Default: false. */
73
+ edgesSelectable?: boolean;
74
+ /** Controlled set of selected edge IDs; supports `v-model:selected-edge-ids`. Unknown IDs are ignored. */
75
+ selectedEdgeIds?: ReadonlySet<string>;
76
+ /** Lets Delete or Backspace propose removing the selected or focused nodes and edges through `delete`. Opt-in. Default: false. */
77
+ deletable?: boolean;
78
+ /** Synchronous check of a deletion proposal. Return `true` or nothing to accept, `false` or a reason string to reject. */
79
+ validateDelete?: (deletion: GraphDeletion) => boolean | string | void;
80
+ /** Reports context menu requests through `context-menu` instead of opening the browser menu. The component renders no menu. Opt-in. Default: false. */
81
+ contextMenu?: boolean;
82
+ /** Hover delay in milliseconds before the `tooltip` slot appears; finite and nonnegative. Default: 400. */
83
+ tooltipDelay?: number;
84
+ /** Grid size in chart units, positive and finite. Drags, keyboard moves, drops and pastes snap to it. */
85
+ snapGrid?: number;
86
+ /** Decorative background pattern that follows pan and zoom: `none`, `dots` or `lines`. Default: `none`. */
87
+ background?: "none" | "dots" | "lines";
88
+ /** Spacing of the background pattern in chart units; positive and finite. Default: `snapGrid`, else 20. */
89
+ backgroundGap?: number;
90
+ /** Snaps a dragged node to edges and centres of other nodes and draws guide lines during a pointer drag. Opt-in. Default: false. */
91
+ alignmentGuides?: boolean;
92
+ /** Snap distance of the alignment guides in screen pixels; finite and nonnegative. Default: 6. */
93
+ guideThreshold?: number;
94
+ /** Pans the camera while a drag or box selection is held within 40 screen pixels of the stage edge. Opt-in. Default: false. */
95
+ autoPan?: boolean;
96
+ /** Accepts HTML drag and drop on the stage and emits `node-drop`. Opt-in. Default: false. */
97
+ droppable?: boolean;
98
+ /** Ctrl or Cmd with C, V and D emit `copy-selection`, `paste-request` and `duplicate-selection`. Opt-in. Default: false. */
99
+ clipboard?: boolean;
100
+ /** Draws collapse and expand toggles on groups. Without `collapsedGroupIds`, the component keeps the collapsed set itself. Opt-in. Default: false. */
101
+ collapsibleGroups?: boolean;
102
+ /** Controlled set of collapsed group IDs; supports `v-model:collapsed-group-ids`. Unknown IDs are ignored. */
103
+ collapsedGroupIds?: ReadonlySet<string>;
104
+ /** Edge routing style: `curve`, `orthogonal` or `straight`. An edge's own `edgeStyle` overrides it. Default: `curve`. */
105
+ edgeStyle?: GraphEdgeStyle;
106
+ /** Distance in chart units between parallel edges (between the same two nodes, in either direction, without waypoints or named ports); they are spread around the centre line, and self-loops of one node are nested. Positive and finite. Opt-in. */
107
+ parallelEdgeSpacing?: number;
108
+ /** Gives edges a focusable hit area and shows waypoint handles on the selected edge, proposed through `edge-reshape`. Opt-in. Default: false. */
109
+ editableEdges?: boolean;
110
+ /** Synchronous check of a waypoint change proposal. Return `true` or nothing to accept, `false` or a reason string to reject. */
111
+ validateEdgeReshape?: (change: GraphEdgeReshape) => boolean | string | void;
112
+ /** Camera scale below which node detail text and edge labels are hidden; greater than 0 and at most 3. */
113
+ lodThreshold?: number;
114
+ /** Leaves the content of the `node` slot unpainted: the stylesheet's fill and stroke rules for node rectangles and text apply to the default renderer only. Opt-in. Default: false. */
115
+ unstyledNodeSlots?: boolean;
116
+ /** Node sizes as a map of node ID to width and height, applied over the layout boxes and keeping each top-left corner. Sizes must be finite and positive; unknown IDs are ignored. */
117
+ sizes?: ReadonlyMap<string, GraphNodeSize>;
118
+ /** Shows corner resize handles on the single selected node, proposed through `node-resize`. Opt-in. Default: false. */
119
+ resizable?: boolean;
120
+ /** Smallest width and height a resize may propose. Default: `{ width: 40, height: 24 }`. */
121
+ minNodeSize?: GraphNodeSize;
122
+ /** Synchronous check of a node resize proposal. Return `true` or nothing to accept, `false` or a reason string to reject. */
123
+ validateNodeResize?: (change: GraphNodeResize) => boolean | string | void;
124
+ /** IDs of nodes drawn in the highlighted style (`vw-is-highlighted`). Display only: never selected, deleted or moved. A node hidden in a collapsed group highlights its proxy. */
125
+ highlightedNodeIds?: ReadonlySet<string>;
126
+ /** IDs of edges drawn in the highlighted style. Display only. A merged edge of a collapsed group is highlighted when one of its original edges is. */
127
+ highlightedEdgeIds?: ReadonlySet<string>;
128
+ /** `builtin` redraws every edge with a named port and, in the orthogonal and straight styles, every edge. `preserve` keeps the paths of the layout while they still fit their nodes and ports. Default: `builtin`. */
129
+ routingPolicy?: GraphRoutingPolicy;
130
+ /** Routes orthogonal edges without waypoints around the node boxes: `true` for an 8-unit clearance, or `{ clearance, bendPenalty }`. Opt-in. Default: false. */
131
+ avoidNodes?: boolean | GraphObstacleAvoidance;
132
+ /** Lets a double-click or F2 on a node or edge open an in-place editor for its label, proposed through `label-edit`. Gives edges their focusable hit area. Opt-in. Default: false. */
133
+ editableLabels?: boolean;
134
+ /** Synchronous check of a label proposal. Return `true` or nothing to accept, `false` or a reason string to reject. */
135
+ validateLabelEdit?: (change: GraphLabelEdit) => boolean | string | void;
136
+ /** Shape of the `boxSelect` drag: `box` (a rectangle) or `lasso` (a free-form outline that selects the nodes whose centre it encloses). Default: `box`. */
137
+ selectionMode?: GraphSelectionMode;
138
+ /**
139
+ * Swimlane bands drawn behind the groups, edges and nodes, each with its title in its header area and the title as
140
+ * its accessible name; usually the `lanes` of a `layoutSwimlaneGraph` result. Display only: the component never
141
+ * changes a node's lane (see `graphSwimlaneAt`). Opt-in. Default: undefined.
142
+ */
143
+ lanes?: readonly GraphSwimlaneBand[];
144
+ /**
145
+ * Edges drawn as bands with real width, by edge ID, usually `graphFlowBands` of a `layoutFlowGraph` result: the
146
+ * default edge path is stroked with the band width (class `vw-network-band`, dashed with `vw-is-reference`) without
147
+ * markers, its hit area is at least as wide, and the band label names it. Bands are drawn widest first, before the
148
+ * other edges. Widths must be finite and at least 0; unknown IDs are ignored. Opt-in. Default: undefined.
149
+ */
150
+ edgeBands?: ReadonlyMap<string, GraphEdgeBand>;
151
+ } & {
152
+ onSelect?: ((id: string) => any) | undefined;
153
+ "onNode-resize"?: ((change: GraphNodeResize) => any) | undefined;
154
+ "onEdge-reshape"?: ((change: GraphEdgeReshape) => any) | undefined;
155
+ onConnect?: ((connection: GraphConnection) => any) | undefined;
156
+ onReconnect?: ((change: GraphReconnect) => any) | undefined;
157
+ "onUpdate:selectedId"?: ((id: string) => any) | undefined;
158
+ "onUpdate:selectedIds"?: ((ids: Set<string>) => any) | undefined;
159
+ "onNode-move"?: ((change: GraphNodeMove) => any) | undefined;
160
+ "onNodes-move"?: ((changes: GraphNodeMove[]) => any) | undefined;
161
+ "onConnect-rejected"?: ((connection: GraphConnection, reason: string) => any) | undefined;
162
+ "onViewport-change"?: ((viewport: GraphViewport) => any) | undefined;
163
+ "onUpdate:selectedEdgeIds"?: ((ids: Set<string>) => any) | undefined;
164
+ "onEdge-select"?: ((id: string) => any) | undefined;
165
+ onDelete?: ((deletion: GraphDeletion) => any) | undefined;
166
+ "onDelete-rejected"?: ((deletion: GraphDeletion, reason: string) => any) | undefined;
167
+ "onContext-menu"?: ((event: GraphContextMenu) => any) | undefined;
168
+ "onNode-drop"?: ((event: GraphDrop) => any) | undefined;
169
+ "onCopy-selection"?: ((selection: GraphClipboardSelection) => any) | undefined;
170
+ "onPaste-request"?: ((event: GraphPaste) => any) | undefined;
171
+ "onDuplicate-selection"?: ((selection: GraphClipboardSelection) => any) | undefined;
172
+ "onUpdate:collapsedGroupIds"?: ((ids: Set<string>) => any) | undefined;
173
+ "onEdge-reshape-rejected"?: ((change: GraphEdgeReshape, reason: string) => any) | undefined;
174
+ "onNode-resize-rejected"?: ((change: GraphNodeResize, reason: string) => any) | undefined;
175
+ "onTarget-enter"?: ((event: ViewTargetEvent<{
176
+ view: "graph";
177
+ kind: "node" | "edge" | "group";
178
+ id: string;
179
+ }>) => any) | undefined;
180
+ "onTarget-leave"?: ((event: ViewTargetEvent<{
181
+ view: "graph";
182
+ kind: "node" | "edge" | "group";
183
+ id: string;
184
+ }>) => any) | undefined;
185
+ "onTarget-activate"?: ((event: ViewTargetEvent<{
186
+ view: "graph";
187
+ kind: "node" | "edge" | "group";
188
+ id: string;
189
+ }>) => any) | undefined;
190
+ "onGesture-start"?: ((gesture: GraphGesture) => any) | undefined;
191
+ "onGesture-end"?: ((gesture: GraphGestureEnd) => any) | undefined;
192
+ "onLabel-edit"?: ((change: GraphLabelEdit) => any) | undefined;
193
+ "onLabel-edit-rejected"?: ((change: GraphLabelEdit, reason: string) => any) | undefined;
194
+ }> & (typeof globalThis extends {
195
+ __VLS_PROPS_FALLBACK: infer P;
196
+ } ? P : {});
197
+ expose: (exposed: import("vue").ShallowUnwrapRef<{
198
+ fit: (options?: GraphFitOptions) => void;
199
+ zoom: (factor: number, x?: number, y?: number) => void;
200
+ getViewport: () => {
201
+ x: number;
202
+ y: number;
203
+ scale: number;
204
+ };
205
+ setViewport: (value: GraphViewport) => void;
206
+ focusNode: (id: string, options?: NetworkFocusOptions) => void;
207
+ exportSvg: (options?: GraphExportOptions<GraphShownNode<N, G>, GraphShownEdge<E, G>>) => string;
208
+ exportPng: (options?: GraphPngExportOptions<GraphShownNode<N, G>, GraphShownEdge<E, G>>) => Promise<Blob>;
209
+ toGraphPoint: (clientX: number, clientY: number) => GraphPoint;
210
+ getViewportCenter: () => GraphPoint;
211
+ revealNode: (id: string, options?: RevealOptions) => Promise<RevealResult>;
212
+ getTargetClientRect: (target: ViewTarget) => DOMRect | undefined;
213
+ setViewportCenter: (center: GraphPoint, scale?: number) => void;
214
+ }>) => void;
215
+ attrs: any;
216
+ slots: {
217
+ node(props: NetworkNodeSlot<GraphShownNode<N, G>>): unknown;
218
+ edge(props: NetworkEdgeSlot<GraphShownEdge<E, G>>): unknown;
219
+ empty(): unknown;
220
+ tooltip?(props: NetworkTooltipSlot<GraphShownNode<N, G>, GraphShownEdge<E, G>>): unknown;
221
+ /** HTML anchored above the only selected node; it keeps its size at every zoom level. */
222
+ 'node-toolbar'?(props: NetworkNodeToolbarSlot<GraphShownNode<N, G>>): unknown;
223
+ /** HTML anchored above the selected edge's label point; it keeps its size at every zoom level. */
224
+ 'edge-toolbar'?(props: NetworkEdgeToolbarSlot<GraphShownEdge<E, G>>): unknown;
225
+ /** SVG that replaces a group's frame and label, in chart coordinates. */
226
+ group?(props: NetworkGroupSlot<G>): unknown;
227
+ /** SVG that replaces a node's rectangle in the minimap, in chart coordinates. */
228
+ 'minimap-node'?(props: NetworkMinimapNodeSlot<GraphShownNode<N, G>>): unknown;
229
+ };
230
+ emit: ((evt: "select", id: string) => void) & ((evt: "node-resize", change: GraphNodeResize) => void) & ((evt: "edge-reshape", change: GraphEdgeReshape) => void) & ((evt: "connect", connection: GraphConnection) => void) & ((evt: "reconnect", change: GraphReconnect) => void) & ((evt: "update:selectedId", id: string) => void) & ((evt: "update:selectedIds", ids: Set<string>) => void) & ((evt: "node-move", change: GraphNodeMove) => void) & ((evt: "nodes-move", changes: GraphNodeMove[]) => void) & ((evt: "connect-rejected", connection: GraphConnection, reason: string) => void) & ((evt: "viewport-change", viewport: GraphViewport) => void) & ((evt: "update:selectedEdgeIds", ids: Set<string>) => void) & ((evt: "edge-select", id: string) => void) & ((evt: "delete", deletion: GraphDeletion) => void) & ((evt: "delete-rejected", deletion: GraphDeletion, reason: string) => void) & ((evt: "context-menu", event: GraphContextMenu) => void) & ((evt: "node-drop", event: GraphDrop) => void) & ((evt: "copy-selection", selection: GraphClipboardSelection) => void) & ((evt: "paste-request", event: GraphPaste) => void) & ((evt: "duplicate-selection", selection: GraphClipboardSelection) => void) & ((evt: "update:collapsedGroupIds", ids: Set<string>) => void) & ((evt: "edge-reshape-rejected", change: GraphEdgeReshape, reason: string) => void) & ((evt: "node-resize-rejected", change: GraphNodeResize, reason: string) => void) & ((evt: "target-enter", event: ViewTargetEvent<{
231
+ view: "graph";
232
+ kind: "node" | "edge" | "group";
233
+ id: string;
234
+ }>) => void) & ((evt: "target-leave", event: ViewTargetEvent<{
235
+ view: "graph";
236
+ kind: "node" | "edge" | "group";
237
+ id: string;
238
+ }>) => void) & ((evt: "target-activate", event: ViewTargetEvent<{
239
+ view: "graph";
240
+ kind: "node" | "edge" | "group";
241
+ id: string;
242
+ }>) => void) & ((evt: "gesture-start", gesture: GraphGesture) => void) & ((evt: "gesture-end", gesture: GraphGestureEnd) => void) & ((evt: "label-edit", change: GraphLabelEdit) => void) & ((evt: "label-edit-rejected", change: GraphLabelEdit, reason: string) => void);
243
+ }>) => import("vue").VNode & {
244
+ __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
245
+ };
246
+ declare const _default: typeof __VLS_export;
247
+ export default _default;
248
+ type __VLS_PrettifyLocal<T> = (T extends any ? {
249
+ [K in keyof T]: T[K];
250
+ } : {
251
+ [K in keyof T as K]: T[K];
252
+ }) & {};
@@ -0,0 +1,27 @@
1
+ import type { GraphPoint } from '../core/graph.js';
2
+ /**
3
+ * Payload of the NetworkGraph `node-drop` event (`droppable`). It refers to the DOM `DataTransfer`, so it is exported from
4
+ * the Vue entry only; the core entry stays free of browser types.
5
+ */
6
+ export interface GraphDrop {
7
+ /** The drop position in chart coordinates, rounded to `snapGrid` when it is set. */
8
+ point: GraphPoint;
9
+ clientX: number;
10
+ clientY: number;
11
+ /** The data of the HTML drag, as the browser supplied it. */
12
+ dataTransfer: DataTransfer | null;
13
+ }
14
+ /**
15
+ * Payload of the GanttChart `bar-drop` event (`droppable`). Like `GraphDrop`, it refers to the DOM `DataTransfer`, so it
16
+ * is exported from the Vue entry only. The chart does not read the data; the application resolves what was dropped.
17
+ */
18
+ export interface TimelineDrop {
19
+ /** Time under the drop point, snapped to the active `snap` and clamped to the time axis. */
20
+ time: number;
21
+ /** The displayed task row under the drop point. Absent over the header and the load rows. */
22
+ rowId?: string;
23
+ clientX: number;
24
+ clientY: number;
25
+ /** The data of the HTML drag, as the browser supplied it. */
26
+ dataTransfer: DataTransfer | null;
27
+ }
@@ -0,0 +1,163 @@
1
+ import { type MaybeRefOrGetter, type Ref, type ShallowRef } from 'vue';
2
+ import type { GraphEdge, GraphLayout, GraphLayoutDirection, GraphNodeSize, GraphPoint } from '../core/graph.js';
3
+ import type { GraphShownEdge, GraphShownNode } from '../core/graphCollapse.js';
4
+ import { type GraphLayoutRequest, type GraphLayoutRequestInput, type GraphLayoutScope } from '../core/graphLayoutRequests.js';
5
+ import type { GraphGesture, GraphGestureEnd, GraphLayoutFunction, NetworkGroup, NetworkNode } from '../core/types.js';
6
+ /**
7
+ * Computes one layout request. It may return the layout or a promise of it. `signal` is aborted when the result is no
8
+ * longer wanted; an engine that can stop early should, but the result is discarded either way.
9
+ */
10
+ export type AsyncGraphLayoutAdapter<N extends NetworkNode = NetworkNode, E extends GraphEdge = GraphEdge, G extends NetworkGroup = NetworkGroup> = (request: GraphLayoutRequest<GraphShownNode<N, G>, GraphShownEdge<E, G>, NetworkGroup>, signal: AbortSignal) => GraphLayout | Promise<GraphLayout>;
11
+ /** The input of one frame: the graph and every condition its layout depends on. */
12
+ export interface AsyncGraphFrame<N extends NetworkNode = NetworkNode, E extends GraphEdge = GraphEdge, G extends NetworkGroup = NetworkGroup> {
13
+ revision: string;
14
+ nodes: readonly N[];
15
+ edges: readonly E[];
16
+ groups: readonly G[];
17
+ /** The collapsed group IDs as given, for NetworkGraph `collapsedGroupIds`. */
18
+ collapsedGroupIds: ReadonlySet<string>;
19
+ direction: GraphLayoutDirection;
20
+ positions?: ReadonlyMap<string, GraphPoint>;
21
+ sizes?: ReadonlyMap<string, GraphNodeSize>;
22
+ /** Pinned nodes for an incremental engine, as given in the input. */
23
+ fixedIds?: ReadonlySet<string>;
24
+ /** New nodes for an incremental engine, as given in the input. */
25
+ addedIds?: ReadonlySet<string>;
26
+ settings?: unknown;
27
+ /** Input keys of the frame's requests; `expanded` only while a group is collapsed. */
28
+ inputKeys: {
29
+ shown: string;
30
+ expanded?: string;
31
+ };
32
+ }
33
+ /** A frame whose layouts are ready: everything NetworkGraph needs, consistent with one input. */
34
+ export interface AsyncGraphDisplayFrame<N extends NetworkNode = NetworkNode, E extends GraphEdge = GraphEdge, G extends NetworkGroup = NetworkGroup> extends AsyncGraphFrame<N, E, G> {
35
+ layouts: {
36
+ shown: GraphLayout;
37
+ expanded?: GraphLayout;
38
+ };
39
+ /**
40
+ * 'initial' from `initialLayout`; 'layout' from the adapter; 'provisional' from the previous layouts with temporary
41
+ * routes for new edges (`temporaryEdgeIds`), shown while the adapter computes the frame.
42
+ */
43
+ source: 'initial' | 'layout' | 'provisional';
44
+ /** Edges drawn with a temporary built-in route (see `completeGraphLayout`). */
45
+ temporaryEdgeIds: readonly string[];
46
+ }
47
+ /**
48
+ * NetworkGraph listeners for its `gesture-start` and `gesture-end` events. Bind them with `v-bind` (or spread them into
49
+ * `h(NetworkGraph, props)`); they can sit next to listeners of the application for the same events.
50
+ */
51
+ export interface AsyncGraphGestureListeners {
52
+ onGestureStart: (gesture: GraphGesture) => void;
53
+ onGestureEnd: (gesture: GraphGestureEnd) => void;
54
+ }
55
+ /** A failed layout request of the desired frame. The display keeps the last consistent frame. */
56
+ export interface AsyncGraphLayoutError {
57
+ revision: string;
58
+ requestId: string;
59
+ inputKey: string;
60
+ scope: GraphLayoutScope;
61
+ error: unknown;
62
+ }
63
+ export interface UseAsyncGraphLayoutOptions<N extends NetworkNode = NetworkNode, E extends GraphEdge = GraphEdge, G extends NetworkGroup = NetworkGroup> {
64
+ /** The layout input. Pass a getter (or a ref) that returns a new object whenever any part of the input changes. */
65
+ input: MaybeRefOrGetter<GraphLayoutRequestInput<N, E, G>>;
66
+ /** Computes a request, for example by posting it to a Worker (see `graphLayoutWorkerAdapter`). */
67
+ adapter: AsyncGraphLayoutAdapter<N, E, G>;
68
+ /**
69
+ * A synchronous layout for the first frame, such as `layoutLayeredGraph`. It is used during server rendering and on
70
+ * the first client render, so both render the same frame; without it `display` stays undefined until the first
71
+ * result arrives (show a loading state in the meantime).
72
+ */
73
+ initialLayout?: (nodes: readonly GraphShownNode<N, G>[], edges: readonly GraphShownEdge<E, G>[]) => GraphLayout;
74
+ /**
75
+ * While true, finished frames wait and are shown when it turns false, so an ongoing drag is not cancelled. Frames
76
+ * also wait while a gesture reported through `gestureListeners` is in flight; this option is for gestures the
77
+ * application tracks itself.
78
+ */
79
+ gesture?: MaybeRefOrGetter<boolean>;
80
+ /**
81
+ * Default true. When every node of the new input already has a box in the displayed layouts (for example after an
82
+ * edge is connected or removed), show the new input right away with the previous boxes and temporary routes for new
83
+ * edges, until the adapter's result arrives.
84
+ */
85
+ provisional?: boolean;
86
+ /**
87
+ * Default 32. The number of computed layouts kept for reuse by later inputs, by scope and input key, least recently
88
+ * used first out: an input whose key was computed before (expanding a group again, undoing an edit) is shown without
89
+ * a request. 0 keeps none, so every new input is requested even if an earlier one had the same key. The cache never
90
+ * decides whether the current input is complete: the layouts and failures of the desired frame are held with the
91
+ * frame until the input changes, so any size, 0 included, shows a frame once all its layouts have arrived, and a
92
+ * failed request is not repeated until the input changes.
93
+ */
94
+ cacheSize?: number;
95
+ }
96
+ export interface AsyncGraphLayout<N extends NetworkNode = NetworkNode, E extends GraphEdge = GraphEdge, G extends NetworkGroup = NetworkGroup> {
97
+ /** The latest input, whose layouts are requested. */
98
+ desired: Readonly<ShallowRef<AsyncGraphFrame<N, E, G> | undefined>>;
99
+ /** The last frame whose layouts are ready. Bind all of its fields to NetworkGraph together. */
100
+ display: Readonly<ShallowRef<AsyncGraphDisplayFrame<N, E, G> | undefined>>;
101
+ /**
102
+ * The NetworkGraph `layout` function. Its identity never changes, so a new result does not re-fit the camera; it
103
+ * returns the display frame's layouts and throws Error for nodes and edges that are not the display frame's.
104
+ */
105
+ layout: GraphLayoutFunction<GraphShownNode<N, G>, GraphShownEdge<E, G>>;
106
+ /** True while layouts of the desired frame are being computed. */
107
+ pending: Readonly<Ref<boolean>>;
108
+ /** True while a finished frame waits for the gesture to end. */
109
+ deferred: Readonly<Ref<boolean>>;
110
+ /**
111
+ * Listeners to bind to NetworkGraph (`v-bind="graph.gestureListeners"`). While a gesture they reported is in flight,
112
+ * finished frames wait as they do while `gesture` is true. Their identity never changes.
113
+ */
114
+ gestureListeners: Readonly<AsyncGraphGestureListeners>;
115
+ /** True while a gesture reported through `gestureListeners` is in flight or the `gesture` option is true. */
116
+ gesturing: Readonly<Ref<boolean>>;
117
+ /**
118
+ * The last failure of the desired frame; cleared when the input changes. A failed request is not repeated for the
119
+ * same input, so the frame is not shown (and `pending` is false) until the input changes, even when its other scope
120
+ * succeeds.
121
+ */
122
+ error: Readonly<ShallowRef<AsyncGraphLayoutError | undefined>>;
123
+ /** Stops waiting for the requests in flight (aborting their signals) and discards their results. */
124
+ cancel: () => void;
125
+ /** Cancels, stops watching the input and ignores every later result. Called automatically with the owning scope. */
126
+ dispose: () => void;
127
+ }
128
+ /**
129
+ * Asynchronous layouts for NetworkGraph. The input is turned into layout requests as NetworkGraph would lay it out
130
+ * (`buildGraphLayoutRequests`), the adapter computes them, and `display` changes only when every layout of one input is
131
+ * ready (both scopes while a group is collapsed), so the nodes, edges, collapse state and layouts passed to the graph
132
+ * always belong together. Results of older or cancelled requests are never shown; a failure keeps the last display.
133
+ * Requests start when the owning component mounts (immediately outside a component), so nothing is started during
134
+ * server rendering. Use the graph's `collapsedGroupIds` prop with the frame's value: an uncontrolled collapse would ask
135
+ * for a layout that has not been computed.
136
+ */
137
+ export declare function useAsyncGraphLayout<N extends NetworkNode, E extends GraphEdge, G extends NetworkGroup = NetworkGroup>(options: UseAsyncGraphLayoutOptions<N, E, G>): AsyncGraphLayout<N, E, G>;
138
+ /** The message port of a layout Worker: a `Worker`, a `MessagePort` or anything with the same three methods. */
139
+ export interface GraphLayoutWorkerPort {
140
+ postMessage(message: unknown): void;
141
+ addEventListener(type: 'message', listener: (event: {
142
+ data: unknown;
143
+ }) => void): void;
144
+ removeEventListener(type: 'message', listener: (event: {
145
+ data: unknown;
146
+ }) => void): void;
147
+ }
148
+ export interface GraphLayoutWorkerAdapterOptions {
149
+ /**
150
+ * 'clone' (default) posts messages with their Maps for structured clone; 'json' posts JSON text with Maps as entry
151
+ * arrays and expects JSON text back.
152
+ */
153
+ transport?: 'clone' | 'json';
154
+ }
155
+ /**
156
+ * An adapter for `useAsyncGraphLayout` that posts each request to a Worker as a 'request' message, resolves with the
157
+ * matching 'success' message (same `requestId` and `inputKey`), rejects with the 'failure' message, and posts a 'cancel'
158
+ * message when the request is aborted. Messages for other requests are ignored; a malformed message for this request,
159
+ * or a response with its `requestId` and `inputKey` but another `scope`, rejects it. When posting the request throws,
160
+ * the request rejects with that error. However a request ends (response, failure, abort or a failed post), its
161
+ * listeners on the port and the signal are removed. The caller creates the Worker.
162
+ */
163
+ export declare function graphLayoutWorkerAdapter(port: GraphLayoutWorkerPort, options?: GraphLayoutWorkerAdapterOptions): AsyncGraphLayoutAdapter<any, any, any>;
@@ -0,0 +1,13 @@
1
+ /** Retain immutable application snapshots. One commit represents one user action. */
2
+ export declare function useEditHistory<T>(initial: T, limit?: number): {
3
+ state: import("vue").ComputedRef<T>;
4
+ canUndo: import("vue").ComputedRef<boolean>;
5
+ canRedo: import("vue").ComputedRef<boolean>;
6
+ commit: (snapshot: T) => void;
7
+ undo: () => void;
8
+ redo: () => void;
9
+ reset: (snapshot: T) => void;
10
+ peekUndo: () => T | undefined;
11
+ peekRedo: () => T | undefined;
12
+ replaceCurrent: (snapshot: T) => void;
13
+ };
@@ -0,0 +1,46 @@
1
+ import type { ShallowRef } from 'vue';
2
+ import type { SaveResult, TransactionAdapter, TransactionOutcome, TransactionSource } from '../core/editTransaction.js';
3
+ export interface UseEditTransactionOptions<S, P> {
4
+ documentId: string;
5
+ initialState: S;
6
+ initialVersion: string;
7
+ adapter: TransactionAdapter<S, P>;
8
+ /** Produces a unique operation ID per save. Defaults to `crypto.randomUUID()` with a counter fallback. */
9
+ createOperationId?: () => string;
10
+ /** Maximum number of undo steps. Defaults to 100. */
11
+ historyLimit?: number;
12
+ onHistoryReset?: (reset: HistoryReset) => void;
13
+ }
14
+ export interface HistoryReset {
15
+ reason: 'refresh';
16
+ version: string;
17
+ }
18
+ /**
19
+ * Server-confirmed edits with undo and redo. The accepted state changes only after the server accepts a
20
+ * transaction; the candidate is shown separately while saving. Undo and redo restore history snapshots
21
+ * against the current accepted version, and move the history position only after acceptance.
22
+ */
23
+ export declare function useEditTransaction<S, P>(options: UseEditTransactionOptions<S, P>): {
24
+ acceptedState: import("vue").ComputedRef<S>;
25
+ acceptedVersion: import("vue").ComputedRef<string>;
26
+ candidateState: import("vue").ComputedRef<S | undefined>;
27
+ status: import("vue").ComputedRef<import("../index.js").TransactionStatus>;
28
+ pendingTransaction: import("vue").ComputedRef<{
29
+ operationId: string;
30
+ kind: "changes" | "restore";
31
+ source: TransactionSource;
32
+ baseVersion: string;
33
+ } | undefined>;
34
+ result: import("vue").ComputedRef<import("../index.js").TransactionFailure | undefined>;
35
+ historyReset: ShallowRef<HistoryReset | undefined>;
36
+ canUndo: import("vue").ComputedRef<boolean>;
37
+ canRedo: import("vue").ComputedRef<boolean>;
38
+ submit: (changes: readonly P[], submitOptions?: {
39
+ source?: "pointer" | "keyboard" | "api";
40
+ }) => Promise<TransactionOutcome<S>>;
41
+ undo: () => Promise<TransactionOutcome<S>>;
42
+ redo: () => Promise<TransactionOutcome<S>>;
43
+ refresh: (state: S, version: string) => void;
44
+ reconcile: (reconciled: SaveResult<S>) => TransactionOutcome<S>;
45
+ clearResult: () => void;
46
+ };
@@ -0,0 +1,118 @@
1
+ import type { MaybeRefOrGetter } from 'vue';
2
+ import type { EntityRef, LoadViewTarget, RevealResult, ViewBinding, ViewTarget } from '../core/viewBindings.js';
3
+ import type { TimelineBarActivity, TimelineBarsInRangeOptions, TimeRangeTargets, TimeRangeTargetsOptions } from '../core/timeRangeTargets.js';
4
+ import type { TimeRange } from '../core/timeline.js';
5
+ export type LinkedViewName = ViewTarget['view'];
6
+ export interface UseLinkedSelectionOptions {
7
+ /** The links between entities and what the views show. Reactive: a change re-resolves the current selection. */
8
+ bindings: MaybeRefOrGetter<readonly ViewBinding[]>;
9
+ /**
10
+ * Called after a `select` or `clearSelection` that changed the selection, with the selected entities and the view
11
+ * that owns the selection. It is not called for hover or for a repeated identical selection.
12
+ */
13
+ onSelect?: (entities: readonly EntityRef[], owner: LinkedViewName | undefined) => void;
14
+ /**
15
+ * An optional time range to explore. The bars worked on in it (`timelineBarsInRange`) and their entities' targets are
16
+ * added to the `highlighted*` sets; what `traversal` reaches from them goes to the separate `related*` sets. Display
17
+ * only: it never changes the selection. Undefined, or leaving the option out, changes nothing.
18
+ */
19
+ timeRange?: MaybeRefOrGetter<LinkedTimeRange | undefined>;
20
+ }
21
+ /** Input of the `timeRange` option of `useLinkedSelection`. */
22
+ export interface LinkedTimeRange extends TimelineBarsInRangeOptions, TimeRangeTargetsOptions {
23
+ /** The half-open range `[start, end)`; `start === end` is an instant. */
24
+ range: TimeRange;
25
+ /** The bars to test, usually the bars given to GanttChart. */
26
+ bars: readonly TimelineBarActivity[];
27
+ }
28
+ /** What to pass to a graph view: its own selection and display-only highlights. */
29
+ export interface LinkedGraphSets {
30
+ /** Selected only when the graph owns the selection; otherwise empty. Use for `selectedIds`. */
31
+ selectedNodeIds: ReadonlySet<string>;
32
+ selectedEdgeIds: ReadonlySet<string>;
33
+ /** Linked nodes, edges and groups that are not selected in this view, from the selection and from hover. */
34
+ highlightedNodeIds: ReadonlySet<string>;
35
+ highlightedEdgeIds: ReadonlySet<string>;
36
+ highlightedGroupIds: ReadonlySet<string>;
37
+ /**
38
+ * Nodes, edges and groups related to a `timeRange` by traversal, without selected or highlighted ones. Empty without
39
+ * `timeRange`. Use for NetworkGraph `relatedIds` or your own styling.
40
+ */
41
+ relatedNodeIds: ReadonlySet<string>;
42
+ relatedEdgeIds: ReadonlySet<string>;
43
+ relatedGroupIds: ReadonlySet<string>;
44
+ }
45
+ /** What to pass to a timeline view. */
46
+ export interface LinkedTimelineSets {
47
+ selectedBarIds: ReadonlySet<string>;
48
+ highlightedBarIds: ReadonlySet<string>;
49
+ highlightedDependencyIds: ReadonlySet<string>;
50
+ highlightedRowIds: ReadonlySet<string>;
51
+ /** Bars, dependencies and rows related to a `timeRange` by traversal, without selected or highlighted ones. */
52
+ relatedBarIds: ReadonlySet<string>;
53
+ relatedDependencyIds: ReadonlySet<string>;
54
+ relatedRowIds: ReadonlySet<string>;
55
+ }
56
+ /** Load targets are time ranges; resolve them against current segments with `resolveLoadTargets`. */
57
+ export interface LinkedLoadSets {
58
+ selected: readonly LoadViewTarget[];
59
+ highlighted: readonly LoadViewTarget[];
60
+ /** Load targets related to a `timeRange` by traversal, without selected or highlighted ones. */
61
+ related: readonly LoadViewTarget[];
62
+ }
63
+ /**
64
+ * Links selection and hover across views (graph, timeline, load) through entity bindings. The view the user acted in
65
+ * owns the selection: its sets contain what it selected, and every view, the owner included, gets display-only
66
+ * highlight sets for the other linked targets. Selection of other views is never written into an owner's `selectedIds`,
67
+ * so linked views cannot delete, move or cancel a drag. Reporting the same selection again changes nothing and does not
68
+ * call `onSelect`, so wiring a view's events back to this composable cannot loop. Hover is highlight only.
69
+ */
70
+ export declare function useLinkedSelection(options: UseLinkedSelectionOptions): {
71
+ /** The view that owns the selection, or undefined. */
72
+ owner: import("vue").ComputedRef<"load" | "graph" | "timeline" | undefined>;
73
+ /** The selected entities. */
74
+ selectedEntities: import("vue").ComputedRef<EntityRef[]>;
75
+ /** The hovered entities. */
76
+ hoveredEntities: import("vue").ComputedRef<readonly EntityRef[]>;
77
+ /** What the `timeRange` option resolves to (active and related bars, entities and targets), or undefined without one. */
78
+ timeRange: import("vue").ComputedRef<TimeRangeTargets | undefined>;
79
+ graph: import("vue").ComputedRef<LinkedGraphSets>;
80
+ timeline: import("vue").ComputedRef<LinkedTimelineSets>;
81
+ load: import("vue").ComputedRef<LinkedLoadSets>;
82
+ select: (view: LinkedViewName, targets: readonly ViewTarget[]) => {
83
+ changed: boolean;
84
+ unknown: ViewTarget[];
85
+ };
86
+ clearSelection: () => boolean;
87
+ hoverEnter: (view: LinkedViewName, target: ViewTarget) => void;
88
+ hoverLeave: (view: LinkedViewName, target?: ViewTarget) => void;
89
+ };
90
+ export interface RevealLinkedTargetOptions {
91
+ /**
92
+ * Calls the reveal method of the view, for example `() => graph.value?.revealNode(id, { focus: true })`. It is called
93
+ * again after each accepted expansion. Returning undefined (no mounted view) counts as `unknown`.
94
+ */
95
+ reveal: () => Promise<RevealResult> | RevealResult | undefined;
96
+ /**
97
+ * Asked when the item is hidden by a collapsed group or row. Expand `proxyId` in the controlled `collapsedGroupIds`
98
+ * (graph) or `collapsedIds` (timeline) and return true, or return false to decline. Without it, nothing is expanded
99
+ * and the `hidden-by-collapse` result is returned.
100
+ */
101
+ expand?: (proxyId: string, result: RevealResult) => boolean | Promise<boolean>;
102
+ /** The most expansions to try for nested collapses. Default 16. */
103
+ maxExpansions?: number;
104
+ }
105
+ export interface LinkedRevealResult extends RevealResult {
106
+ /** The proxies that `expand` accepted, in order. */
107
+ expandedIds: string[];
108
+ /** True when `expand` declined, or accepted without the item becoming visible. The status is then not `revealed`. */
109
+ declined?: boolean;
110
+ }
111
+ /**
112
+ * Reveals an item of a view and, when a collapsed ancestor hides it, offers the application to expand that ancestor:
113
+ * reveal, ask `expand(proxyId)`, wait for the render (`nextTick` twice: props, then layout and DOM), reveal again, until
114
+ * the item is shown, unknown, or the application declines. It never expands anything itself and never reports
115
+ * `revealed` unless the last reveal did. An expansion that is accepted but leaves the same proxy in place counts as
116
+ * declined, so an application that does not update the controlled set cannot loop.
117
+ */
118
+ export declare function revealLinkedTarget(options: RevealLinkedTargetOptions): Promise<LinkedRevealResult>;