@vielzeug/wire 0.0.0-stage → 26.11.24
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +21 -0
- package/README.md +48 -2
- package/dist/_format.cjs +2 -0
- package/dist/_format.cjs.map +1 -0
- package/dist/_format.d.ts +3 -0
- package/dist/_format.d.ts.map +1 -0
- package/dist/_format.js +8 -0
- package/dist/_format.js.map +1 -0
- package/dist/_heap.cjs +2 -0
- package/dist/_heap.cjs.map +1 -0
- package/dist/_heap.d.ts +12 -0
- package/dist/_heap.d.ts.map +1 -0
- package/dist/_heap.js +37 -0
- package/dist/_heap.js.map +1 -0
- package/dist/_sides.cjs +2 -0
- package/dist/_sides.cjs.map +1 -0
- package/dist/_sides.d.ts +20 -0
- package/dist/_sides.d.ts.map +1 -0
- package/dist/_sides.js +55 -0
- package/dist/_sides.js.map +1 -0
- package/dist/bezier.cjs +2 -0
- package/dist/bezier.cjs.map +1 -0
- package/dist/bezier.d.ts +24 -0
- package/dist/bezier.d.ts.map +1 -0
- package/dist/bezier.js +34 -0
- package/dist/bezier.js.map +1 -0
- package/dist/edit.cjs +2 -0
- package/dist/edit.cjs.map +1 -0
- package/dist/edit.d.ts +93 -0
- package/dist/edit.d.ts.map +1 -0
- package/dist/edit.js +170 -0
- package/dist/edit.js.map +1 -0
- package/dist/errors.cjs +2 -0
- package/dist/errors.cjs.map +1 -0
- package/dist/errors.d.ts +11 -0
- package/dist/errors.d.ts.map +1 -0
- package/dist/errors.js +9 -0
- package/dist/errors.js.map +1 -0
- package/dist/graph.cjs +2 -0
- package/dist/graph.cjs.map +1 -0
- package/dist/graph.d.ts +21 -0
- package/dist/graph.d.ts.map +1 -0
- package/dist/graph.js +81 -0
- package/dist/graph.js.map +1 -0
- package/dist/index.cjs +1 -0
- package/dist/index.d.ts +9 -0
- package/dist/index.d.ts.map +1 -0
- package/dist/index.js +8 -0
- package/dist/orthogonal.cjs +2 -0
- package/dist/orthogonal.cjs.map +1 -0
- package/dist/orthogonal.d.ts +37 -0
- package/dist/orthogonal.d.ts.map +1 -0
- package/dist/orthogonal.js +122 -0
- package/dist/orthogonal.js.map +1 -0
- package/dist/path.cjs +2 -0
- package/dist/path.cjs.map +1 -0
- package/dist/path.d.ts +19 -0
- package/dist/path.d.ts.map +1 -0
- package/dist/path.js +33 -0
- package/dist/path.js.map +1 -0
- package/dist/ports.cjs +2 -0
- package/dist/ports.cjs.map +1 -0
- package/dist/ports.d.ts +21 -0
- package/dist/ports.d.ts.map +1 -0
- package/dist/ports.js +36 -0
- package/dist/ports.js.map +1 -0
- package/dist/types.d.ts +31 -0
- package/dist/types.d.ts.map +1 -0
- package/dist/wire.cjs +2 -0
- package/dist/wire.cjs.map +1 -0
- package/dist/wire.iife.js +2 -0
- package/dist/wire.iife.js.map +1 -0
- package/dist/wire.js +543 -0
- package/dist/wire.js.map +1 -0
- package/package.json +48 -4
package/dist/wire.js
ADDED
|
@@ -0,0 +1,543 @@
|
|
|
1
|
+
// src/_sides.ts
|
|
2
|
+
var e = {
|
|
3
|
+
bottom: {
|
|
4
|
+
x: 0,
|
|
5
|
+
y: 1
|
|
6
|
+
},
|
|
7
|
+
left: {
|
|
8
|
+
x: -1,
|
|
9
|
+
y: 0
|
|
10
|
+
},
|
|
11
|
+
right: {
|
|
12
|
+
x: 1,
|
|
13
|
+
y: 0
|
|
14
|
+
},
|
|
15
|
+
top: {
|
|
16
|
+
x: 0,
|
|
17
|
+
y: -1
|
|
18
|
+
}
|
|
19
|
+
}, t = {
|
|
20
|
+
Down: 4,
|
|
21
|
+
Left: 1,
|
|
22
|
+
None: 0,
|
|
23
|
+
Right: 2,
|
|
24
|
+
Up: 3
|
|
25
|
+
}, n = {
|
|
26
|
+
[t.Left]: {
|
|
27
|
+
x: -1,
|
|
28
|
+
y: 0
|
|
29
|
+
},
|
|
30
|
+
[t.Right]: {
|
|
31
|
+
x: 1,
|
|
32
|
+
y: 0
|
|
33
|
+
},
|
|
34
|
+
[t.Up]: {
|
|
35
|
+
x: 0,
|
|
36
|
+
y: -1
|
|
37
|
+
},
|
|
38
|
+
[t.Down]: {
|
|
39
|
+
x: 0,
|
|
40
|
+
y: 1
|
|
41
|
+
}
|
|
42
|
+
}, r = {
|
|
43
|
+
bottom: t.Down,
|
|
44
|
+
left: t.Left,
|
|
45
|
+
right: t.Right,
|
|
46
|
+
top: t.Up
|
|
47
|
+
}, i = {
|
|
48
|
+
[t.Down]: t.Up,
|
|
49
|
+
[t.Left]: t.Right,
|
|
50
|
+
[t.Right]: t.Left,
|
|
51
|
+
[t.Up]: t.Down
|
|
52
|
+
}, WireError = class extends Error {
|
|
53
|
+
constructor(e, t) {
|
|
54
|
+
super(e, t), this.name = new.target.name, Object.setPrototypeOf(this, new.target.prototype);
|
|
55
|
+
}
|
|
56
|
+
}, WireGraphError = class extends WireError {}, WireConfigError = class extends WireError {}, a = 40, o = 1.5;
|
|
57
|
+
function bezierRoute(t, n, r = {}) {
|
|
58
|
+
let i = r.handleLength ?? a;
|
|
59
|
+
if (!Number.isFinite(i) || i < 0) throw new WireConfigError(`Bezier handleLength must be a finite non-negative number, received ${String(i)}.`);
|
|
60
|
+
let s = e[t.side], c = e[n.side], l = i;
|
|
61
|
+
if (r.selfLoop && t.side === n.side) {
|
|
62
|
+
let e = Math.hypot(n.x - t.x, n.y - t.y);
|
|
63
|
+
l = Math.max(i, e * o);
|
|
64
|
+
}
|
|
65
|
+
return {
|
|
66
|
+
c1: {
|
|
67
|
+
x: t.x + s.x * l,
|
|
68
|
+
y: t.y + s.y * l
|
|
69
|
+
},
|
|
70
|
+
c2: {
|
|
71
|
+
x: n.x + c.x * l,
|
|
72
|
+
y: n.y + c.y * l
|
|
73
|
+
},
|
|
74
|
+
from: {
|
|
75
|
+
x: t.x,
|
|
76
|
+
y: t.y
|
|
77
|
+
},
|
|
78
|
+
to: {
|
|
79
|
+
x: n.x,
|
|
80
|
+
y: n.y
|
|
81
|
+
}
|
|
82
|
+
};
|
|
83
|
+
}
|
|
84
|
+
// src/edit.ts
|
|
85
|
+
var s = 10, c = 6, l = 4, u = 64;
|
|
86
|
+
function cubicAt(e, t) {
|
|
87
|
+
let n = 1 - t, r = n * n * n, i = 3 * n * n * t, a = 3 * n * t * t, o = t * t * t;
|
|
88
|
+
return {
|
|
89
|
+
x: r * e.from.x + i * e.c1.x + a * e.c2.x + o * e.to.x,
|
|
90
|
+
y: r * e.from.y + i * e.c1.y + a * e.c2.y + o * e.to.y
|
|
91
|
+
};
|
|
92
|
+
}
|
|
93
|
+
function requirePoint(e, t) {
|
|
94
|
+
if (!Number.isFinite(e.x) || !Number.isFinite(e.y)) throw new WireConfigError(`Wire edit ${t} must have finite coordinates, received (${e.x}, ${e.y}).`);
|
|
95
|
+
}
|
|
96
|
+
function requirePositive(e, t) {
|
|
97
|
+
if (!Number.isFinite(e) || e <= 0) throw new WireConfigError(`Wire edit ${t} must be a finite positive number, received ${String(e)}.`);
|
|
98
|
+
}
|
|
99
|
+
function requireUnitT(e) {
|
|
100
|
+
if (!Number.isFinite(e) || e < 0 || e > 1) throw new WireConfigError(`Wire edit t must be a finite number in [0, 1], received ${String(e)}.`);
|
|
101
|
+
}
|
|
102
|
+
function arrowhead(e, t, n = {}) {
|
|
103
|
+
requirePoint(e, "arrowhead tip"), requirePoint(t, "arrowhead direction");
|
|
104
|
+
let r = Math.hypot(t.x, t.y);
|
|
105
|
+
if (r === 0) throw new WireConfigError("Wire edit arrowhead direction must be non-zero.");
|
|
106
|
+
let i = n.length ?? s, a = n.width ?? c;
|
|
107
|
+
requirePositive(i, "arrowhead length"), requirePositive(a, "arrowhead width");
|
|
108
|
+
let o = t.x / r, l = t.y / r, u = -l, d = o, f = e.x - o * i, p = e.y - l * i, m = a / 2;
|
|
109
|
+
return [
|
|
110
|
+
{
|
|
111
|
+
x: e.x,
|
|
112
|
+
y: e.y
|
|
113
|
+
},
|
|
114
|
+
{
|
|
115
|
+
x: f + u * m,
|
|
116
|
+
y: p + d * m
|
|
117
|
+
},
|
|
118
|
+
{
|
|
119
|
+
x: f - u * m,
|
|
120
|
+
y: p - d * m
|
|
121
|
+
}
|
|
122
|
+
];
|
|
123
|
+
}
|
|
124
|
+
function polylineLengths(e) {
|
|
125
|
+
let t = Array(e.length);
|
|
126
|
+
t[0] = 0;
|
|
127
|
+
for (let n = 1; n < e.length; n++) t[n] = t[n - 1] + Math.hypot(e[n].x - e[n - 1].x, e[n].y - e[n - 1].y);
|
|
128
|
+
return t;
|
|
129
|
+
}
|
|
130
|
+
function pointAtPolylineLength(e, t, n) {
|
|
131
|
+
let r = t[t.length - 1];
|
|
132
|
+
if (r === 0) return {
|
|
133
|
+
x: e[0].x,
|
|
134
|
+
y: e[0].y
|
|
135
|
+
};
|
|
136
|
+
let i = Math.min(Math.max(n, 0), r), a = 1, o = t.length - 1;
|
|
137
|
+
for (; a < o;) {
|
|
138
|
+
let e = a + o >> 1;
|
|
139
|
+
t[e] < i ? a = e + 1 : o = e;
|
|
140
|
+
}
|
|
141
|
+
let s = e[a - 1], c = e[a], l = t[a] - t[a - 1];
|
|
142
|
+
if (l === 0) return {
|
|
143
|
+
x: s.x,
|
|
144
|
+
y: s.y
|
|
145
|
+
};
|
|
146
|
+
let u = (i - t[a - 1]) / l;
|
|
147
|
+
return {
|
|
148
|
+
x: s.x + (c.x - s.x) * u,
|
|
149
|
+
y: s.y + (c.y - s.y) * u
|
|
150
|
+
};
|
|
151
|
+
}
|
|
152
|
+
function bezierTable(e) {
|
|
153
|
+
let t = Array(65), n = Array(65);
|
|
154
|
+
for (let n = 0; n <= u; n++) t[n] = cubicAt(e, n / u);
|
|
155
|
+
n[0] = 0;
|
|
156
|
+
for (let e = 1; e <= u; e++) n[e] = n[e - 1] + Math.hypot(t[e].x - t[e - 1].x, t[e].y - t[e - 1].y);
|
|
157
|
+
return {
|
|
158
|
+
cumulative: n,
|
|
159
|
+
samples: t,
|
|
160
|
+
total: n[u]
|
|
161
|
+
};
|
|
162
|
+
}
|
|
163
|
+
function uAtBezierLength(e, t) {
|
|
164
|
+
let n = Math.min(Math.max(t, 0), e.total), r = 1, i = u;
|
|
165
|
+
for (; r < i;) {
|
|
166
|
+
let t = r + i >> 1;
|
|
167
|
+
e.cumulative[t] < n ? r = t + 1 : i = t;
|
|
168
|
+
}
|
|
169
|
+
let a = e.cumulative[r] - e.cumulative[r - 1], o = a === 0 ? 0 : (n - e.cumulative[r - 1]) / a;
|
|
170
|
+
return (r - 1 + o) / u;
|
|
171
|
+
}
|
|
172
|
+
function sampledLengthAt(e, t) {
|
|
173
|
+
let n = Math.min(Math.max(t, 0), 1) * u, r = Math.min(Math.floor(n), 63), i = n - r;
|
|
174
|
+
return e.cumulative[r] + i * (e.cumulative[r + 1] - e.cumulative[r]);
|
|
175
|
+
}
|
|
176
|
+
function requireCurve(e, t) {
|
|
177
|
+
requirePoint(e.from, `${t} from`), requirePoint(e.c1, `${t} c1`), requirePoint(e.c2, `${t} c2`), requirePoint(e.to, `${t} to`);
|
|
178
|
+
}
|
|
179
|
+
function pointOnPolyline(e, t) {
|
|
180
|
+
if (e.length < 2) throw new WireConfigError(`Wire edit pointOnPolyline requires at least 2 points, received ${e.length}.`);
|
|
181
|
+
for (let t = 0; t < e.length; t++) requirePoint(e[t], `pointOnPolyline points[${t}]`);
|
|
182
|
+
requireUnitT(t);
|
|
183
|
+
let n = polylineLengths(e);
|
|
184
|
+
return pointAtPolylineLength(e, n, t * n[n.length - 1]);
|
|
185
|
+
}
|
|
186
|
+
function pointOnBezier(e, t) {
|
|
187
|
+
requireCurve(e, "pointOnBezier"), requireUnitT(t);
|
|
188
|
+
let n = bezierTable(e);
|
|
189
|
+
return n.total === 0 ? {
|
|
190
|
+
x: e.from.x,
|
|
191
|
+
y: e.from.y
|
|
192
|
+
} : cubicAt(e, uAtBezierLength(n, t * n.total));
|
|
193
|
+
}
|
|
194
|
+
function distanceToSegment(e, t, n) {
|
|
195
|
+
let r = n.x - t.x, i = n.y - t.y, a = r * r + i * i;
|
|
196
|
+
if (a === 0) return {
|
|
197
|
+
distance: Math.hypot(e.x - t.x, e.y - t.y),
|
|
198
|
+
ratio: 0
|
|
199
|
+
};
|
|
200
|
+
let o = Math.min(Math.max(((e.x - t.x) * r + (e.y - t.y) * i) / a, 0), 1), s = t.x + r * o, c = t.y + i * o;
|
|
201
|
+
return {
|
|
202
|
+
distance: Math.hypot(e.x - s, e.y - c),
|
|
203
|
+
ratio: o
|
|
204
|
+
};
|
|
205
|
+
}
|
|
206
|
+
function hitPolyline(e, t, n = {}) {
|
|
207
|
+
if (e.length < 2) throw new WireConfigError(`Wire edit hitPolyline requires at least 2 points, received ${e.length}.`);
|
|
208
|
+
for (let t = 0; t < e.length; t++) requirePoint(e[t], `hitPolyline points[${t}]`);
|
|
209
|
+
requirePoint(t, "hitPolyline point");
|
|
210
|
+
let r = n.threshold ?? l;
|
|
211
|
+
requirePositive(r, "hitPolyline threshold");
|
|
212
|
+
let i = polylineLengths(e), a = i[i.length - 1], o = Infinity, s = 0;
|
|
213
|
+
for (let n = 1; n < e.length; n++) {
|
|
214
|
+
let r = distanceToSegment(t, e[n - 1], e[n]);
|
|
215
|
+
r.distance < o && (o = r.distance, s = i[n - 1] + r.ratio * (i[n] - i[n - 1]));
|
|
216
|
+
}
|
|
217
|
+
return o > r ? null : {
|
|
218
|
+
distance: o,
|
|
219
|
+
t: a === 0 ? 0 : s / a
|
|
220
|
+
};
|
|
221
|
+
}
|
|
222
|
+
function hitBezier(e, t, n = {}) {
|
|
223
|
+
requireCurve(e, "hitBezier"), requirePoint(t, "hitBezier point");
|
|
224
|
+
let r = n.threshold ?? l;
|
|
225
|
+
requirePositive(r, "hitBezier threshold");
|
|
226
|
+
let i = bezierTable(e);
|
|
227
|
+
if (i.total === 0) {
|
|
228
|
+
let n = Math.hypot(t.x - e.from.x, t.y - e.from.y);
|
|
229
|
+
return n <= r ? {
|
|
230
|
+
distance: n,
|
|
231
|
+
t: 0
|
|
232
|
+
} : null;
|
|
233
|
+
}
|
|
234
|
+
let a = 0, o = Infinity;
|
|
235
|
+
for (let e = 0; e <= u; e++) {
|
|
236
|
+
let n = Math.hypot(t.x - i.samples[e].x, t.y - i.samples[e].y);
|
|
237
|
+
n < o && (o = n, a = e);
|
|
238
|
+
}
|
|
239
|
+
let s = Math.max(0, (a - 1) / u), c = Math.min(1, (a + 1) / u);
|
|
240
|
+
for (let n = 0; n < 32; n++) {
|
|
241
|
+
let n = s + (c - s) / 3, r = c - (c - s) / 3, i = cubicAt(e, n), a = cubicAt(e, r);
|
|
242
|
+
Math.hypot(t.x - i.x, t.y - i.y) < Math.hypot(t.x - a.x, t.y - a.y) ? c = r : s = n;
|
|
243
|
+
}
|
|
244
|
+
let d = (s + c) / 2, f = cubicAt(e, d), p = Math.hypot(t.x - f.x, t.y - f.y);
|
|
245
|
+
return p > r ? null : {
|
|
246
|
+
distance: p,
|
|
247
|
+
t: sampledLengthAt(i, d) / i.total
|
|
248
|
+
};
|
|
249
|
+
}
|
|
250
|
+
// src/_heap.ts
|
|
251
|
+
var MinHeap = class {
|
|
252
|
+
items = [];
|
|
253
|
+
get size() {
|
|
254
|
+
return this.items.length;
|
|
255
|
+
}
|
|
256
|
+
push(e, t) {
|
|
257
|
+
let n = this.items;
|
|
258
|
+
n.push({
|
|
259
|
+
key: e,
|
|
260
|
+
value: t
|
|
261
|
+
});
|
|
262
|
+
let r = n.length - 1;
|
|
263
|
+
for (; r > 0;) {
|
|
264
|
+
let e = r - 1 >> 1, t = n[e], i = n[r];
|
|
265
|
+
if (t.key <= i.key) break;
|
|
266
|
+
n[e] = i, n[r] = t, r = e;
|
|
267
|
+
}
|
|
268
|
+
}
|
|
269
|
+
pop() {
|
|
270
|
+
let e = this.items, t = e[0], n = e.pop();
|
|
271
|
+
if (e.length > 0) {
|
|
272
|
+
e[0] = n;
|
|
273
|
+
let t = 0;
|
|
274
|
+
for (;;) {
|
|
275
|
+
let n = t * 2 + 1, r = n + 1, i = t;
|
|
276
|
+
if (n < e.length && e[n].key < e[i].key && (i = n), r < e.length && e[r].key < e[i].key && (i = r), i === t) break;
|
|
277
|
+
let a = e[t], o = e[i];
|
|
278
|
+
e[t] = o, e[i] = a, t = i;
|
|
279
|
+
}
|
|
280
|
+
}
|
|
281
|
+
return t.value;
|
|
282
|
+
}
|
|
283
|
+
};
|
|
284
|
+
// src/graph.ts
|
|
285
|
+
function buildNodeIndex(e) {
|
|
286
|
+
let t = /* @__PURE__ */ new Map();
|
|
287
|
+
for (let n of e) {
|
|
288
|
+
if (t.has(n)) throw new WireGraphError(`Duplicate node id "${n}" in the node list.`);
|
|
289
|
+
t.set(n, t.size);
|
|
290
|
+
}
|
|
291
|
+
return t;
|
|
292
|
+
}
|
|
293
|
+
function validateEdgeEndpoints(e, t) {
|
|
294
|
+
for (let n of t) {
|
|
295
|
+
if (!e.has(n.from)) throw new WireGraphError(`Edge from "${n.from}" to "${n.to}" references unknown node id "${n.from}".`);
|
|
296
|
+
if (!e.has(n.to)) throw new WireGraphError(`Edge from "${n.from}" to "${n.to}" references unknown node id "${n.to}".`);
|
|
297
|
+
}
|
|
298
|
+
}
|
|
299
|
+
function topologicalOrder(e, t) {
|
|
300
|
+
let n = buildNodeIndex(e);
|
|
301
|
+
validateEdgeEndpoints(n, t);
|
|
302
|
+
let r = e.length, i = Array.from({ length: r }, () => []), a = Array(r).fill(0);
|
|
303
|
+
for (let e of t) {
|
|
304
|
+
let t = n.get(e.from), r = n.get(e.to);
|
|
305
|
+
i[t].push(r), a[r] = (a[r] ?? 0) + 1;
|
|
306
|
+
}
|
|
307
|
+
let o = new MinHeap();
|
|
308
|
+
for (let e = 0; e < r; e += 1) a[e] === 0 && o.push(e, e);
|
|
309
|
+
let s = [];
|
|
310
|
+
for (; o.size > 0;) {
|
|
311
|
+
let t = o.pop();
|
|
312
|
+
s.push(e[t]);
|
|
313
|
+
for (let e of i[t]) {
|
|
314
|
+
let t = (a[e] ?? 0) - 1;
|
|
315
|
+
a[e] = t, t === 0 && o.push(e, e);
|
|
316
|
+
}
|
|
317
|
+
}
|
|
318
|
+
if (s.length !== r) throw new WireGraphError("Graph contains a cycle; no topological order exists. Use findCyclicGroups() to locate it.");
|
|
319
|
+
return s;
|
|
320
|
+
}
|
|
321
|
+
function findCyclicGroups(e, t) {
|
|
322
|
+
let n = buildNodeIndex(e);
|
|
323
|
+
validateEdgeEndpoints(n, t);
|
|
324
|
+
let r = e.length, i = Array.from({ length: r }, () => []), a = Array(r).fill(!1);
|
|
325
|
+
for (let e of t) {
|
|
326
|
+
let t = n.get(e.from), r = n.get(e.to);
|
|
327
|
+
t === r && (a[t] = !0), i[t].push(r);
|
|
328
|
+
}
|
|
329
|
+
let o = Array(r).fill(-1), s = Array(r).fill(-1), c = Array(r).fill(!1), l = [], u = [], d = 0, strongConnect = (t) => {
|
|
330
|
+
let n = [{
|
|
331
|
+
child: 0,
|
|
332
|
+
node: t
|
|
333
|
+
}], enter = (e) => {
|
|
334
|
+
s[e] = d, o[e] = d, d += 1, l.push(e), c[e] = !0;
|
|
335
|
+
};
|
|
336
|
+
for (enter(t); n.length > 0;) {
|
|
337
|
+
let t = n[n.length - 1], r = i[t.node];
|
|
338
|
+
if (t.child < r.length) {
|
|
339
|
+
let e = r[t.child];
|
|
340
|
+
t.child += 1, s[e] === -1 ? (enter(e), n.push({
|
|
341
|
+
child: 0,
|
|
342
|
+
node: e
|
|
343
|
+
})) : c[e] && (o[t.node] = Math.min(o[t.node], s[e]));
|
|
344
|
+
continue;
|
|
345
|
+
}
|
|
346
|
+
n.pop();
|
|
347
|
+
let d = n[n.length - 1];
|
|
348
|
+
if (d && (o[d.node] = Math.min(o[d.node], o[t.node])), o[t.node] === s[t.node]) {
|
|
349
|
+
let n = [], r = -1;
|
|
350
|
+
do
|
|
351
|
+
r = l.pop(), c[r] = !1, n.push(r);
|
|
352
|
+
while (r !== t.node);
|
|
353
|
+
(n.length > 1 || n.length === 1 && a[n[0]]) && (n.sort((e, t) => e - t), u.push(n.map((t) => e[t])));
|
|
354
|
+
}
|
|
355
|
+
}
|
|
356
|
+
};
|
|
357
|
+
for (let e = 0; e < r; e += 1) s[e] === -1 && strongConnect(e);
|
|
358
|
+
return u.sort((e, t) => n.get(e[0]) - n.get(t[0])), u;
|
|
359
|
+
}
|
|
360
|
+
// src/orthogonal.ts
|
|
361
|
+
var d = 5;
|
|
362
|
+
function padRect(e, t) {
|
|
363
|
+
return {
|
|
364
|
+
x0: e.x - t,
|
|
365
|
+
x1: e.x + e.width + t,
|
|
366
|
+
y0: e.y - t,
|
|
367
|
+
y1: e.y + e.height + t
|
|
368
|
+
};
|
|
369
|
+
}
|
|
370
|
+
function pointBlocked(e, t, n) {
|
|
371
|
+
for (let r of n) if (e > r.x0 && e < r.x1 && t > r.y0 && t < r.y1) return !0;
|
|
372
|
+
return !1;
|
|
373
|
+
}
|
|
374
|
+
function spanBlocked(e, t, n) {
|
|
375
|
+
let r = Math.min(e.x, t.x), i = Math.max(e.x, t.x), a = Math.min(e.y, t.y), o = Math.max(e.y, t.y);
|
|
376
|
+
for (let e of n) if (a === o) {
|
|
377
|
+
if (a > e.y0 && a < e.y1 && r < e.x1 && e.x0 < i) return !0;
|
|
378
|
+
} else if (r === i && r > e.x0 && r < e.x1 && a < e.y1 && e.y0 < o) return !0;
|
|
379
|
+
return !1;
|
|
380
|
+
}
|
|
381
|
+
function ownersOf(e, t) {
|
|
382
|
+
return t.filter((t) => pointBlocked(e.x, e.y, [t]));
|
|
383
|
+
}
|
|
384
|
+
function escapeDistance(e, t, r) {
|
|
385
|
+
let i = n[t], a = 0;
|
|
386
|
+
for (let t of r) {
|
|
387
|
+
let n = i.x > 0 ? t.x1 - e.x : i.x < 0 ? e.x - t.x0 : i.y > 0 ? t.y1 - e.y : e.y - t.y0;
|
|
388
|
+
n > a && (a = n);
|
|
389
|
+
}
|
|
390
|
+
return a;
|
|
391
|
+
}
|
|
392
|
+
function orthogonalRoute(n, a, o = {}) {
|
|
393
|
+
let s = o.padding ?? 8, c = o.bendPenalty ?? 12, l = o.stub ?? 16;
|
|
394
|
+
if (!Number.isFinite(s) || s < 0) throw new WireConfigError(`Orthogonal padding must be a finite non-negative number, received ${String(s)}.`);
|
|
395
|
+
if (!Number.isFinite(c) || c < 0) throw new WireConfigError(`Bend penalty must be a finite non-negative number, received ${String(c)}.`);
|
|
396
|
+
if (!Number.isFinite(l) || l < 0) throw new WireConfigError(`Stub must be a finite non-negative number, received ${String(l)}.`);
|
|
397
|
+
let u = {
|
|
398
|
+
x: n.x,
|
|
399
|
+
y: n.y
|
|
400
|
+
}, f = {
|
|
401
|
+
x: a.x,
|
|
402
|
+
y: a.y
|
|
403
|
+
};
|
|
404
|
+
if (u.x === f.x && u.y === f.y) return [u];
|
|
405
|
+
let p = (o.obstacles ?? []).map((e) => padRect(e, s)), m = ownersOf(u, p), h = ownersOf(f, p), othersFor = (e) => e.length === 0 ? p : p.filter((t) => !e.includes(t)), g = othersFor(m), _ = othersFor(h), v = r[n.side], y = r[a.side];
|
|
406
|
+
if (u.x === f.x || u.y === f.y) {
|
|
407
|
+
let e = u.x === f.x ? f.y > u.y ? t.Down : t.Up : f.x > u.x ? t.Right : t.Left, n = l === 0 && m.length === 0 || v === e, r = l === 0 && h.length === 0 || i[y] === e, a = p.filter((e) => !m.includes(e) && !h.includes(e));
|
|
408
|
+
if (n && r && !spanBlocked(u, f, a)) return [u, f];
|
|
409
|
+
}
|
|
410
|
+
let exitTip = (t, n, r, i) => {
|
|
411
|
+
let a = e[n], o = Math.max(l, escapeDistance(t, r, i));
|
|
412
|
+
return {
|
|
413
|
+
x: t.x + a.x * o,
|
|
414
|
+
y: t.y + a.y * o
|
|
415
|
+
};
|
|
416
|
+
}, b = exitTip(u, n.side, v, m), x = exitTip(f, a.side, y, h);
|
|
417
|
+
if (spanBlocked(u, b, g) || spanBlocked(f, x, _)) return null;
|
|
418
|
+
let S = b, C = x, w = l > 0 || m.length > 0 ? v : t.None, T = l > 0 || h.length > 0 ? y : t.None, E = /* @__PURE__ */ new Set([S.x, C.x]), D = /* @__PURE__ */ new Set([S.y, C.y]);
|
|
419
|
+
for (let e of p) E.add(e.x0), E.add(e.x1), D.add(e.y0), D.add(e.y1);
|
|
420
|
+
let O = [...E].sort((e, t) => e - t), k = [...D].sort((e, t) => e - t), A = O.length, j = k.length, M = A * j, nodeX = (e) => O[e % A], nodeY = (e) => k[Math.floor(e / A)], nodeAt = (e, t) => k.indexOf(t) * A + O.indexOf(e), N = nodeAt(S.x, S.y), P = nodeAt(C.x, C.y);
|
|
421
|
+
if (pointBlocked(nodeX(N), nodeY(N), p) || pointBlocked(nodeX(P), nodeY(P), p)) return null;
|
|
422
|
+
let F = M * d, I = new Float64Array(F).fill(Infinity), L = new Int32Array(F).fill(-1), R = new Uint8Array(F), heuristic = (e) => Math.abs(nodeX(e) - C.x) + Math.abs(nodeY(e) - C.y), stateId = (e, t) => e * d + t, z = new MinHeap(), B = stateId(N, w);
|
|
423
|
+
I[B] = 0, z.push(heuristic(N), B);
|
|
424
|
+
let V = -1;
|
|
425
|
+
for (; z.size > 0 && V === -1;) {
|
|
426
|
+
let e = z.pop();
|
|
427
|
+
if (R[e]) continue;
|
|
428
|
+
R[e] = 1;
|
|
429
|
+
let n = Math.floor(e / d), r = e % d;
|
|
430
|
+
if (n === P && (T === t.None || r !== T)) {
|
|
431
|
+
V = e;
|
|
432
|
+
break;
|
|
433
|
+
}
|
|
434
|
+
let i = nodeX(n), a = nodeY(n), o = [
|
|
435
|
+
[t.Left, n - 1],
|
|
436
|
+
[t.Right, n + 1],
|
|
437
|
+
[t.Up, n - A],
|
|
438
|
+
[t.Down, n + A]
|
|
439
|
+
];
|
|
440
|
+
for (let [s, l] of o) {
|
|
441
|
+
if (s === t.Left && n % A === 0 || s === t.Right && n % A === A - 1 || s === t.Up && n < A || s === t.Down && n >= (j - 1) * A) continue;
|
|
442
|
+
let o = nodeX(l), u = nodeY(l);
|
|
443
|
+
if (pointBlocked(o, u, p) || spanBlocked({
|
|
444
|
+
x: i,
|
|
445
|
+
y: a
|
|
446
|
+
}, {
|
|
447
|
+
x: o,
|
|
448
|
+
y: u
|
|
449
|
+
}, p)) continue;
|
|
450
|
+
let d = Math.abs(o - i) + Math.abs(u - a), f = r !== t.None && r !== s ? c : 0, m = I[e] + d + f, h = stateId(l, s);
|
|
451
|
+
m < I[h] && (I[h] = m, L[h] = e, z.push(m + heuristic(l), h));
|
|
452
|
+
}
|
|
453
|
+
}
|
|
454
|
+
if (V === -1) return null;
|
|
455
|
+
let H = [];
|
|
456
|
+
for (let e = V; e !== -1; e = L[e]) H.push(Math.floor(e / d));
|
|
457
|
+
H.reverse();
|
|
458
|
+
let U = [
|
|
459
|
+
u,
|
|
460
|
+
...H.filter((e, t) => {
|
|
461
|
+
if (t === 0 || t === H.length - 1) return !0;
|
|
462
|
+
let n = H[t - 1], r = H[t + 1];
|
|
463
|
+
return !(nodeX(n) === nodeX(e) && nodeX(e) === nodeX(r) || nodeY(n) === nodeY(e) && nodeY(e) === nodeY(r));
|
|
464
|
+
}).map((e) => ({
|
|
465
|
+
x: nodeX(e),
|
|
466
|
+
y: nodeY(e)
|
|
467
|
+
})),
|
|
468
|
+
f
|
|
469
|
+
];
|
|
470
|
+
for (let e = 1; e < U.length - 1; e += 1) {
|
|
471
|
+
let t = U[e - 1], n = U[e], r = U[e + 1];
|
|
472
|
+
(t.x === n.x && n.x === r.x || t.y === n.y && n.y === r.y) && (U.splice(e, 1), --e);
|
|
473
|
+
}
|
|
474
|
+
return U;
|
|
475
|
+
}
|
|
476
|
+
// src/_format.ts
|
|
477
|
+
function fmt(e) {
|
|
478
|
+
let t = Math.round(e * 1e6) / 1e6;
|
|
479
|
+
return Object.is(t, -0) ? "0" : String(t);
|
|
480
|
+
}
|
|
481
|
+
// src/path.ts
|
|
482
|
+
var f = 1e-9;
|
|
483
|
+
function polylineToSvgPath(e, t = {}) {
|
|
484
|
+
let n = t.cornerRadius ?? 0;
|
|
485
|
+
if (!Number.isFinite(n) || n < 0) throw new WireConfigError(`Path cornerRadius must be a finite non-negative number, received ${String(n)}.`);
|
|
486
|
+
let r = e[0];
|
|
487
|
+
if (!r) return "";
|
|
488
|
+
let i = e[e.length - 1], a = [`M ${fmt(r.x)} ${fmt(r.y)}`];
|
|
489
|
+
if (n === 0) {
|
|
490
|
+
for (let t = 1; t < e.length; t += 1) {
|
|
491
|
+
let n = e[t];
|
|
492
|
+
a.push(`L ${fmt(n.x)} ${fmt(n.y)}`);
|
|
493
|
+
}
|
|
494
|
+
return a.join(" ");
|
|
495
|
+
}
|
|
496
|
+
for (let t = 1; t < e.length - 1; t += 1) {
|
|
497
|
+
let r = e[t - 1], i = e[t], o = e[t + 1], s = Math.hypot(i.x - r.x, i.y - r.y), c = Math.hypot(o.x - i.x, o.y - i.y);
|
|
498
|
+
if (s === 0 || c === 0) continue;
|
|
499
|
+
let l = (i.x - r.x) / s, u = (i.y - r.y) / s, d = (o.x - i.x) / c, p = (o.y - i.y) / c;
|
|
500
|
+
if (Math.abs(l * p - u * d) < f) continue;
|
|
501
|
+
let m = Math.min(n, s / 2, c / 2);
|
|
502
|
+
a.push(`L ${fmt(i.x - l * m)} ${fmt(i.y - u * m)}`), a.push(`Q ${fmt(i.x)} ${fmt(i.y)}, ${fmt(i.x + d * m)} ${fmt(i.y + p * m)}`);
|
|
503
|
+
}
|
|
504
|
+
return a.push(`L ${fmt(i.x)} ${fmt(i.y)}`), a.join(" ");
|
|
505
|
+
}
|
|
506
|
+
function bezierToSvgPath(e) {
|
|
507
|
+
return `M ${fmt(e.from.x)} ${fmt(e.from.y)} C ${fmt(e.c1.x)} ${fmt(e.c1.y)}, ${fmt(e.c2.x)} ${fmt(e.c2.y)}, ${fmt(e.to.x)} ${fmt(e.to.y)}`;
|
|
508
|
+
}
|
|
509
|
+
// src/ports.ts
|
|
510
|
+
function portAnchor(e, t, n = .5) {
|
|
511
|
+
if (!Number.isFinite(n) || n < 0 || n > 1) throw new WireConfigError(`Port offset must be a finite number between 0 and 1, received ${String(n)}.`);
|
|
512
|
+
switch (t) {
|
|
513
|
+
case "bottom": return {
|
|
514
|
+
side: t,
|
|
515
|
+
x: e.x + e.width * n,
|
|
516
|
+
y: e.y + e.height
|
|
517
|
+
};
|
|
518
|
+
case "left": return {
|
|
519
|
+
side: t,
|
|
520
|
+
x: e.x,
|
|
521
|
+
y: e.y + e.height * n
|
|
522
|
+
};
|
|
523
|
+
case "right": return {
|
|
524
|
+
side: t,
|
|
525
|
+
x: e.x + e.width,
|
|
526
|
+
y: e.y + e.height * n
|
|
527
|
+
};
|
|
528
|
+
case "top": return {
|
|
529
|
+
side: t,
|
|
530
|
+
x: e.x + e.width * n,
|
|
531
|
+
y: e.y
|
|
532
|
+
};
|
|
533
|
+
}
|
|
534
|
+
}
|
|
535
|
+
function floatingSide(e, t) {
|
|
536
|
+
if (!Number.isFinite(e.x) || !Number.isFinite(e.y) || !Number.isFinite(e.width) || !Number.isFinite(e.height)) throw new WireConfigError(`Floating rect must have finite coordinates, received (${e.x}, ${e.y}, ${e.width}, ${e.height}).`);
|
|
537
|
+
if (!Number.isFinite(t.x) || !Number.isFinite(t.y)) throw new WireConfigError(`Floating target must have finite coordinates, received (${t.x}, ${t.y}).`);
|
|
538
|
+
let n = t.x - (e.x + e.width / 2), r = t.y - (e.y + e.height / 2);
|
|
539
|
+
return Math.abs(n) >= Math.abs(r) ? n >= 0 ? "right" : "left" : r > 0 ? "bottom" : "top";
|
|
540
|
+
}
|
|
541
|
+
export { WireConfigError, WireError, WireGraphError, arrowhead, bezierRoute, bezierToSvgPath, findCyclicGroups, floatingSide, hitBezier, hitPolyline, orthogonalRoute, pointOnBezier, pointOnPolyline, polylineToSvgPath, portAnchor, topologicalOrder };
|
|
542
|
+
|
|
543
|
+
//# sourceMappingURL=wire.js.map
|