vizmatic 0.3.2 → 0.4.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/PROMPT.md +9 -3
- package/README.md +479 -3
- package/dist/chunk-FEIPTPBZ.js +1165 -0
- package/dist/chunk-TH3F4SDB.js +79 -0
- package/dist/cli.js +12 -8
- package/dist/index.cjs +2727 -123
- package/dist/index.d.cts +556 -1
- package/dist/index.d.ts +556 -1
- package/dist/index.js +2021 -557
- package/dist/scene-cli.d.ts +1 -0
- package/dist/scene-cli.js +4 -0
- package/dist/scene-runtime.cjs +930 -0
- package/dist/scene-runtime.d.cts +80 -0
- package/dist/scene-runtime.d.ts +80 -0
- package/dist/scene-runtime.js +20 -0
- package/examples/pressure-mechanism.scene.json +14 -0
- package/examples/videos/README.md +28 -0
- package/examples/videos/request-lifecycle.tsx +99 -0
- package/examples/videos/signal-to-story.tsx +126 -0
- package/package.json +18 -7
package/dist/index.js
CHANGED
|
@@ -1,445 +1,33 @@
|
|
|
1
|
-
|
|
2
|
-
|
|
3
|
-
|
|
4
|
-
|
|
5
|
-
|
|
6
|
-
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
|
|
10
|
-
|
|
11
|
-
|
|
12
|
-
|
|
13
|
-
|
|
14
|
-
|
|
15
|
-
|
|
16
|
-
|
|
17
|
-
|
|
18
|
-
|
|
19
|
-
|
|
20
|
-
|
|
21
|
-
|
|
22
|
-
|
|
23
|
-
|
|
24
|
-
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
|
|
28
|
-
|
|
29
|
-
|
|
30
|
-
|
|
31
|
-
warningLight: "#fbbf24",
|
|
32
|
-
warningDark: "#b45309",
|
|
33
|
-
critical: "#dc2626",
|
|
34
|
-
// Red — errors/bottlenecks
|
|
35
|
-
criticalLight: "#f87171",
|
|
36
|
-
criticalDark: "#b91c1c",
|
|
37
|
-
info: "#06b6d4",
|
|
38
|
-
// Cyan — informational
|
|
39
|
-
infoLight: "#22d3ee",
|
|
40
|
-
infoDark: "#0891b2",
|
|
41
|
-
accent: "#f472b6",
|
|
42
|
-
// Pink — accents
|
|
43
|
-
accentLight: "#f9a8d4",
|
|
44
|
-
neutral: "#334155",
|
|
45
|
-
// Slate — infrastructure/background
|
|
46
|
-
neutralLight: "#475569",
|
|
47
|
-
neutralDark: "#1e293b",
|
|
48
|
-
// Text
|
|
49
|
-
textPrimary: "#f1f5f9",
|
|
50
|
-
textSecondary: "#94a3b8",
|
|
51
|
-
textMuted: "#8493a8",
|
|
52
|
-
textOnColor: "#ffffff",
|
|
53
|
-
// Borders
|
|
54
|
-
border: "#334155",
|
|
55
|
-
borderSubtle: "#1e293b",
|
|
56
|
-
borderLight: "#475569",
|
|
57
|
-
shadow: "rgba(0, 0, 0, 0.24)"
|
|
58
|
-
};
|
|
59
|
-
var lightColors = {
|
|
60
|
-
// Canvas backgrounds
|
|
61
|
-
bg: "#f5f7fa",
|
|
62
|
-
bgCard: "#f8fafc",
|
|
63
|
-
bgCardAlt: "#f1f5f9",
|
|
64
|
-
bgHover: "#e2e8f0",
|
|
65
|
-
bgSubtle: "#f5f7fa",
|
|
66
|
-
// Brand / semantic colors (same hues, adjusted for light bg)
|
|
67
|
-
primary: "#7c3aed",
|
|
68
|
-
primaryLight: "#8b5cf6",
|
|
69
|
-
primaryDark: "#6d28d9",
|
|
70
|
-
secondary: "#2563eb",
|
|
71
|
-
secondaryLight: "#3b82f6",
|
|
72
|
-
secondaryDark: "#1d4ed8",
|
|
73
|
-
positive: "#059669",
|
|
74
|
-
positiveLight: "#10b981",
|
|
75
|
-
positiveDark: "#047857",
|
|
76
|
-
warning: "#d97706",
|
|
77
|
-
warningLight: "#f59e0b",
|
|
78
|
-
warningDark: "#b45309",
|
|
79
|
-
critical: "#dc2626",
|
|
80
|
-
criticalLight: "#ef4444",
|
|
81
|
-
criticalDark: "#b91c1c",
|
|
82
|
-
info: "#0891b2",
|
|
83
|
-
infoLight: "#06b6d4",
|
|
84
|
-
infoDark: "#0e7490",
|
|
85
|
-
accent: "#ec4899",
|
|
86
|
-
accentLight: "#f472b6",
|
|
87
|
-
neutral: "#cbd5e1",
|
|
88
|
-
neutralLight: "#94a3b8",
|
|
89
|
-
neutralDark: "#e2e8f0",
|
|
90
|
-
// Text
|
|
91
|
-
textPrimary: "#0f172a",
|
|
92
|
-
textSecondary: "#475569",
|
|
93
|
-
textMuted: "#5b677a",
|
|
94
|
-
textOnColor: "#ffffff",
|
|
95
|
-
// Borders
|
|
96
|
-
border: "#e2e8f0",
|
|
97
|
-
borderSubtle: "#e2e8f0",
|
|
98
|
-
borderLight: "#cbd5e1",
|
|
99
|
-
shadow: "rgba(15, 23, 42, 0.12)"
|
|
100
|
-
};
|
|
101
|
-
var defaultStyleTokens = {
|
|
102
|
-
preset: "default",
|
|
103
|
-
fontSans: "Inter",
|
|
104
|
-
fontMono: "JetBrains Mono"
|
|
105
|
-
};
|
|
106
|
-
var engineeringColors = {
|
|
107
|
-
...lightColors,
|
|
108
|
-
bg: "#f4f4f5",
|
|
109
|
-
bgCard: "#ffffff",
|
|
110
|
-
bgCardAlt: "#ececee",
|
|
111
|
-
bgHover: "#e4e4e7",
|
|
112
|
-
bgSubtle: "#eeeeef",
|
|
113
|
-
primary: "#632ca6",
|
|
114
|
-
primaryLight: "#6d28d9",
|
|
115
|
-
primaryDark: "#4c1d95",
|
|
116
|
-
secondary: "#124fc7",
|
|
117
|
-
secondaryLight: "#1556d1",
|
|
118
|
-
secondaryDark: "#123d96",
|
|
119
|
-
positive: "#087a55",
|
|
120
|
-
positiveLight: "#0a8060",
|
|
121
|
-
positiveDark: "#05543c",
|
|
122
|
-
warning: "#c96c00",
|
|
123
|
-
warningLight: "#d97800",
|
|
124
|
-
warningDark: "#9a4f00",
|
|
125
|
-
critical: "#b83232",
|
|
126
|
-
criticalLight: "#c43d3d",
|
|
127
|
-
criticalDark: "#8f2626",
|
|
128
|
-
info: "#0b7185",
|
|
129
|
-
infoLight: "#0d7d92",
|
|
130
|
-
infoDark: "#075565",
|
|
131
|
-
accent: "#a83c76",
|
|
132
|
-
accentLight: "#b74583",
|
|
133
|
-
neutral: "#52525b",
|
|
134
|
-
neutralLight: "#71717a",
|
|
135
|
-
neutralDark: "#3f3f46",
|
|
136
|
-
textPrimary: "#101012",
|
|
137
|
-
textSecondary: "#3f3f46",
|
|
138
|
-
textMuted: "#68686f",
|
|
139
|
-
textOnColor: "#ffffff",
|
|
140
|
-
border: "#3f3f46",
|
|
141
|
-
borderSubtle: "#d4d4d8",
|
|
142
|
-
borderLight: "#a1a1aa",
|
|
143
|
-
shadow: "rgba(0, 0, 0, 0)"
|
|
144
|
-
};
|
|
145
|
-
function getThemeColors(mode, preset = "default") {
|
|
146
|
-
if (preset === "engineering") {
|
|
147
|
-
return {
|
|
148
|
-
...engineeringColors,
|
|
149
|
-
preset,
|
|
150
|
-
fontSans: "Inter",
|
|
151
|
-
fontMono: "JetBrains Mono"
|
|
152
|
-
};
|
|
153
|
-
}
|
|
154
|
-
return {
|
|
155
|
-
...mode === "light" ? lightColors : darkColors,
|
|
156
|
-
...defaultStyleTokens
|
|
157
|
-
};
|
|
158
|
-
}
|
|
159
|
-
var colors = {
|
|
160
|
-
...darkColors,
|
|
161
|
-
...defaultStyleTokens
|
|
162
|
-
};
|
|
163
|
-
var gradients = {
|
|
164
|
-
purple: "linear-gradient(135deg, #7c3aed, #a855f7)",
|
|
165
|
-
blue: "linear-gradient(135deg, #2563eb, #60a5fa)",
|
|
166
|
-
green: "linear-gradient(135deg, #059669, #34d399)",
|
|
167
|
-
warm: "linear-gradient(135deg, #f59e0b, #ef4444)",
|
|
168
|
-
cyan: "linear-gradient(135deg, #06b6d4, #22d3ee)",
|
|
169
|
-
pink: "linear-gradient(135deg, #ec4899, #f472b6)",
|
|
170
|
-
sunset: "linear-gradient(135deg, #f97316, #db2777)",
|
|
171
|
-
ocean: "linear-gradient(135deg, #0284c7, #7c3aed)",
|
|
172
|
-
dark: "linear-gradient(180deg, #0f1117, #1a1b26)"
|
|
173
|
-
};
|
|
174
|
-
var toneGradients = {
|
|
175
|
-
blue: gradients.blue,
|
|
176
|
-
purple: gradients.purple,
|
|
177
|
-
green: gradients.green,
|
|
178
|
-
warm: gradients.warm,
|
|
179
|
-
cyan: gradients.cyan,
|
|
180
|
-
pink: gradients.pink,
|
|
181
|
-
red: gradients.warm,
|
|
182
|
-
critical: gradients.warm,
|
|
183
|
-
neutral: gradients.dark,
|
|
184
|
-
sunset: gradients.sunset,
|
|
185
|
-
ocean: gradients.ocean,
|
|
186
|
-
dark: gradients.dark
|
|
187
|
-
};
|
|
188
|
-
function getToneGradient(tone) {
|
|
189
|
-
return toneGradients[tone];
|
|
190
|
-
}
|
|
191
|
-
function getToneColor(tone, c) {
|
|
192
|
-
return {
|
|
193
|
-
blue: c.secondaryLight,
|
|
194
|
-
purple: c.primaryLight,
|
|
195
|
-
green: c.positiveLight,
|
|
196
|
-
warm: c.warningLight,
|
|
197
|
-
cyan: c.infoLight,
|
|
198
|
-
pink: c.accentLight,
|
|
199
|
-
red: c.criticalLight,
|
|
200
|
-
critical: c.criticalLight,
|
|
201
|
-
neutral: c.textSecondary,
|
|
202
|
-
sunset: c.warningLight,
|
|
203
|
-
ocean: c.infoLight,
|
|
204
|
-
dark: c.textSecondary
|
|
205
|
-
}[tone];
|
|
206
|
-
}
|
|
207
|
-
function getReadableToneColor(tone, c, background = c.bgCard, backdrop = c.bgCard) {
|
|
208
|
-
const semanticColor = {
|
|
209
|
-
blue: "secondary",
|
|
210
|
-
purple: "primary",
|
|
211
|
-
green: "positive",
|
|
212
|
-
warm: "warning",
|
|
213
|
-
cyan: "info",
|
|
214
|
-
pink: "accent",
|
|
215
|
-
red: "critical",
|
|
216
|
-
critical: "critical",
|
|
217
|
-
neutral: "neutral",
|
|
218
|
-
sunset: "warning",
|
|
219
|
-
ocean: "info",
|
|
220
|
-
dark: "neutral"
|
|
221
|
-
};
|
|
222
|
-
const color = getReadableColor(semanticColor[tone], c);
|
|
223
|
-
return colorContrast(color, background, backdrop) >= 4.5 ? color : getReadableTextColor(background, c, backdrop);
|
|
224
|
-
}
|
|
225
|
-
function getToneFill(tone, c) {
|
|
226
|
-
if (c.preset !== "engineering") return withColorAlpha(getToneColor(tone, c), 22 / 255);
|
|
227
|
-
return {
|
|
228
|
-
blue: "#cddcfa",
|
|
229
|
-
purple: "#dfcff8",
|
|
230
|
-
green: "#d5ede4",
|
|
231
|
-
warm: "#fde7ce",
|
|
232
|
-
cyan: "#d7edf1",
|
|
233
|
-
pink: "#f3d9e7",
|
|
234
|
-
red: "#f4d7d7",
|
|
235
|
-
critical: "#f4d7d7",
|
|
236
|
-
neutral: "#e4e4e7",
|
|
237
|
-
sunset: "#fde1d6",
|
|
238
|
-
ocean: "#d8e2f6",
|
|
239
|
-
dark: "#dedee2"
|
|
240
|
-
}[tone];
|
|
241
|
-
}
|
|
242
|
-
var typography = {
|
|
243
|
-
title: { fontSize: 28, fontWeight: 700, fontFamily: "Inter" },
|
|
244
|
-
subtitle: { fontSize: 20, fontWeight: 600, fontFamily: "Inter" },
|
|
245
|
-
label: { fontSize: 16, fontWeight: 600, fontFamily: "Inter" },
|
|
246
|
-
body: { fontSize: 14, fontWeight: 400, fontFamily: "Inter" },
|
|
247
|
-
small: { fontSize: 12, fontWeight: 500, fontFamily: "Inter" },
|
|
248
|
-
tiny: { fontSize: 11, fontWeight: 500, fontFamily: "Inter" },
|
|
249
|
-
code: { fontSize: 13, fontWeight: 400, fontFamily: "JetBrains Mono" },
|
|
250
|
-
annotation: { fontSize: 12, fontWeight: 500, fontFamily: "Inter", fontStyle: "italic" }
|
|
251
|
-
};
|
|
252
|
-
var canvas = {
|
|
253
|
-
standard: { width: 800, height: 500 },
|
|
254
|
-
wide: { width: 1e3, height: 400 },
|
|
255
|
-
square: { width: 600, height: 600 },
|
|
256
|
-
tall: { width: 600, height: 800 }
|
|
257
|
-
};
|
|
258
|
-
function getStyles(c) {
|
|
259
|
-
return {
|
|
260
|
-
canvas: {
|
|
261
|
-
width: "100%",
|
|
262
|
-
height: "100%",
|
|
263
|
-
display: "flex",
|
|
264
|
-
flexDirection: "column",
|
|
265
|
-
backgroundColor: c.bg,
|
|
266
|
-
fontFamily: c.fontSans,
|
|
267
|
-
padding: 40
|
|
268
|
-
},
|
|
269
|
-
card: {
|
|
270
|
-
display: "flex",
|
|
271
|
-
flexDirection: "column",
|
|
272
|
-
backgroundColor: c.bgCard,
|
|
273
|
-
borderRadius: 8,
|
|
274
|
-
border: `1px solid ${c.borderSubtle}`,
|
|
275
|
-
padding: 20
|
|
276
|
-
},
|
|
277
|
-
pill: {
|
|
278
|
-
display: "flex",
|
|
279
|
-
alignItems: "center",
|
|
280
|
-
justifyContent: "center",
|
|
281
|
-
borderRadius: 999,
|
|
282
|
-
padding: "6px 16px",
|
|
283
|
-
fontSize: 13,
|
|
284
|
-
fontWeight: 600,
|
|
285
|
-
fontFamily: "Inter"
|
|
286
|
-
}
|
|
287
|
-
};
|
|
288
|
-
}
|
|
289
|
-
var styles = {
|
|
290
|
-
canvas: {
|
|
291
|
-
width: "100%",
|
|
292
|
-
height: "100%",
|
|
293
|
-
display: "flex",
|
|
294
|
-
flexDirection: "column",
|
|
295
|
-
backgroundColor: colors.bg,
|
|
296
|
-
fontFamily: "Inter",
|
|
297
|
-
padding: 40
|
|
298
|
-
},
|
|
299
|
-
card: {
|
|
300
|
-
display: "flex",
|
|
301
|
-
flexDirection: "column",
|
|
302
|
-
backgroundColor: colors.bgCard,
|
|
303
|
-
borderRadius: 8,
|
|
304
|
-
border: `1px solid ${colors.borderSubtle}`,
|
|
305
|
-
padding: 20
|
|
306
|
-
},
|
|
307
|
-
pill: {
|
|
308
|
-
display: "flex",
|
|
309
|
-
alignItems: "center",
|
|
310
|
-
justifyContent: "center",
|
|
311
|
-
borderRadius: 999,
|
|
312
|
-
padding: "6px 16px",
|
|
313
|
-
fontSize: 13,
|
|
314
|
-
fontWeight: 600,
|
|
315
|
-
fontFamily: "Inter"
|
|
316
|
-
}
|
|
317
|
-
};
|
|
318
|
-
function getColor(name, c) {
|
|
319
|
-
if (c) return c[name];
|
|
320
|
-
return colors[name];
|
|
321
|
-
}
|
|
322
|
-
function getReadableColor(name, c) {
|
|
323
|
-
const variants = {
|
|
324
|
-
primary: [c.primaryLight, c.primary, c.primaryDark],
|
|
325
|
-
secondary: [c.secondaryLight, c.secondary, c.secondaryDark],
|
|
326
|
-
positive: [c.positiveLight, c.positive, c.positiveDark],
|
|
327
|
-
warning: [c.warningLight, c.warning, c.warningDark],
|
|
328
|
-
critical: [c.criticalLight, c.critical, c.criticalDark],
|
|
329
|
-
info: [c.infoLight, c.info, c.infoDark],
|
|
330
|
-
accent: [c.accentLight, c.accent, "#be185d"],
|
|
331
|
-
neutral: [c.textSecondary, c.neutralLight, c.neutral, c.neutralDark]
|
|
332
|
-
};
|
|
333
|
-
return variants[name].reduce((best, candidate) => colorContrast(candidate, c.bgCard) > colorContrast(best, c.bgCard) ? candidate : best);
|
|
334
|
-
}
|
|
335
|
-
function parseColor(color) {
|
|
336
|
-
const parsed = parseCssColor(color);
|
|
337
|
-
if (!parsed || parsed.values.length < 3) return void 0;
|
|
338
|
-
if (parsed.type !== "hsl") {
|
|
339
|
-
return {
|
|
340
|
-
channels: [parsed.values[0] ?? 0, parsed.values[1] ?? 0, parsed.values[2] ?? 0],
|
|
341
|
-
alpha: parsed.alpha
|
|
342
|
-
};
|
|
343
|
-
}
|
|
344
|
-
const hue = ((parsed.values[0] ?? 0) % 360 + 360) % 360;
|
|
345
|
-
const saturation = (parsed.values[1] ?? 0) / 100;
|
|
346
|
-
const lightness = (parsed.values[2] ?? 0) / 100;
|
|
347
|
-
const chroma = (1 - Math.abs(2 * lightness - 1)) * saturation;
|
|
348
|
-
const segment = hue / 60;
|
|
349
|
-
const intermediate = chroma * (1 - Math.abs(segment % 2 - 1));
|
|
350
|
-
let channels;
|
|
351
|
-
if (segment < 1) channels = [chroma, intermediate, 0];
|
|
352
|
-
else if (segment < 2) channels = [intermediate, chroma, 0];
|
|
353
|
-
else if (segment < 3) channels = [0, chroma, intermediate];
|
|
354
|
-
else if (segment < 4) channels = [0, intermediate, chroma];
|
|
355
|
-
else if (segment < 5) channels = [intermediate, 0, chroma];
|
|
356
|
-
else channels = [chroma, 0, intermediate];
|
|
357
|
-
const offset = lightness - chroma / 2;
|
|
358
|
-
return {
|
|
359
|
-
channels: channels.map((channel) => Math.round((channel + offset) * 255)),
|
|
360
|
-
alpha: parsed.alpha
|
|
361
|
-
};
|
|
362
|
-
}
|
|
363
|
-
function withColorAlpha(color, opacity) {
|
|
364
|
-
if (typeof color !== "string" || !Number.isFinite(opacity)) return "transparent";
|
|
365
|
-
const parsed = parseColor(color);
|
|
366
|
-
if (!parsed) return "transparent";
|
|
367
|
-
const alpha = Math.min(1, Math.max(0, parsed.alpha * Math.min(1, Math.max(0, opacity))));
|
|
368
|
-
const hex = color.trim();
|
|
369
|
-
if (/^#[\da-f]{6}$/i.test(hex)) {
|
|
370
|
-
return `${hex}${Math.round(alpha * 255).toString(16).padStart(2, "0")}`;
|
|
371
|
-
}
|
|
372
|
-
return `rgba(${parsed.channels.join(", ")}, ${Number(alpha.toFixed(6))})`;
|
|
373
|
-
}
|
|
374
|
-
function colorLuminance(color, backdrop) {
|
|
375
|
-
const parsed = parseColor(color);
|
|
376
|
-
if (!parsed) return void 0;
|
|
377
|
-
let channels = parsed.channels;
|
|
378
|
-
if (parsed.alpha < 1) {
|
|
379
|
-
const backdropColor = backdrop ? parseColor(backdrop) : void 0;
|
|
380
|
-
if (!backdropColor) return void 0;
|
|
381
|
-
channels = channels.map((channel, index) => Math.round(
|
|
382
|
-
channel * parsed.alpha + backdropColor.channels[index] * (1 - parsed.alpha)
|
|
383
|
-
));
|
|
384
|
-
}
|
|
385
|
-
const [r, g, b] = channels.map((channel) => {
|
|
386
|
-
const normalized = channel / 255;
|
|
387
|
-
return normalized <= 0.04045 ? normalized / 12.92 : ((normalized + 0.055) / 1.055) ** 2.4;
|
|
388
|
-
});
|
|
389
|
-
return 0.2126 * r + 0.7152 * g + 0.0722 * b;
|
|
390
|
-
}
|
|
391
|
-
function colorContrast(left, right, rightBackdrop) {
|
|
392
|
-
const leftLuminance = colorLuminance(left);
|
|
393
|
-
const rightLuminance = colorLuminance(right, rightBackdrop);
|
|
394
|
-
if (leftLuminance == null || rightLuminance == null) return 0;
|
|
395
|
-
return (Math.max(leftLuminance, rightLuminance) + 0.05) / (Math.min(leftLuminance, rightLuminance) + 0.05);
|
|
396
|
-
}
|
|
397
|
-
function getReadableTextColor(background, c, backdrop = c.bgCard) {
|
|
398
|
-
if (colorLuminance(background, backdrop) == null) return c.textPrimary;
|
|
399
|
-
const candidates = [c.textPrimary, c.textOnColor, c.bg, "#000000"];
|
|
400
|
-
const readable = candidates.find((candidate) => colorContrast(candidate, background, backdrop) >= 4.5);
|
|
401
|
-
if (readable) return readable;
|
|
402
|
-
return candidates.reduce((best, candidate) => colorContrast(candidate, background, backdrop) > colorContrast(best, background, backdrop) ? candidate : best);
|
|
403
|
-
}
|
|
404
|
-
function getGradient(name) {
|
|
405
|
-
const map = {
|
|
406
|
-
primary: gradients.purple,
|
|
407
|
-
secondary: gradients.blue,
|
|
408
|
-
positive: gradients.green,
|
|
409
|
-
warning: gradients.warm,
|
|
410
|
-
critical: gradients.warm,
|
|
411
|
-
info: gradients.cyan,
|
|
412
|
-
accent: gradients.pink,
|
|
413
|
-
neutral: gradients.dark
|
|
414
|
-
};
|
|
415
|
-
return map[name];
|
|
416
|
-
}
|
|
417
|
-
function heatColor(value) {
|
|
418
|
-
const v = Math.max(0, Math.min(1, value));
|
|
419
|
-
if (v < 0.25) {
|
|
420
|
-
const t = v / 0.25;
|
|
421
|
-
return lerpColor("#1e293b", "#0891b2", t);
|
|
422
|
-
} else if (v < 0.5) {
|
|
423
|
-
const t = (v - 0.25) / 0.25;
|
|
424
|
-
return lerpColor("#0891b2", "#059669", t);
|
|
425
|
-
} else if (v < 0.75) {
|
|
426
|
-
const t = (v - 0.5) / 0.25;
|
|
427
|
-
return lerpColor("#059669", "#d97706", t);
|
|
428
|
-
} else {
|
|
429
|
-
const t = (v - 0.75) / 0.25;
|
|
430
|
-
return lerpColor("#d97706", "#dc2626", t);
|
|
431
|
-
}
|
|
432
|
-
}
|
|
433
|
-
function lerpColor(a, b, t) {
|
|
434
|
-
const ah = parseInt(a.slice(1), 16);
|
|
435
|
-
const bh = parseInt(b.slice(1), 16);
|
|
436
|
-
const ar = ah >> 16 & 255, ag = ah >> 8 & 255, ab = ah & 255;
|
|
437
|
-
const br = bh >> 16 & 255, bg = bh >> 8 & 255, bb = bh & 255;
|
|
438
|
-
const rr = Math.round(ar + (br - ar) * t);
|
|
439
|
-
const rg = Math.round(ag + (bg - ag) * t);
|
|
440
|
-
const rb = Math.round(ab + (bb - ab) * t);
|
|
441
|
-
return `#${(rr << 16 | rg << 8 | rb).toString(16).padStart(6, "0")}`;
|
|
442
|
-
}
|
|
1
|
+
import {
|
|
2
|
+
SCENE_COMPONENT_NAMES,
|
|
3
|
+
SCENE_DOM_TAGS,
|
|
4
|
+
SCENE_LIMITS,
|
|
5
|
+
SCENE_RUNTIME_VERSION,
|
|
6
|
+
__export,
|
|
7
|
+
canvas,
|
|
8
|
+
colors,
|
|
9
|
+
evaluateSceneSource,
|
|
10
|
+
getColor,
|
|
11
|
+
getGradient,
|
|
12
|
+
getReadableColor,
|
|
13
|
+
getReadableTextColor,
|
|
14
|
+
getReadableToneColor,
|
|
15
|
+
getStyles,
|
|
16
|
+
getThemeColors,
|
|
17
|
+
getToneColor,
|
|
18
|
+
getToneFill,
|
|
19
|
+
getToneGradient,
|
|
20
|
+
gradients,
|
|
21
|
+
heatColor,
|
|
22
|
+
normalizeSceneTime,
|
|
23
|
+
prepareScene,
|
|
24
|
+
sceneSha256,
|
|
25
|
+
styles,
|
|
26
|
+
toneGradients,
|
|
27
|
+
typography,
|
|
28
|
+
validateResolvedSceneResources,
|
|
29
|
+
withColorAlpha
|
|
30
|
+
} from "./chunk-FEIPTPBZ.js";
|
|
443
31
|
|
|
444
32
|
// src/primitives.ts
|
|
445
33
|
var primitives_exports = {};
|
|
@@ -3534,9 +3122,9 @@ function preferredSide(from, to) {
|
|
|
3534
3122
|
return to.cy >= from.cy ? "bottom" : "top";
|
|
3535
3123
|
}
|
|
3536
3124
|
function routingAnchor(node, side, offset = 0.5) {
|
|
3537
|
-
const
|
|
3538
|
-
if (side === "left" || side === "right") return { x:
|
|
3539
|
-
return { x:
|
|
3125
|
+
const bounds2 = box(node);
|
|
3126
|
+
if (side === "left" || side === "right") return { x: bounds2[side], y: bounds2.top + node.height * offset };
|
|
3127
|
+
return { x: bounds2.left + node.width * offset, y: bounds2[side] };
|
|
3540
3128
|
}
|
|
3541
3129
|
function outward(point, side, distance) {
|
|
3542
3130
|
return {
|
|
@@ -3750,7 +3338,7 @@ function routeOrthogonalGraph(nodes, edges, width, height, clearance = 12, gap =
|
|
|
3750
3338
|
}
|
|
3751
3339
|
const points = simplify([start, ...result.points, end]);
|
|
3752
3340
|
if (points.length < 2) continue;
|
|
3753
|
-
const repeated = (previous.get(key) ?? []).some((route) => route.length === points.length && (route.every((point,
|
|
3341
|
+
const repeated = (previous.get(key) ?? []).some((route) => route.length === points.length && (route.every((point, position2) => point.x === points[position2].x && point.y === points[position2].y) || route.every((point, position2) => point.x === points[points.length - 1 - position2].x && point.y === points[points.length - 1 - position2].y)));
|
|
3754
3342
|
if (repeated) {
|
|
3755
3343
|
failure = "parallel connectors have no separate lane at the requested clearance";
|
|
3756
3344
|
continue;
|
|
@@ -3766,17 +3354,17 @@ function routeOrthogonalGraph(nodes, edges, width, height, clearance = 12, gap =
|
|
|
3766
3354
|
}
|
|
3767
3355
|
function routingLabelPosition(points) {
|
|
3768
3356
|
let longest = 0;
|
|
3769
|
-
let
|
|
3357
|
+
let position2 = points[0];
|
|
3770
3358
|
for (let i = 1; i < points.length; i++) {
|
|
3771
3359
|
const a = points[i - 1];
|
|
3772
3360
|
const b = points[i];
|
|
3773
3361
|
const length = Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
|
|
3774
3362
|
if (length > longest) {
|
|
3775
3363
|
longest = length;
|
|
3776
|
-
|
|
3364
|
+
position2 = { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 };
|
|
3777
3365
|
}
|
|
3778
3366
|
}
|
|
3779
|
-
return
|
|
3367
|
+
return position2;
|
|
3780
3368
|
}
|
|
3781
3369
|
|
|
3782
3370
|
// src/primitives/diagrams.ts
|
|
@@ -4067,13 +3655,13 @@ function connectorLabelCollisions(edges, nodes, groups = []) {
|
|
|
4067
3655
|
if (rectanglesOverlap(labels[index].bounds, labels[otherIndex].bounds, 4)) collisions += 1;
|
|
4068
3656
|
}
|
|
4069
3657
|
for (const node of nodes.values()) {
|
|
4070
|
-
const
|
|
3658
|
+
const bounds2 = {
|
|
4071
3659
|
left: node.cx - node.width / 2,
|
|
4072
3660
|
right: node.cx + node.width / 2,
|
|
4073
3661
|
top: node.cy - node.height / 2,
|
|
4074
3662
|
bottom: node.cy + node.height / 2
|
|
4075
3663
|
};
|
|
4076
|
-
if (rectanglesOverlap(labels[index].bounds,
|
|
3664
|
+
if (rectanglesOverlap(labels[index].bounds, bounds2)) collisions += 1;
|
|
4077
3665
|
}
|
|
4078
3666
|
for (const group of groups) {
|
|
4079
3667
|
const headerBounds = {
|
|
@@ -4334,24 +3922,24 @@ function GraphDiagram({
|
|
|
4334
3922
|
const offsetX = (resolvedWidth - (graphSize.width ?? resolvedWidth)) / 2;
|
|
4335
3923
|
const offsetY = (resolvedHeight - (graphSize.height ?? resolvedHeight)) / 2;
|
|
4336
3924
|
layout = new Map(nodes.map((node) => {
|
|
4337
|
-
const
|
|
3925
|
+
const position2 = graph.node(node.id);
|
|
4338
3926
|
return [node.id, {
|
|
4339
3927
|
...node,
|
|
4340
3928
|
width: node.width ?? nodeWidth,
|
|
4341
3929
|
height: node.height ?? nodeHeight,
|
|
4342
|
-
cx: (
|
|
4343
|
-
cy: (
|
|
3930
|
+
cx: (position2?.x ?? resolvedWidth / 2) + offsetX,
|
|
3931
|
+
cy: (position2?.y ?? resolvedHeight / 2) + offsetY
|
|
4344
3932
|
}];
|
|
4345
3933
|
}));
|
|
4346
3934
|
const groupsById = new Map(groups.map((group) => [group.id, group]));
|
|
4347
3935
|
groupLayout = groups.map((group) => {
|
|
4348
|
-
const
|
|
3936
|
+
const position2 = graph.node(group.id);
|
|
4349
3937
|
return {
|
|
4350
3938
|
...group,
|
|
4351
|
-
width:
|
|
4352
|
-
height:
|
|
4353
|
-
cx: (
|
|
4354
|
-
cy: (
|
|
3939
|
+
width: position2?.width ?? 0,
|
|
3940
|
+
height: position2?.height ?? 0,
|
|
3941
|
+
cx: (position2?.x ?? resolvedWidth / 2) + offsetX,
|
|
3942
|
+
cy: (position2?.y ?? resolvedHeight / 2) + offsetY,
|
|
4355
3943
|
depth: graphGroupDepth(group, groupsById)
|
|
4356
3944
|
};
|
|
4357
3945
|
}).sort((left, right) => left.depth - right.depth);
|
|
@@ -4645,7 +4233,8 @@ function GraphDiagram({
|
|
|
4645
4233
|
flexDirection: "column",
|
|
4646
4234
|
alignItems: icon ? "flex-start" : "center",
|
|
4647
4235
|
gap: node.detail ? 5 : 0,
|
|
4648
|
-
minWidth: 0
|
|
4236
|
+
minWidth: 0,
|
|
4237
|
+
flexShrink: 1
|
|
4649
4238
|
}
|
|
4650
4239
|
},
|
|
4651
4240
|
React6.createElement("div", {
|
|
@@ -5391,7 +4980,7 @@ function SequenceDiagram({
|
|
|
5391
4980
|
const noteElements = rows.map((row, rowIndex) => {
|
|
5392
4981
|
if (!row.item || !isNote(row.item)) return null;
|
|
5393
4982
|
const note = row.item;
|
|
5394
|
-
const
|
|
4983
|
+
const bounds2 = sequenceNoteBounds(note, participantXs, resolvedWidth, noteWidth, padding);
|
|
5395
4984
|
const tone = note.tone ?? "warm";
|
|
5396
4985
|
const accent = note.muted ? c.textMuted : getToneColor(tone, c);
|
|
5397
4986
|
return React7.createElement("div", {
|
|
@@ -5399,9 +4988,9 @@ function SequenceDiagram({
|
|
|
5399
4988
|
"data-vizmatic-sequence-note": note.id ?? row.key,
|
|
5400
4989
|
style: {
|
|
5401
4990
|
position: "absolute",
|
|
5402
|
-
left:
|
|
4991
|
+
left: bounds2.left,
|
|
5403
4992
|
top: rowCenter(rowIndex) - 17,
|
|
5404
|
-
width:
|
|
4993
|
+
width: bounds2.width,
|
|
5405
4994
|
minHeight: 34,
|
|
5406
4995
|
boxSizing: "border-box",
|
|
5407
4996
|
display: "flex",
|
|
@@ -7061,25 +6650,44 @@ function CanvasChartFit({ children, width, height }) {
|
|
|
7061
6650
|
}
|
|
7062
6651
|
function prepareChartFits(element) {
|
|
7063
6652
|
const sizes = /* @__PURE__ */ new Map();
|
|
6653
|
+
const hasText = (node) => {
|
|
6654
|
+
if (typeof node === "string" || typeof node === "number" || typeof node === "bigint") return true;
|
|
6655
|
+
if (Array.isArray(node)) return node.some(hasText);
|
|
6656
|
+
return isValidElement2(node) && node.type === React10.Fragment && hasText(node.props.children);
|
|
6657
|
+
};
|
|
7064
6658
|
const visit = (node, scope) => {
|
|
7065
6659
|
if (Array.isArray(node)) return node.map((child) => visit(child, scope));
|
|
7066
6660
|
if (!isValidElement2(node)) return node;
|
|
7067
|
-
|
|
7068
|
-
|
|
6661
|
+
const forwarded = node.type;
|
|
6662
|
+
const render = typeof node.type === "function" ? node.type : forwarded?.$$typeof === /* @__PURE__ */ Symbol.for("react.forward_ref") ? forwarded.render : void 0;
|
|
6663
|
+
if (render) {
|
|
6664
|
+
const resolved = visit(render(node.props), scope);
|
|
7069
6665
|
return node.key != null && isValidElement2(resolved) ? React10.cloneElement(resolved, { key: node.key }) : resolved;
|
|
7070
6666
|
}
|
|
7071
6667
|
const size = node.props[FIT_PROP];
|
|
7072
6668
|
const props = { ...node.props };
|
|
7073
6669
|
delete props[FIT_PROP];
|
|
6670
|
+
let childScope = scope;
|
|
7074
6671
|
if (size) {
|
|
7075
6672
|
const id = String(sizes.size);
|
|
7076
6673
|
sizes.set(id, size);
|
|
7077
6674
|
props[VIEWPORT_PROP] = id;
|
|
7078
|
-
|
|
6675
|
+
childScope = id;
|
|
6676
|
+
} else if (scope !== void 0 && typeof node.type === "string") {
|
|
6677
|
+
props[SCOPE_PROP] = scope;
|
|
7079
6678
|
}
|
|
7080
|
-
if (scope !== void 0 && typeof node.type === "string") props[SCOPE_PROP] = scope;
|
|
7081
6679
|
const children = node.props.children;
|
|
7082
|
-
|
|
6680
|
+
const preparedChildren = children === void 0 ? void 0 : visit(children, childScope);
|
|
6681
|
+
if (typeof node.type === "string") {
|
|
6682
|
+
const style = node.props.style;
|
|
6683
|
+
props.style = {
|
|
6684
|
+
minWidth: 0,
|
|
6685
|
+
minHeight: 0,
|
|
6686
|
+
...style?.flex === void 0 ? { flexShrink: hasText(preparedChildren) ? 1 : 0 } : {},
|
|
6687
|
+
...style
|
|
6688
|
+
};
|
|
6689
|
+
}
|
|
6690
|
+
return children === void 0 ? React10.cloneElement(node, props) : React10.cloneElement(node, props, preparedChildren);
|
|
7083
6691
|
};
|
|
7084
6692
|
return { element: visit(element), sizes };
|
|
7085
6693
|
}
|
|
@@ -7105,14 +6713,14 @@ async function renderWithCanvasChartFit(render, element, options) {
|
|
|
7105
6713
|
const prepared = prepareChartFits(element);
|
|
7106
6714
|
if (!prepared.sizes.size) return render(prepared.element, options);
|
|
7107
6715
|
const viewports = /* @__PURE__ */ new Map();
|
|
7108
|
-
const
|
|
6716
|
+
const bounds2 = /* @__PURE__ */ new Map();
|
|
7109
6717
|
await render(prepared.element, { ...options, onNodeDetected(node) {
|
|
7110
6718
|
const viewport = node.props[VIEWPORT_PROP];
|
|
7111
6719
|
if (typeof viewport === "string") viewports.set(viewport, node);
|
|
7112
6720
|
const id = node.props[SCOPE_PROP];
|
|
7113
|
-
if (typeof id !== "string" || node.width
|
|
7114
|
-
const prior =
|
|
7115
|
-
|
|
6721
|
+
if (typeof id !== "string" || node.width < 0 || node.height < 0) return;
|
|
6722
|
+
const prior = bounds2.get(id);
|
|
6723
|
+
bounds2.set(id, {
|
|
7116
6724
|
left: Math.min(prior?.left ?? Infinity, node.left),
|
|
7117
6725
|
top: Math.min(prior?.top ?? Infinity, node.top),
|
|
7118
6726
|
right: Math.max(prior?.right ?? -Infinity, node.left + node.width),
|
|
@@ -7122,7 +6730,7 @@ async function renderWithCanvasChartFit(render, element, options) {
|
|
|
7122
6730
|
const geometry = /* @__PURE__ */ new Map();
|
|
7123
6731
|
for (const [id, size] of prepared.sizes) {
|
|
7124
6732
|
const viewport = viewports.get(id);
|
|
7125
|
-
const measured =
|
|
6733
|
+
const measured = bounds2.get(id);
|
|
7126
6734
|
if (!viewport || !measured) throw new Error("Could not measure the chart inside CanvasItem.");
|
|
7127
6735
|
const width = measured.right - measured.left, height = measured.bottom - measured.top;
|
|
7128
6736
|
const scale = Math.min(size.width / width, size.height / height);
|
|
@@ -9136,8 +8744,8 @@ function normalizeWatermark(watermark) {
|
|
|
9136
8744
|
function Watermark(_props) {
|
|
9137
8745
|
return null;
|
|
9138
8746
|
}
|
|
9139
|
-
function positionStyle(
|
|
9140
|
-
switch (
|
|
8747
|
+
function positionStyle(position2) {
|
|
8748
|
+
switch (position2) {
|
|
9141
8749
|
case "top-left":
|
|
9142
8750
|
return { top: 8, left: 10 };
|
|
9143
8751
|
case "bottom-left":
|
|
@@ -9188,7 +8796,7 @@ function wrapWithWatermark(element, width, height, theme = "dark", watermark = t
|
|
|
9188
8796
|
const isDark = theme === "dark";
|
|
9189
8797
|
const options = normalizeWatermark(watermark);
|
|
9190
8798
|
const color = options?.color ?? (isDark ? WATERMARK_COLOR_DARK : WATERMARK_COLOR_LIGHT);
|
|
9191
|
-
const
|
|
8799
|
+
const position2 = options?.position ?? "top-right";
|
|
9192
8800
|
const opacity = options?.opacity ?? (isDark ? 0.55 : 0.4);
|
|
9193
8801
|
const icon = options ? imageNode(options.image) ?? iconNode(options.icon, color) : void 0;
|
|
9194
8802
|
const text = options?.text ?? DEFAULT_WATERMARK_TEXT;
|
|
@@ -9221,7 +8829,7 @@ function wrapWithWatermark(element, width, height, theme = "dark", watermark = t
|
|
|
9221
8829
|
{
|
|
9222
8830
|
style: {
|
|
9223
8831
|
position: "absolute",
|
|
9224
|
-
...positionStyle(
|
|
8832
|
+
...positionStyle(position2),
|
|
9225
8833
|
display: "flex",
|
|
9226
8834
|
alignItems: "center",
|
|
9227
8835
|
gap: 5,
|
|
@@ -9585,23 +9193,19 @@ function cropLayoutNodes(nodes, region) {
|
|
|
9585
9193
|
}];
|
|
9586
9194
|
});
|
|
9587
9195
|
}
|
|
9588
|
-
function cropSavesEnough(source, target) {
|
|
9589
|
-
if (source <= 0 || target >= source) return false;
|
|
9590
|
-
return (source - target) / source * 100 >= CROP_THRESHOLD_PERCENT;
|
|
9591
|
-
}
|
|
9592
9196
|
var CanvasOverflowError = class extends Error {
|
|
9593
9197
|
width;
|
|
9594
9198
|
height;
|
|
9595
9199
|
overflow;
|
|
9596
9200
|
animation;
|
|
9597
9201
|
constructor(width, height, overflow, animation) {
|
|
9598
|
-
const
|
|
9202
|
+
const position2 = animation ? [
|
|
9599
9203
|
animation.sceneIndex != null ? `scene ${animation.sceneIndex + 1}` : void 0,
|
|
9600
9204
|
animation.frameIndex != null ? `frame ${animation.frameIndex + 1}${animation.frameCount ? `/${animation.frameCount}` : ""}` : void 0,
|
|
9601
9205
|
animation.time != null ? `${Math.round(animation.time)}ms` : void 0,
|
|
9602
9206
|
animation.label ? JSON.stringify(animation.label) : void 0
|
|
9603
9207
|
].filter(Boolean).join(", ") : "";
|
|
9604
|
-
super(`Canvas overflow detected (${width}\xD7${height})${
|
|
9208
|
+
super(`Canvas overflow detected (${width}\xD7${height})${position2 ? ` at ${position2}` : ""}: ${overflow.message}`);
|
|
9605
9209
|
this.name = "CanvasOverflowError";
|
|
9606
9210
|
this.width = width;
|
|
9607
9211
|
this.height = height;
|
|
@@ -9645,7 +9249,7 @@ async function renderToPngInContext(element, options, createFn, theme) {
|
|
|
9645
9249
|
const detectPixels = detectResult.pixels;
|
|
9646
9250
|
const pixelData = new Uint8Array(detectPixels.buffer);
|
|
9647
9251
|
const detectedBg = detectBackgroundColor(pixelData);
|
|
9648
|
-
const
|
|
9252
|
+
const bounds2 = detectContentBounds(
|
|
9649
9253
|
pixelData,
|
|
9650
9254
|
options.width,
|
|
9651
9255
|
detectResult.height,
|
|
@@ -9664,7 +9268,7 @@ async function renderToPngInContext(element, options, createFn, theme) {
|
|
|
9664
9268
|
let finalWidth = options.width;
|
|
9665
9269
|
let finalHeight = options.height;
|
|
9666
9270
|
let finalElement = element;
|
|
9667
|
-
const croppedHeight =
|
|
9271
|
+
const croppedHeight = bounds2.y + bounds2.height;
|
|
9668
9272
|
const heightSaved = options.height - croppedHeight;
|
|
9669
9273
|
const heightSavedPercent = heightSaved / options.height * 100;
|
|
9670
9274
|
if (shouldCropHeight(options.crop) && heightSavedPercent >= CROP_THRESHOLD_PERCENT) {
|
|
@@ -9723,7 +9327,7 @@ async function renderToPngInContext(element, options, createFn, theme) {
|
|
|
9723
9327
|
viewportBg,
|
|
9724
9328
|
AUTOCROP_PADDING
|
|
9725
9329
|
);
|
|
9726
|
-
if (
|
|
9330
|
+
if (viewportBounds.width < finalWidth || viewportBounds.height < viewportCheck.height) {
|
|
9727
9331
|
finalSvg = cropSvgViewport(finalSvg, viewportBounds);
|
|
9728
9332
|
finalRender.layoutNodes = cropLayoutNodes(finalRender.layoutNodes, viewportBounds);
|
|
9729
9333
|
finalWidth = viewportBounds.width;
|
|
@@ -9835,7 +9439,7 @@ import { Resvg as Resvg2 } from "@resvg/resvg-js";
|
|
|
9835
9439
|
import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
|
|
9836
9440
|
import { dirname as dirname2 } from "path";
|
|
9837
9441
|
import * as gifenc from "gifenc";
|
|
9838
|
-
import
|
|
9442
|
+
import parseCssColor from "parse-css-color";
|
|
9839
9443
|
|
|
9840
9444
|
// src/timeline.ts
|
|
9841
9445
|
var MIN_FPS = 1;
|
|
@@ -9855,18 +9459,18 @@ function clampProgress(progress) {
|
|
|
9855
9459
|
return Math.max(0, Math.min(1, progress));
|
|
9856
9460
|
}
|
|
9857
9461
|
function easingValue(easing = "linear", progress) {
|
|
9858
|
-
const
|
|
9462
|
+
const amount2 = clampProgress(progress);
|
|
9859
9463
|
let result;
|
|
9860
9464
|
if (typeof easing === "function") {
|
|
9861
|
-
result = easing(
|
|
9465
|
+
result = easing(amount2);
|
|
9862
9466
|
} else if (easing === "ease-in") {
|
|
9863
|
-
result =
|
|
9467
|
+
result = amount2 * amount2 * amount2;
|
|
9864
9468
|
} else if (easing === "ease-out") {
|
|
9865
|
-
result = 1 - (1 -
|
|
9469
|
+
result = 1 - (1 - amount2) ** 3;
|
|
9866
9470
|
} else if (easing === "ease-in-out") {
|
|
9867
|
-
result =
|
|
9471
|
+
result = amount2 < 0.5 ? 4 * amount2 * amount2 * amount2 : 1 - (-2 * amount2 + 2) ** 3 / 2;
|
|
9868
9472
|
} else if (easing === "linear") {
|
|
9869
|
-
result =
|
|
9473
|
+
result = amount2;
|
|
9870
9474
|
} else {
|
|
9871
9475
|
throw new Error(`Unknown animation easing: ${String(easing)}`);
|
|
9872
9476
|
}
|
|
@@ -9938,8 +9542,8 @@ function defineAnimation(definition) {
|
|
|
9938
9542
|
fps
|
|
9939
9543
|
};
|
|
9940
9544
|
}
|
|
9941
|
-
function interpolateValue(from, to, progress,
|
|
9942
|
-
if (
|
|
9545
|
+
function interpolateValue(from, to, progress, interpolate2) {
|
|
9546
|
+
if (interpolate2) return interpolate2(from, to, progress);
|
|
9943
9547
|
if (typeof from === "number" && typeof to === "number" && Number.isFinite(from) && Number.isFinite(to)) {
|
|
9944
9548
|
return from + (to - from) * progress;
|
|
9945
9549
|
}
|
|
@@ -10075,6 +9679,23 @@ function sampleAnimation(animation, time) {
|
|
|
10075
9679
|
if (!Number.isFinite(time)) throw new Error("Animation sample time must be finite");
|
|
10076
9680
|
return evaluateAnimation(animation, time).state;
|
|
10077
9681
|
}
|
|
9682
|
+
function sampleAnimationFrame(animation, requestedTime, timing) {
|
|
9683
|
+
if (!Number.isFinite(requestedTime)) throw new Error("Animation sample time must be finite");
|
|
9684
|
+
const time = Math.max(0, Math.min(animation.duration, requestedTime));
|
|
9685
|
+
const evaluated = evaluateAnimation(animation, time);
|
|
9686
|
+
return {
|
|
9687
|
+
state: evaluated.state,
|
|
9688
|
+
frame: {
|
|
9689
|
+
...timing,
|
|
9690
|
+
time,
|
|
9691
|
+
duration: animation.duration,
|
|
9692
|
+
progress: time / animation.duration,
|
|
9693
|
+
step: evaluated.step,
|
|
9694
|
+
stepProgress: evaluated.stepProgress,
|
|
9695
|
+
label: evaluated.label
|
|
9696
|
+
}
|
|
9697
|
+
};
|
|
9698
|
+
}
|
|
10078
9699
|
function animationCadence(duration, fps) {
|
|
10079
9700
|
const interval = 1e3 / fps;
|
|
10080
9701
|
const times = [0];
|
|
@@ -10113,24 +9734,12 @@ function sampleAnimationFrames(animation, options = {}) {
|
|
|
10113
9734
|
assertFps(fps);
|
|
10114
9735
|
const cadence = animationCadence(animation.duration, fps);
|
|
10115
9736
|
const count = cadence.times.length;
|
|
10116
|
-
return cadence.times.map((time, index) => {
|
|
10117
|
-
|
|
10118
|
-
|
|
10119
|
-
|
|
10120
|
-
|
|
10121
|
-
|
|
10122
|
-
count,
|
|
10123
|
-
time,
|
|
10124
|
-
duration: animation.duration,
|
|
10125
|
-
delay: cadence.delays[index],
|
|
10126
|
-
progress: time / animation.duration,
|
|
10127
|
-
step: evaluated.step,
|
|
10128
|
-
stepProgress: evaluated.stepProgress,
|
|
10129
|
-
label: evaluated.label,
|
|
10130
|
-
fps
|
|
10131
|
-
}
|
|
10132
|
-
};
|
|
10133
|
-
});
|
|
9737
|
+
return cadence.times.map((time, index) => sampleAnimationFrame(animation, time, {
|
|
9738
|
+
index,
|
|
9739
|
+
count,
|
|
9740
|
+
delay: cadence.delays[index],
|
|
9741
|
+
fps
|
|
9742
|
+
}));
|
|
10134
9743
|
}
|
|
10135
9744
|
|
|
10136
9745
|
// src/animate.ts
|
|
@@ -10226,7 +9835,7 @@ function hslToRgb(hue, saturation, lightness) {
|
|
|
10226
9835
|
}
|
|
10227
9836
|
function colorForBackground(background, theme) {
|
|
10228
9837
|
const value = background === "theme" ? getThemeColors(theme).bg : background;
|
|
10229
|
-
const parsed =
|
|
9838
|
+
const parsed = parseCssColor(value);
|
|
10230
9839
|
if (!parsed) throw new Error(`Invalid animation background color: ${value}`);
|
|
10231
9840
|
const [r, g, b] = parsed.type === "hsl" ? hslToRgb(parsed.values[0], parsed.values[1], parsed.values[2]) : [parsed.values[0], parsed.values[1], parsed.values[2]];
|
|
10232
9841
|
return { r, g, b, a: Math.round(parsed.alpha * 255) };
|
|
@@ -10301,16 +9910,16 @@ function cropFramePixels(pixels, canvasWidth, region) {
|
|
|
10301
9910
|
}
|
|
10302
9911
|
function deltaPixelFrame(frame, previous, enabled) {
|
|
10303
9912
|
if (!enabled || !previous) return frame;
|
|
10304
|
-
const
|
|
10305
|
-
if (!
|
|
9913
|
+
const bounds2 = changedBounds(previous, frame.pixels, frame.width, frame.height);
|
|
9914
|
+
if (!bounds2 || bounds2.width === frame.width && bounds2.height === frame.height) return frame;
|
|
10306
9915
|
return {
|
|
10307
9916
|
...frame,
|
|
10308
|
-
x:
|
|
10309
|
-
y:
|
|
9917
|
+
x: bounds2.x,
|
|
9918
|
+
y: bounds2.y,
|
|
10310
9919
|
delta: true,
|
|
10311
|
-
width:
|
|
10312
|
-
height:
|
|
10313
|
-
pixels: cropFramePixels(frame.pixels, frame.width,
|
|
9920
|
+
width: bounds2.width,
|
|
9921
|
+
height: bounds2.height,
|
|
9922
|
+
pixels: cropFramePixels(frame.pixels, frame.width, bounds2)
|
|
10314
9923
|
};
|
|
10315
9924
|
}
|
|
10316
9925
|
function encodeGif(frames, loop, deltaFrames) {
|
|
@@ -10416,8 +10025,8 @@ async function scenesToFrames(scenes, options) {
|
|
|
10416
10025
|
);
|
|
10417
10026
|
const frameDelays = transitionFrameDelays(transitionDuration, transitionFrames);
|
|
10418
10027
|
for (let frameIndex = 0; frameIndex < transitionFrames; frameIndex += 1) {
|
|
10419
|
-
const
|
|
10420
|
-
const pixels = transition === "fade" ? blendPixels(previous.pixels, current.pixels,
|
|
10028
|
+
const amount2 = (frameIndex + 1) / transitionFrames;
|
|
10029
|
+
const pixels = transition === "fade" ? blendPixels(previous.pixels, current.pixels, amount2) : blendPixels(backgroundPixels(scaledWidth, scaledHeight, options.theme, options.background), current.pixels, amount2);
|
|
10421
10030
|
frames.push({ pixels, delay: frameDelays[frameIndex], width: scaledWidth, height: scaledHeight });
|
|
10422
10031
|
}
|
|
10423
10032
|
}
|
|
@@ -10609,6 +10218,1825 @@ async function renderAnimationGifWithOutput(animation, options) {
|
|
|
10609
10218
|
};
|
|
10610
10219
|
}
|
|
10611
10220
|
|
|
10221
|
+
// src/math.ts
|
|
10222
|
+
import parseCssColor2 from "parse-css-color";
|
|
10223
|
+
import { liteAdaptor } from "mathjax-full/js/adaptors/liteAdaptor.js";
|
|
10224
|
+
import { RegisterHTMLHandler } from "mathjax-full/js/handlers/html.js";
|
|
10225
|
+
import { TeX } from "mathjax-full/js/input/tex.js";
|
|
10226
|
+
import "mathjax-full/js/input/tex/ams/AmsConfiguration.js";
|
|
10227
|
+
import "mathjax-full/js/input/tex/newcommand/NewcommandConfiguration.js";
|
|
10228
|
+
import { mathjax } from "mathjax-full/js/mathjax.js";
|
|
10229
|
+
import { SVG } from "mathjax-full/js/output/svg.js";
|
|
10230
|
+
var DEFAULT_FONT_SIZE = 16;
|
|
10231
|
+
var EX_FACTOR = 0.5;
|
|
10232
|
+
var adaptor = liteAdaptor({ fontSize: DEFAULT_FONT_SIZE });
|
|
10233
|
+
RegisterHTMLHandler(adaptor);
|
|
10234
|
+
var outputJax = new SVG({ fontCache: "none", exFactor: EX_FACTOR });
|
|
10235
|
+
var renderCache = /* @__PURE__ */ new Map();
|
|
10236
|
+
var RENDER_CACHE_LIMIT = 128;
|
|
10237
|
+
function createDocument() {
|
|
10238
|
+
const inputJax = new TeX({
|
|
10239
|
+
packages: ["base", "ams", "newcommand"],
|
|
10240
|
+
formatError(_jax, error) {
|
|
10241
|
+
throw new Error(`Invalid TeX: ${error.message}`, { cause: error });
|
|
10242
|
+
}
|
|
10243
|
+
});
|
|
10244
|
+
return mathjax.document("", { InputJax: inputJax, OutputJax: outputJax });
|
|
10245
|
+
}
|
|
10246
|
+
function parseEx(value, name) {
|
|
10247
|
+
if (typeof value !== "string" || !value.endsWith("ex")) {
|
|
10248
|
+
throw new Error(`MathJax returned an unsupported ${name} dimension`);
|
|
10249
|
+
}
|
|
10250
|
+
const amount2 = Number(value.slice(0, -2));
|
|
10251
|
+
if (!Number.isFinite(amount2) || amount2 <= 0) {
|
|
10252
|
+
throw new Error(`MathJax returned an invalid ${name} dimension`);
|
|
10253
|
+
}
|
|
10254
|
+
return amount2;
|
|
10255
|
+
}
|
|
10256
|
+
function parseViewBox(value) {
|
|
10257
|
+
if (typeof value !== "string") throw new Error("MathJax returned an SVG without a viewBox");
|
|
10258
|
+
const values = value.trim().split(/[ ,]+/).map(Number);
|
|
10259
|
+
if (values.length !== 4 || values.some((part) => !Number.isFinite(part)) || values[2] <= 0 || values[3] <= 0) {
|
|
10260
|
+
throw new Error("MathJax returned an invalid SVG viewBox");
|
|
10261
|
+
}
|
|
10262
|
+
return [values[0], values[1], values[2], values[3]];
|
|
10263
|
+
}
|
|
10264
|
+
function renderMathSvg(tex, options = {}) {
|
|
10265
|
+
if (typeof tex !== "string" || tex.trim().length === 0) {
|
|
10266
|
+
throw new Error("TeX input must be a non-empty string");
|
|
10267
|
+
}
|
|
10268
|
+
const fontSize = options.fontSize ?? DEFAULT_FONT_SIZE;
|
|
10269
|
+
if (!Number.isFinite(fontSize) || fontSize <= 0) {
|
|
10270
|
+
throw new Error("Math SVG fontSize must be a positive finite number");
|
|
10271
|
+
}
|
|
10272
|
+
const color = options.color ?? "#000000";
|
|
10273
|
+
if (typeof color !== "string" || !parseCssColor2(color.trim())) {
|
|
10274
|
+
throw new Error("Math SVG color must be a valid CSS color");
|
|
10275
|
+
}
|
|
10276
|
+
const normalizedColor = color.trim();
|
|
10277
|
+
const display = options.display ?? false;
|
|
10278
|
+
const key = JSON.stringify([tex, fontSize, normalizedColor, display]);
|
|
10279
|
+
const cached = renderCache.get(key);
|
|
10280
|
+
if (cached) {
|
|
10281
|
+
renderCache.delete(key);
|
|
10282
|
+
renderCache.set(key, cached);
|
|
10283
|
+
return { ...cached };
|
|
10284
|
+
}
|
|
10285
|
+
let container;
|
|
10286
|
+
try {
|
|
10287
|
+
container = createDocument().convert(tex, {
|
|
10288
|
+
display,
|
|
10289
|
+
em: fontSize,
|
|
10290
|
+
ex: fontSize * EX_FACTOR,
|
|
10291
|
+
containerWidth: fontSize * 80
|
|
10292
|
+
});
|
|
10293
|
+
} catch (cause) {
|
|
10294
|
+
if (cause instanceof Error && cause.message.startsWith("Invalid TeX:")) throw cause;
|
|
10295
|
+
const detail = cause instanceof Error ? cause.message : String(cause);
|
|
10296
|
+
throw new Error(`Unable to render TeX: ${detail}`, { cause });
|
|
10297
|
+
}
|
|
10298
|
+
const svgElement = adaptor.tags(container, "svg")[0];
|
|
10299
|
+
if (!svgElement) throw new Error("MathJax did not produce an SVG image");
|
|
10300
|
+
const width = parseEx(adaptor.getAttribute(svgElement, "width"), "width") * fontSize * EX_FACTOR;
|
|
10301
|
+
const height = parseEx(adaptor.getAttribute(svgElement, "height"), "height") * fontSize * EX_FACTOR;
|
|
10302
|
+
if (!Number.isFinite(width) || !Number.isFinite(height)) {
|
|
10303
|
+
throw new Error("MathJax returned non-finite SVG dimensions");
|
|
10304
|
+
}
|
|
10305
|
+
const [, viewBoxY, , viewBoxHeight] = parseViewBox(adaptor.getAttribute(svgElement, "viewBox"));
|
|
10306
|
+
const baseline = -viewBoxY * height / viewBoxHeight;
|
|
10307
|
+
if (!Number.isFinite(baseline)) {
|
|
10308
|
+
throw new Error("MathJax returned an invalid SVG baseline");
|
|
10309
|
+
}
|
|
10310
|
+
const drawing = adaptor.tags(svgElement, "g")[0];
|
|
10311
|
+
if (!drawing) throw new Error("MathJax returned an SVG without a drawing group");
|
|
10312
|
+
adaptor.removeAttribute(svgElement, "style");
|
|
10313
|
+
adaptor.setAttribute(svgElement, "width", `${width}px`);
|
|
10314
|
+
adaptor.setAttribute(svgElement, "height", `${height}px`);
|
|
10315
|
+
adaptor.setAttribute(drawing, "fill", normalizedColor);
|
|
10316
|
+
adaptor.setAttribute(drawing, "stroke", normalizedColor);
|
|
10317
|
+
const result = {
|
|
10318
|
+
svg: adaptor.serializeXML(svgElement),
|
|
10319
|
+
width,
|
|
10320
|
+
height,
|
|
10321
|
+
baseline
|
|
10322
|
+
};
|
|
10323
|
+
renderCache.set(key, result);
|
|
10324
|
+
if (renderCache.size > RENDER_CACHE_LIMIT) {
|
|
10325
|
+
renderCache.delete(renderCache.keys().next().value);
|
|
10326
|
+
}
|
|
10327
|
+
return { ...result };
|
|
10328
|
+
}
|
|
10329
|
+
|
|
10330
|
+
// src/motion.ts
|
|
10331
|
+
var DEFAULT_ARC_LIFT = 80;
|
|
10332
|
+
function assertFiniteProgress(progress) {
|
|
10333
|
+
if (!Number.isFinite(progress)) throw new Error("Motion progress must be finite");
|
|
10334
|
+
}
|
|
10335
|
+
function clampProgress2(progress) {
|
|
10336
|
+
assertFiniteProgress(progress);
|
|
10337
|
+
return Math.max(0, Math.min(1, progress));
|
|
10338
|
+
}
|
|
10339
|
+
function assertPoint(point, context) {
|
|
10340
|
+
if (!Number.isFinite(point.x) || !Number.isFinite(point.y)) {
|
|
10341
|
+
throw new Error(`${context} coordinates must be finite`);
|
|
10342
|
+
}
|
|
10343
|
+
}
|
|
10344
|
+
function interpolate(from, to, progress) {
|
|
10345
|
+
return {
|
|
10346
|
+
x: from.x * (1 - progress) + to.x * progress,
|
|
10347
|
+
y: from.y * (1 - progress) + to.y * progress
|
|
10348
|
+
};
|
|
10349
|
+
}
|
|
10350
|
+
function smoothstep(progress) {
|
|
10351
|
+
const amount2 = clampProgress2(progress);
|
|
10352
|
+
return amount2 * amount2 * (3 - 2 * amount2);
|
|
10353
|
+
}
|
|
10354
|
+
function arcSwap(from, to, progress, options = {}) {
|
|
10355
|
+
assertPoint(from, "Arc swap start");
|
|
10356
|
+
assertPoint(to, "Arc swap end");
|
|
10357
|
+
const amount2 = clampProgress2(progress);
|
|
10358
|
+
const lift = options.lift ?? DEFAULT_ARC_LIFT;
|
|
10359
|
+
if (!Number.isFinite(lift)) throw new Error("Arc swap lift must be finite");
|
|
10360
|
+
if (amount2 === 0) return [{ x: from.x, y: from.y }, { x: to.x, y: to.y }];
|
|
10361
|
+
if (amount2 === 1) return [{ x: to.x, y: to.y }, { x: from.x, y: from.y }];
|
|
10362
|
+
const eased = (options.easing ?? smoothstep)(amount2);
|
|
10363
|
+
if (!Number.isFinite(eased)) throw new Error("Motion easing must return a finite number");
|
|
10364
|
+
const t = Math.max(0, Math.min(1, eased));
|
|
10365
|
+
if (t === 0) return [{ x: from.x, y: from.y }, { x: to.x, y: to.y }];
|
|
10366
|
+
if (t === 1) return [{ x: to.x, y: to.y }, { x: from.x, y: from.y }];
|
|
10367
|
+
const dx = to.x - from.x;
|
|
10368
|
+
const dy = to.y - from.y;
|
|
10369
|
+
const length = Math.hypot(dx, dy);
|
|
10370
|
+
if (!Number.isFinite(length)) throw new Error("Arc swap distance must be finite");
|
|
10371
|
+
if (length === 0) return [{ x: from.x, y: from.y }, { x: to.x, y: to.y }];
|
|
10372
|
+
const normalX = -dy / length;
|
|
10373
|
+
const normalY = dx / length;
|
|
10374
|
+
const arcHeight = 4 * (1 - t) * t * lift;
|
|
10375
|
+
const firstBase = interpolate(from, to, t);
|
|
10376
|
+
const secondBase = interpolate(to, from, t);
|
|
10377
|
+
const first = {
|
|
10378
|
+
x: firstBase.x + normalX * arcHeight,
|
|
10379
|
+
y: firstBase.y + normalY * arcHeight
|
|
10380
|
+
};
|
|
10381
|
+
const second = {
|
|
10382
|
+
x: secondBase.x - normalX * arcHeight,
|
|
10383
|
+
y: secondBase.y - normalY * arcHeight
|
|
10384
|
+
};
|
|
10385
|
+
assertPoint(first, "Arc swap result");
|
|
10386
|
+
assertPoint(second, "Arc swap result");
|
|
10387
|
+
return [first, second];
|
|
10388
|
+
}
|
|
10389
|
+
function pathLengths(points) {
|
|
10390
|
+
const lengths = [];
|
|
10391
|
+
let total = 0;
|
|
10392
|
+
for (let index = 0; index < points.length; index += 1) {
|
|
10393
|
+
const point = points[index];
|
|
10394
|
+
assertPoint(point, `Path point ${index}`);
|
|
10395
|
+
if (index === 0) continue;
|
|
10396
|
+
const previous = points[index - 1];
|
|
10397
|
+
const length = Math.hypot(point.x - previous.x, point.y - previous.y);
|
|
10398
|
+
if (!Number.isFinite(length)) throw new Error("Path segment length must be finite");
|
|
10399
|
+
total += length;
|
|
10400
|
+
if (!Number.isFinite(total)) throw new Error("Path length must be finite");
|
|
10401
|
+
lengths.push(length);
|
|
10402
|
+
}
|
|
10403
|
+
return lengths;
|
|
10404
|
+
}
|
|
10405
|
+
function tracePolyline(points, progress) {
|
|
10406
|
+
const amount2 = clampProgress2(progress);
|
|
10407
|
+
if (points.length === 0) return [];
|
|
10408
|
+
const lengths = pathLengths(points);
|
|
10409
|
+
if (amount2 === 1) return points.map(({ x, y }) => ({ x, y }));
|
|
10410
|
+
const traced = [{ x: points[0].x, y: points[0].y }];
|
|
10411
|
+
if (amount2 === 0 || lengths.length === 0) return traced;
|
|
10412
|
+
const total = lengths.reduce((sum, length) => sum + length, 0);
|
|
10413
|
+
if (total === 0) return traced;
|
|
10414
|
+
const target = total * amount2;
|
|
10415
|
+
let travelled = 0;
|
|
10416
|
+
for (let index = 0; index < lengths.length; index += 1) {
|
|
10417
|
+
const segmentLength = lengths[index];
|
|
10418
|
+
const next = points[index + 1];
|
|
10419
|
+
if (segmentLength === 0) continue;
|
|
10420
|
+
const segmentEnd = travelled + segmentLength;
|
|
10421
|
+
if (target >= segmentEnd) {
|
|
10422
|
+
traced.push({ x: next.x, y: next.y });
|
|
10423
|
+
travelled = segmentEnd;
|
|
10424
|
+
continue;
|
|
10425
|
+
}
|
|
10426
|
+
const segmentProgress = (target - travelled) / segmentLength;
|
|
10427
|
+
const point = interpolate(points[index], next, segmentProgress);
|
|
10428
|
+
assertPoint(point, "Polyline trace result");
|
|
10429
|
+
const previous = traced[traced.length - 1];
|
|
10430
|
+
if (point.x !== previous.x || point.y !== previous.y) traced.push(point);
|
|
10431
|
+
return traced;
|
|
10432
|
+
}
|
|
10433
|
+
return traced;
|
|
10434
|
+
}
|
|
10435
|
+
function pointAlongPath(points, progress) {
|
|
10436
|
+
if (points.length === 0) throw new Error("Cannot find a point along an empty path");
|
|
10437
|
+
const traced = tracePolyline(points, progress);
|
|
10438
|
+
return { ...traced[traced.length - 1] };
|
|
10439
|
+
}
|
|
10440
|
+
|
|
10441
|
+
// src/canvas-components.ts
|
|
10442
|
+
function finite(value, name) {
|
|
10443
|
+
if (!Number.isFinite(value)) throw new Error(`${name} must be finite`);
|
|
10444
|
+
}
|
|
10445
|
+
function nonnegative(value, name) {
|
|
10446
|
+
finite(value, name);
|
|
10447
|
+
if (value < 0) throw new Error(`${name} must be nonnegative`);
|
|
10448
|
+
}
|
|
10449
|
+
function positive(value, name) {
|
|
10450
|
+
finite(value, name);
|
|
10451
|
+
if (value <= 0) throw new Error(`${name} must be positive`);
|
|
10452
|
+
}
|
|
10453
|
+
function normalizedOpacity(value, name = "Canvas opacity") {
|
|
10454
|
+
finite(value, name);
|
|
10455
|
+
return Math.max(0, Math.min(1, value));
|
|
10456
|
+
}
|
|
10457
|
+
function validateBounds(bounds2) {
|
|
10458
|
+
finite(bounds2.x, "Canvas x");
|
|
10459
|
+
finite(bounds2.y, "Canvas y");
|
|
10460
|
+
positive(bounds2.width, "Canvas width");
|
|
10461
|
+
positive(bounds2.height, "Canvas height");
|
|
10462
|
+
nonnegative(bounds2.radius ?? 14, "Canvas radius");
|
|
10463
|
+
}
|
|
10464
|
+
function layoutTokenRow(values, options = {}) {
|
|
10465
|
+
const { advance = 24, gap = 16, minWidth = 64, paddingX = 17, width } = options;
|
|
10466
|
+
nonnegative(advance, "Token advance");
|
|
10467
|
+
nonnegative(gap, "Token gap");
|
|
10468
|
+
positive(minWidth, "Token minimum width");
|
|
10469
|
+
nonnegative(paddingX, "Token horizontal padding");
|
|
10470
|
+
if (width !== void 0) positive(width, "Token width");
|
|
10471
|
+
if (options.x !== void 0) finite(options.x, "Token x");
|
|
10472
|
+
if (options.centerX !== void 0) finite(options.centerX, "Token center x");
|
|
10473
|
+
const items = values.map((value) => {
|
|
10474
|
+
const text = String(value);
|
|
10475
|
+
return { text, x: 0, width: width ?? Math.max(minWidth, text.length * advance + 2 * paddingX) };
|
|
10476
|
+
});
|
|
10477
|
+
const totalWidth = items.reduce((total, item) => total + item.width, 0) + Math.max(0, items.length - 1) * gap;
|
|
10478
|
+
let x = options.x ?? (options.centerX ?? 0) - totalWidth / 2;
|
|
10479
|
+
finite(x, "Token row origin");
|
|
10480
|
+
for (const item of items) {
|
|
10481
|
+
item.x = x;
|
|
10482
|
+
x += item.width + gap;
|
|
10483
|
+
finite(x, "Token row extent");
|
|
10484
|
+
}
|
|
10485
|
+
return items;
|
|
10486
|
+
}
|
|
10487
|
+
function createCanvasComponents(painter) {
|
|
10488
|
+
function fade(alpha2, draw) {
|
|
10489
|
+
const amount2 = normalizedOpacity(alpha2);
|
|
10490
|
+
if (amount2 > 0) painter.opacity(amount2, draw);
|
|
10491
|
+
}
|
|
10492
|
+
function panel(options, draw) {
|
|
10493
|
+
validateBounds(options);
|
|
10494
|
+
const { x, y, width, height, fill, stroke, radius = 14, padding = 10, id, scope = "container", opacity = 1 } = options;
|
|
10495
|
+
nonnegative(padding, "Canvas padding");
|
|
10496
|
+
const alpha2 = normalizedOpacity(opacity);
|
|
10497
|
+
if (scope !== "container" && scope !== "label") throw new Error("Canvas scope must be container or label");
|
|
10498
|
+
let shape;
|
|
10499
|
+
painter.opacity(alpha2, () => {
|
|
10500
|
+
shape = painter.rect(x, y, width, height, fill, stroke, radius);
|
|
10501
|
+
if (draw) {
|
|
10502
|
+
const bounds2 = { x, y, width, height, radius };
|
|
10503
|
+
const scopeOptions = { padding, id };
|
|
10504
|
+
if (scope === "label") painter.labelScope(bounds2, draw, scopeOptions);
|
|
10505
|
+
else painter.container(bounds2, draw, scopeOptions);
|
|
10506
|
+
}
|
|
10507
|
+
});
|
|
10508
|
+
return shape;
|
|
10509
|
+
}
|
|
10510
|
+
function card(options) {
|
|
10511
|
+
const { label, x, y, width, height, fontSize = 32, font = "sans", textColor, baselineOffset = fontSize * 0.34, labelOpacity = 1 } = options;
|
|
10512
|
+
positive(fontSize, "Canvas font size");
|
|
10513
|
+
finite(baselineOffset, "Canvas text baseline offset");
|
|
10514
|
+
const labelAlpha = normalizedOpacity(labelOpacity, "Canvas label opacity");
|
|
10515
|
+
return panel(options, () => {
|
|
10516
|
+
fade(labelAlpha, () => {
|
|
10517
|
+
painter.text(String(label), x + width / 2, y + height / 2 + baselineOffset, fontSize, textColor, "center", font);
|
|
10518
|
+
});
|
|
10519
|
+
});
|
|
10520
|
+
}
|
|
10521
|
+
function matrix(options) {
|
|
10522
|
+
const { values, x, y, cellSize = 112, gap = 8, inset = 0, format = String, style = {}, cellStyle } = options;
|
|
10523
|
+
finite(x, "Matrix x");
|
|
10524
|
+
finite(y, "Matrix y");
|
|
10525
|
+
positive(cellSize, "Matrix cell size");
|
|
10526
|
+
nonnegative(gap, "Matrix gap");
|
|
10527
|
+
finite(inset, "Matrix inset");
|
|
10528
|
+
if (gap >= cellSize) throw new Error("Matrix gap must be smaller than cell size");
|
|
10529
|
+
const columns = values[0]?.length ?? 0;
|
|
10530
|
+
for (const row of values) {
|
|
10531
|
+
if (!Array.isArray(row) || row.length !== columns) throw new Error("Canvas matrix rows must be rectangular");
|
|
10532
|
+
}
|
|
10533
|
+
const shapes = [];
|
|
10534
|
+
for (let row = 0; row < values.length; row += 1) {
|
|
10535
|
+
for (let column = 0; column < columns; column += 1) {
|
|
10536
|
+
const value = values[row][column];
|
|
10537
|
+
const cell = { ...style, ...cellStyle?.(value, row, column) };
|
|
10538
|
+
finite(cell.opacity ?? 1, "Canvas opacity");
|
|
10539
|
+
if ((cell.opacity ?? 1) <= 0) continue;
|
|
10540
|
+
const shape = card({
|
|
10541
|
+
...cell,
|
|
10542
|
+
x: x + column * cellSize + inset,
|
|
10543
|
+
y: y + row * cellSize + inset,
|
|
10544
|
+
width: cellSize - gap,
|
|
10545
|
+
height: cellSize - gap,
|
|
10546
|
+
label: format(value, row, column)
|
|
10547
|
+
});
|
|
10548
|
+
shapes.push(shape);
|
|
10549
|
+
}
|
|
10550
|
+
}
|
|
10551
|
+
return shapes;
|
|
10552
|
+
}
|
|
10553
|
+
function tokenRow(options) {
|
|
10554
|
+
const { values, y, height = 68, reveal = 1, opacity = 1, ...style } = options;
|
|
10555
|
+
finite(y, "Token row y");
|
|
10556
|
+
positive(height, "Token height");
|
|
10557
|
+
finite(reveal, "Token reveal");
|
|
10558
|
+
const alpha2 = normalizedOpacity(opacity);
|
|
10559
|
+
const items = layoutTokenRow(values, options);
|
|
10560
|
+
const shapes = [];
|
|
10561
|
+
for (let index = 0; index < items.length; index += 1) {
|
|
10562
|
+
const amount2 = Math.max(0, Math.min(1, reveal * items.length - index)) * alpha2;
|
|
10563
|
+
if (amount2 <= 0) continue;
|
|
10564
|
+
const { text: label, x, width } = items[index];
|
|
10565
|
+
const shape = card({ ...style, label, x, y, width, height, opacity: amount2 });
|
|
10566
|
+
shapes.push(shape);
|
|
10567
|
+
}
|
|
10568
|
+
return shapes;
|
|
10569
|
+
}
|
|
10570
|
+
function particle(options) {
|
|
10571
|
+
const { points, progress, radius = 9, fill, stroke, strokeWidth = 3 } = options;
|
|
10572
|
+
finite(progress, "Particle progress");
|
|
10573
|
+
positive(radius, "Particle radius");
|
|
10574
|
+
nonnegative(strokeWidth, "Particle stroke width");
|
|
10575
|
+
if (progress <= 0 || progress >= 1) return null;
|
|
10576
|
+
const point = pointAlongPath(points, progress);
|
|
10577
|
+
painter.circle(point.x, point.y, radius, fill, stroke, strokeWidth);
|
|
10578
|
+
return point;
|
|
10579
|
+
}
|
|
10580
|
+
return { panel, card, matrix, tokenRow, particle, fade };
|
|
10581
|
+
}
|
|
10582
|
+
|
|
10583
|
+
// src/teaching-transfer.ts
|
|
10584
|
+
function nonnegative2(value, name) {
|
|
10585
|
+
if (!Number.isFinite(value) || value < 0) throw new Error(`${name} must be finite and nonnegative`);
|
|
10586
|
+
}
|
|
10587
|
+
function alpha(value) {
|
|
10588
|
+
if (!Number.isFinite(value)) throw new Error("Transfer opacity must be finite");
|
|
10589
|
+
return Math.max(0, Math.min(1, value));
|
|
10590
|
+
}
|
|
10591
|
+
function bounds(shape) {
|
|
10592
|
+
if (![shape.x, shape.y, shape.width, shape.height].every(Number.isFinite) || shape.width <= 0 || shape.height <= 0) {
|
|
10593
|
+
throw new Error("Transfer endpoints require finite positive rectangular bounds");
|
|
10594
|
+
}
|
|
10595
|
+
nonnegative2(shape.radius ?? 0, "Transfer corner radius");
|
|
10596
|
+
}
|
|
10597
|
+
function center(shape) {
|
|
10598
|
+
return { x: shape.x + shape.width / 2, y: shape.y + shape.height / 2 };
|
|
10599
|
+
}
|
|
10600
|
+
function edgeDistance(shape, ux, uy) {
|
|
10601
|
+
const halfWidth = shape.width / 2, halfHeight = shape.height / 2;
|
|
10602
|
+
const limit = Math.min(ux === 0 ? Infinity : halfWidth / Math.abs(ux), uy === 0 ? Infinity : halfHeight / Math.abs(uy));
|
|
10603
|
+
const radius = Math.min(shape.radius ?? 0, halfWidth, halfHeight);
|
|
10604
|
+
if (radius === 0) return limit;
|
|
10605
|
+
const outside = (distance) => Math.hypot(
|
|
10606
|
+
Math.max(0, Math.abs(ux * distance) - (halfWidth - radius)),
|
|
10607
|
+
Math.max(0, Math.abs(uy * distance) - (halfHeight - radius))
|
|
10608
|
+
) > radius;
|
|
10609
|
+
if (!outside(limit)) return limit;
|
|
10610
|
+
let low = 0, high = limit;
|
|
10611
|
+
for (let index = 0; index < 32; index += 1) {
|
|
10612
|
+
const middle = (low + high) / 2;
|
|
10613
|
+
if (outside(middle)) high = middle;
|
|
10614
|
+
else low = middle;
|
|
10615
|
+
}
|
|
10616
|
+
return low;
|
|
10617
|
+
}
|
|
10618
|
+
function safeGap(shape, ux, uy, clearance, edge) {
|
|
10619
|
+
const expanded = Math.min(
|
|
10620
|
+
ux === 0 ? Infinity : (shape.width / 2 + clearance) / Math.abs(ux),
|
|
10621
|
+
uy === 0 ? Infinity : (shape.height / 2 + clearance) / Math.abs(uy)
|
|
10622
|
+
);
|
|
10623
|
+
return expanded - edge;
|
|
10624
|
+
}
|
|
10625
|
+
function createTeachingTransfer(painter) {
|
|
10626
|
+
return (options) => {
|
|
10627
|
+
const { source, target, color = "#63DEEC", width = 3, margin = 2, progress, particle } = options;
|
|
10628
|
+
bounds(source.shape);
|
|
10629
|
+
bounds(target.shape);
|
|
10630
|
+
nonnegative2(width, "Transfer stroke width");
|
|
10631
|
+
if (width === 0) throw new Error("Transfer stroke width must be positive");
|
|
10632
|
+
nonnegative2(margin, "Transfer margin");
|
|
10633
|
+
const opacity = Math.min(alpha(source.opacity), alpha(target.opacity), alpha(options.opacity ?? 1));
|
|
10634
|
+
for (const gap of [options.gap, options.fromGap, options.toGap]) {
|
|
10635
|
+
if (gap !== void 0) nonnegative2(gap, "Transfer gap");
|
|
10636
|
+
}
|
|
10637
|
+
if (progress !== void 0 && !Number.isFinite(progress)) throw new Error("Transfer progress must be finite");
|
|
10638
|
+
if (particle && progress === void 0) throw new Error("Transfer particle requires progress");
|
|
10639
|
+
const radius = particle?.radius ?? 7, strokeWidth = particle?.strokeWidth ?? 3;
|
|
10640
|
+
nonnegative2(radius, "Transfer particle radius");
|
|
10641
|
+
if (radius === 0) throw new Error("Transfer particle radius must be positive");
|
|
10642
|
+
nonnegative2(strokeWidth, "Transfer particle stroke width");
|
|
10643
|
+
if (opacity === 0) return null;
|
|
10644
|
+
const a = center(source.shape), z = center(target.shape);
|
|
10645
|
+
const distance = Math.hypot(z.x - a.x, z.y - a.y);
|
|
10646
|
+
if (!Number.isFinite(distance) || distance === 0) throw new Error("Transfer endpoints must have distinct finite centers");
|
|
10647
|
+
const ux = (z.x - a.x) / distance, uy = (z.y - a.y) / distance;
|
|
10648
|
+
const sourceEdge = edgeDistance(source.shape, ux, uy), targetEdge = edgeDistance(target.shape, ux, uy);
|
|
10649
|
+
const markerRadius = progress === void 0 ? 0 : radius + (particle?.stroke ? strokeWidth / 2 : 0);
|
|
10650
|
+
const clearance = Math.max(width / 2, markerRadius) + margin;
|
|
10651
|
+
const fromGap = Math.max(options.fromGap ?? options.gap ?? 0, safeGap(source.shape, ux, uy, clearance, sourceEdge));
|
|
10652
|
+
const toGap = Math.max(options.toGap ?? options.gap ?? 0, safeGap(target.shape, ux, uy, clearance, targetEdge));
|
|
10653
|
+
if (distance <= sourceEdge + targetEdge + fromGap + toGap) throw new Error("Transfer endpoints leave no room for the requested clearance");
|
|
10654
|
+
let route;
|
|
10655
|
+
painter.opacity(opacity, () => {
|
|
10656
|
+
route = painter.connect(source.shape, target.shape, { color, width, fromGap, toGap });
|
|
10657
|
+
if (progress !== void 0 && progress > 0 && progress < 1) {
|
|
10658
|
+
const x = route.from.x * (1 - progress) + route.to.x * progress;
|
|
10659
|
+
const y = route.from.y * (1 - progress) + route.to.y * progress;
|
|
10660
|
+
painter.circle(x, y, radius, particle?.fill ?? color, particle?.stroke, strokeWidth);
|
|
10661
|
+
}
|
|
10662
|
+
});
|
|
10663
|
+
return route;
|
|
10664
|
+
};
|
|
10665
|
+
}
|
|
10666
|
+
|
|
10667
|
+
// src/teaching-grid.ts
|
|
10668
|
+
function positive2(value, name) {
|
|
10669
|
+
if (!Number.isFinite(value) || value <= 0) throw new Error(`${name} must be finite and positive`);
|
|
10670
|
+
}
|
|
10671
|
+
function layoutCellGrid(options) {
|
|
10672
|
+
const { x, y, width, height, rows, columns } = options;
|
|
10673
|
+
if (![x, y, x + width, y + height].every(Number.isFinite)) throw new Error("Grid bounds must be finite");
|
|
10674
|
+
positive2(width, "Grid width");
|
|
10675
|
+
positive2(height, "Grid height");
|
|
10676
|
+
if (![rows, columns, rows * columns].every(Number.isSafeInteger) || rows <= 0 || columns <= 0) {
|
|
10677
|
+
throw new Error("Grid rows and columns must be positive safe integers");
|
|
10678
|
+
}
|
|
10679
|
+
const bounds2 = { x, y, width, height };
|
|
10680
|
+
const cells = Array.from({ length: rows }, (_, row) => Array.from({ length: columns }, (_2, column) => ({
|
|
10681
|
+
x: x + column * width / columns,
|
|
10682
|
+
y: y + row * height / rows,
|
|
10683
|
+
width: width / columns,
|
|
10684
|
+
height: height / rows
|
|
10685
|
+
})));
|
|
10686
|
+
return {
|
|
10687
|
+
bounds: bounds2,
|
|
10688
|
+
cells,
|
|
10689
|
+
cell(row, column) {
|
|
10690
|
+
if (!Number.isSafeInteger(row) || !Number.isSafeInteger(column) || row < 0 || row >= rows || column < 0 || column >= columns) {
|
|
10691
|
+
throw new Error("Grid cell index is outside the grid");
|
|
10692
|
+
}
|
|
10693
|
+
return cells[row][column];
|
|
10694
|
+
}
|
|
10695
|
+
};
|
|
10696
|
+
}
|
|
10697
|
+
function createTeachingGrid(painter) {
|
|
10698
|
+
const components = createCanvasComponents(painter);
|
|
10699
|
+
return (options) => {
|
|
10700
|
+
const layout = layoutCellGrid(options);
|
|
10701
|
+
const {
|
|
10702
|
+
x,
|
|
10703
|
+
y,
|
|
10704
|
+
width,
|
|
10705
|
+
height,
|
|
10706
|
+
rows,
|
|
10707
|
+
columns,
|
|
10708
|
+
fill = "#18283B",
|
|
10709
|
+
stroke = "#63DEEC",
|
|
10710
|
+
lineWidth = 1,
|
|
10711
|
+
labels,
|
|
10712
|
+
highlights = [],
|
|
10713
|
+
fontSize = 28,
|
|
10714
|
+
textColor = "#FFFFFF",
|
|
10715
|
+
padding = 4
|
|
10716
|
+
} = options;
|
|
10717
|
+
positive2(lineWidth, "Grid line width");
|
|
10718
|
+
if (lineWidth >= Math.min(width / columns, height / rows)) throw new Error("Grid line width must be smaller than a cell");
|
|
10719
|
+
positive2(fontSize, "Grid font size");
|
|
10720
|
+
if (!Number.isFinite(padding) || padding < 0) throw new Error("Grid padding must be finite and nonnegative");
|
|
10721
|
+
if (labels && (labels.length !== rows || labels.some((row) => row.length !== columns))) {
|
|
10722
|
+
throw new Error("Grid labels must match rows and columns");
|
|
10723
|
+
}
|
|
10724
|
+
for (const highlight of highlights) {
|
|
10725
|
+
layout.cell(highlight.row, highlight.column);
|
|
10726
|
+
if (!Number.isFinite(highlight.opacity ?? 1)) throw new Error("Grid highlight opacity must be finite");
|
|
10727
|
+
}
|
|
10728
|
+
const shape = components.panel({ ...layout.bounds, fill, stroke, radius: 0, padding: 0 }, () => {
|
|
10729
|
+
for (const highlight of highlights) {
|
|
10730
|
+
const cell = layout.cell(highlight.row, highlight.column);
|
|
10731
|
+
const inset2 = Math.min(2, cell.width / 4, cell.height / 4);
|
|
10732
|
+
components.fade(highlight.opacity ?? 1, () => {
|
|
10733
|
+
painter.rect(cell.x + inset2, cell.y + inset2, cell.width - 2 * inset2, cell.height - 2 * inset2, highlight.fill, highlight.stroke, 0);
|
|
10734
|
+
});
|
|
10735
|
+
}
|
|
10736
|
+
const inset = lineWidth / 2;
|
|
10737
|
+
for (let column = 1; column < columns; column += 1) {
|
|
10738
|
+
const left = x + column * width / columns;
|
|
10739
|
+
painter.path([{ x: left, y: y + inset }, { x: left, y: y + height - inset }], { color: stroke, width: lineWidth });
|
|
10740
|
+
}
|
|
10741
|
+
for (let row = 1; row < rows; row += 1) {
|
|
10742
|
+
const top = y + row * height / rows;
|
|
10743
|
+
painter.path([{ x: x + inset, y: top }, { x: x + width - inset, y: top }], { color: stroke, width: lineWidth });
|
|
10744
|
+
}
|
|
10745
|
+
labels?.forEach((row, r) => row.forEach((label, column) => {
|
|
10746
|
+
const cell = layout.cell(r, column), value = String(label);
|
|
10747
|
+
const baseline = cell.y + cell.height / 2 + fontSize * 0.34 - (value.split("\n").length - 1) * fontSize * 0.7;
|
|
10748
|
+
painter.labelScope(cell, () => painter.text(value, cell.x + cell.width / 2, baseline, fontSize, textColor, "center"), { padding });
|
|
10749
|
+
}));
|
|
10750
|
+
});
|
|
10751
|
+
return { ...layout, shape };
|
|
10752
|
+
};
|
|
10753
|
+
}
|
|
10754
|
+
|
|
10755
|
+
// src/teaching-timeline.ts
|
|
10756
|
+
function createTeachingTimeline(painter) {
|
|
10757
|
+
return (options) => {
|
|
10758
|
+
const {
|
|
10759
|
+
x,
|
|
10760
|
+
y,
|
|
10761
|
+
width,
|
|
10762
|
+
height,
|
|
10763
|
+
domain: [lo, hi],
|
|
10764
|
+
lanes,
|
|
10765
|
+
intervals,
|
|
10766
|
+
time = hi,
|
|
10767
|
+
ticks = [lo, hi],
|
|
10768
|
+
formatTime = String,
|
|
10769
|
+
labelWidth = 180,
|
|
10770
|
+
laneGap = 18,
|
|
10771
|
+
fontSize = 28,
|
|
10772
|
+
color = "#8D9CB9",
|
|
10773
|
+
trackColor = "#18283B",
|
|
10774
|
+
cursorColor = "#FFCE73"
|
|
10775
|
+
} = options;
|
|
10776
|
+
if (![x, y, x + width, y + height, lo, hi, hi - lo, time, labelWidth, laneGap, fontSize].every(Number.isFinite)) throw new Error("Timeline values must be finite");
|
|
10777
|
+
if (width <= 0 || height <= 0 || hi <= lo || time < lo || time > hi) throw new Error("Timeline needs positive bounds and a current time inside its increasing domain");
|
|
10778
|
+
if (fontSize <= 0 || labelWidth <= 12 || labelWidth >= width - 6 || laneGap < 0 || !lanes.length) throw new Error("Timeline needs positive label space, font size, and at least one lane");
|
|
10779
|
+
const ids = new Set(lanes.map((lane) => lane.id));
|
|
10780
|
+
if (ids.size !== lanes.length || lanes.some((lane) => !lane.id)) throw new Error("Timeline lane IDs must be nonempty and unique");
|
|
10781
|
+
const intervalIds = /* @__PURE__ */ new Set();
|
|
10782
|
+
for (const interval of intervals) {
|
|
10783
|
+
if (!interval.id || intervalIds.has(interval.id) || !ids.has(interval.lane)) throw new Error("Timeline intervals need unique IDs and an existing lane");
|
|
10784
|
+
intervalIds.add(interval.id);
|
|
10785
|
+
if (![interval.start, interval.end, interval.opacity ?? 1].every(Number.isFinite) || interval.start < lo || interval.end > hi || interval.end <= interval.start) throw new Error("Timeline intervals must have finite positive durations inside the domain");
|
|
10786
|
+
}
|
|
10787
|
+
for (const lane of lanes) {
|
|
10788
|
+
const ordered = intervals.filter((interval) => interval.lane === lane.id).sort((a, b) => a.start - b.start);
|
|
10789
|
+
if (ordered.some((interval, i) => i > 0 && interval.start < ordered[i - 1].end)) throw new Error(`Timeline intervals overlap in lane ${lane.id}; use separate lanes for concurrent work`);
|
|
10790
|
+
}
|
|
10791
|
+
if (ticks.some((tick) => !Number.isFinite(tick) || tick < lo || tick > hi)) throw new Error("Timeline ticks must lie inside the domain");
|
|
10792
|
+
const axisHeight = Math.max(36, fontSize * 2 + 18);
|
|
10793
|
+
const laneHeight = (height - axisHeight - (lanes.length - 1) * laneGap) / lanes.length;
|
|
10794
|
+
const labelHeight = fontSize * 1.5, barHeight = laneHeight - labelHeight;
|
|
10795
|
+
if (barHeight < 12) throw new Error("Timeline height cannot fit lane labels and interval bars");
|
|
10796
|
+
const left = x + labelWidth + 3, plotWidth = width - labelWidth - 6;
|
|
10797
|
+
const point = (value) => {
|
|
10798
|
+
if (!Number.isFinite(value) || value < lo || value > hi) throw new Error("Timeline point must lie inside the domain");
|
|
10799
|
+
return left + (value - lo) / (hi - lo) * plotWidth;
|
|
10800
|
+
};
|
|
10801
|
+
const bounds2 = { x, y, width, height };
|
|
10802
|
+
const result = { bounds: bounds2, time, point, lanes: /* @__PURE__ */ Object.create(null), intervals: /* @__PURE__ */ Object.create(null) };
|
|
10803
|
+
painter.container(bounds2, () => {
|
|
10804
|
+
lanes.forEach((lane, index) => {
|
|
10805
|
+
const top = y + index * (laneHeight + laneGap);
|
|
10806
|
+
const track = { x: left - 2, y: top + labelHeight, width: plotWidth + 4, height: barHeight };
|
|
10807
|
+
const shape = painter.rect(track.x, track.y, track.width, track.height, trackColor, color, 0);
|
|
10808
|
+
result.lanes[lane.id] = { shape, bounds: track };
|
|
10809
|
+
painter.labelScope({ x, y: top, width: labelWidth - 12, height: laneHeight }, () => {
|
|
10810
|
+
painter.text(lane.label, x, top + laneHeight / 2 + fontSize * 0.34, fontSize, color, "left");
|
|
10811
|
+
}, { padding: 0 });
|
|
10812
|
+
for (const interval of intervals.filter((item) => item.lane === lane.id)) {
|
|
10813
|
+
const visibleEnd = Math.max(interval.start, Math.min(time, interval.end));
|
|
10814
|
+
const elapsed = visibleEnd - interval.start;
|
|
10815
|
+
const bar = { x: point(interval.start), y: track.y + 2, width: point(visibleEnd) - point(interval.start), height: barHeight - 4 };
|
|
10816
|
+
const opacity = Math.max(0, Math.min(1, interval.opacity ?? 1));
|
|
10817
|
+
const item = { id: interval.id, shape: null, bounds: bar, elapsed, opacity, complete: time >= interval.end };
|
|
10818
|
+
result.intervals[interval.id] = item;
|
|
10819
|
+
if (elapsed === 0 || opacity === 0) continue;
|
|
10820
|
+
painter.opacity(opacity, () => {
|
|
10821
|
+
painter.container(track, () => {
|
|
10822
|
+
item.shape = painter.rect(bar.x, bar.y, bar.width, bar.height, interval.color ?? "#63DEEC", void 0, 0);
|
|
10823
|
+
}, { padding: 0 });
|
|
10824
|
+
if (interval.label) {
|
|
10825
|
+
const labelBounds = { x: point(interval.start), y: top, width: point(interval.end) - point(interval.start), height: labelHeight };
|
|
10826
|
+
painter.labelScope(labelBounds, () => painter.text(interval.label, labelBounds.x + labelBounds.width / 2, top + fontSize, fontSize, interval.color ?? "#63DEEC", "center"), { padding: 2 });
|
|
10827
|
+
}
|
|
10828
|
+
});
|
|
10829
|
+
}
|
|
10830
|
+
});
|
|
10831
|
+
const axisY = y + height - axisHeight + Math.max(10, fontSize * 0.5);
|
|
10832
|
+
painter.line(left, axisY, left + plotWidth, axisY, color, 2);
|
|
10833
|
+
for (const tick of ticks) {
|
|
10834
|
+
const px = point(tick);
|
|
10835
|
+
painter.line(px, axisY, px, axisY + 6, color, 2);
|
|
10836
|
+
painter.labelScope({ x: left - labelWidth, y: axisY + 8, width: plotWidth + labelWidth, height: fontSize * 1.5 }, () => {
|
|
10837
|
+
painter.text(formatTime(tick), px, axisY + fontSize * 1.4, fontSize, color, tick === hi ? "right" : tick === lo ? "left" : "center");
|
|
10838
|
+
}, { padding: 0 });
|
|
10839
|
+
}
|
|
10840
|
+
painter.line(point(time), axisY - 8, point(time), axisY + 8, cursorColor, 3);
|
|
10841
|
+
}, { padding: 0 });
|
|
10842
|
+
return result;
|
|
10843
|
+
};
|
|
10844
|
+
}
|
|
10845
|
+
|
|
10846
|
+
// src/teaching-allocation.ts
|
|
10847
|
+
var COLORS = ["#63DEEC", "#79A6FF", "#D6A0FF", "#FFCE73"];
|
|
10848
|
+
function layoutAllocation(options) {
|
|
10849
|
+
const { x, y, width, height, capacity, parts } = options;
|
|
10850
|
+
if (![x, y, x + width, y + height, capacity].every(Number.isFinite) || width <= 0 || height <= 0 || capacity <= 0) throw new Error("Allocation needs finite positive bounds and capacity");
|
|
10851
|
+
const ids = /* @__PURE__ */ new Set();
|
|
10852
|
+
let used = 0;
|
|
10853
|
+
for (const part of parts) {
|
|
10854
|
+
if (!part.id || ids.has(part.id)) throw new Error("Allocation part IDs must be nonempty and unique");
|
|
10855
|
+
ids.add(part.id);
|
|
10856
|
+
if (!Number.isFinite(part.value) || part.value < 0) throw new Error("Allocation values must be finite and nonnegative");
|
|
10857
|
+
used += part.value;
|
|
10858
|
+
}
|
|
10859
|
+
if (!Number.isFinite(used) || used - capacity > Number.EPSILON * Math.max(used, capacity) * 8) throw new Error("Allocation exceeds capacity");
|
|
10860
|
+
used = Math.min(used, capacity);
|
|
10861
|
+
let offset = 0;
|
|
10862
|
+
const segments = parts.map((part) => {
|
|
10863
|
+
const start = Math.min(offset, capacity);
|
|
10864
|
+
offset += part.value;
|
|
10865
|
+
return { id: part.id, value: part.value, bounds: { x: x + width * (start / capacity), y, width: width * ((Math.min(offset, capacity) - start) / capacity), height } };
|
|
10866
|
+
});
|
|
10867
|
+
const remaining = Math.max(0, capacity - used);
|
|
10868
|
+
return { bounds: { x, y, width, height }, used, remaining, parts: segments, freeBounds: { x: x + width * (used / capacity), y, width: width * (remaining / capacity), height } };
|
|
10869
|
+
}
|
|
10870
|
+
function createTeachingAllocation(painter) {
|
|
10871
|
+
return (options) => {
|
|
10872
|
+
const { x, y, width, height, fontSize = 28, unit = "", format = String, color = "#8D9CB9", trackColor = "#18283B" } = options;
|
|
10873
|
+
if (!Number.isFinite(fontSize) || fontSize <= 0) throw new Error("Allocation font size must be finite and positive");
|
|
10874
|
+
const header = fontSize * 1.7, barHeight = fontSize * 2, rowHeight = fontSize * 1.65, gap = fontSize * 0.6;
|
|
10875
|
+
if (height < header + barHeight + gap + (options.parts.length + 1) * rowHeight || width <= 6 || width * 0.67 <= fontSize) throw new Error("Allocation bounds cannot fit the strip and ledger");
|
|
10876
|
+
const layout = layoutAllocation({ ...options, x: x + 3, y: y + header + 3, width: width - 6, height: barHeight - 6 });
|
|
10877
|
+
const suffix = unit ? ` ${unit}` : "", shapes = [];
|
|
10878
|
+
let shape;
|
|
10879
|
+
painter.container({ x, y, width, height }, () => {
|
|
10880
|
+
painter.labelScope({ x, y, width, height: header }, () => painter.text(`Used ${format(layout.used)} / ${format(options.capacity)}${suffix}`, x, y + fontSize, fontSize, color, "left"), { padding: 0 });
|
|
10881
|
+
const strip = { x: x + 1, y: y + header + 1, width: width - 2, height: barHeight - 2 };
|
|
10882
|
+
shape = painter.rect(strip.x, strip.y, strip.width, strip.height, trackColor, color, 0);
|
|
10883
|
+
painter.container(strip, () => {
|
|
10884
|
+
layout.parts.forEach((part, index) => shapes.push(part.bounds.width === 0 ? null : painter.rect(part.bounds.x, part.bounds.y, part.bounds.width, part.bounds.height, options.parts[index].color ?? COLORS[index % COLORS.length], void 0, 0)));
|
|
10885
|
+
}, { padding: 0 });
|
|
10886
|
+
const rows = [...options.parts, { id: "free", label: "Free", value: layout.remaining, color }];
|
|
10887
|
+
rows.forEach((part, index) => {
|
|
10888
|
+
const top = y + header + barHeight + gap + index * rowHeight, baseline = top + rowHeight / 2 + fontSize * 0.34;
|
|
10889
|
+
painter.rect(x, top + (rowHeight - fontSize * 0.6) / 2, fontSize * 0.6, fontSize * 0.6, part.color ?? COLORS[index % COLORS.length], void 0, 0);
|
|
10890
|
+
painter.labelScope({ x: x + fontSize, y: top, width: width * 0.67 - fontSize, height: rowHeight }, () => painter.text(part.label, x + fontSize, baseline, fontSize, color, "left"), { padding: 0 });
|
|
10891
|
+
painter.labelScope({ x: x + width * 0.7, y: top, width: width * 0.3, height: rowHeight }, () => painter.text(`${format(part.value)}${suffix}`, x + width, baseline, fontSize, color, "right"), { padding: 0 });
|
|
10892
|
+
});
|
|
10893
|
+
}, { padding: 0 });
|
|
10894
|
+
return { ...layout, shapes, shape };
|
|
10895
|
+
};
|
|
10896
|
+
}
|
|
10897
|
+
|
|
10898
|
+
// src/teaching-canvas.ts
|
|
10899
|
+
var INK = "#8D9CB9";
|
|
10900
|
+
var ACCENT = "#63DEEC";
|
|
10901
|
+
var PANEL = "#18283B";
|
|
10902
|
+
function finite2(value, name) {
|
|
10903
|
+
if (!Number.isFinite(value)) throw new Error(`${name} must be finite`);
|
|
10904
|
+
}
|
|
10905
|
+
function positive3(value, name) {
|
|
10906
|
+
finite2(value, name);
|
|
10907
|
+
if (value <= 0) throw new Error(`${name} must be positive`);
|
|
10908
|
+
}
|
|
10909
|
+
function boundsOf(options) {
|
|
10910
|
+
finite2(options.x, "Teaching x");
|
|
10911
|
+
finite2(options.y, "Teaching y");
|
|
10912
|
+
positive3(options.width, "Teaching width");
|
|
10913
|
+
positive3(options.height, "Teaching height");
|
|
10914
|
+
return { x: options.x, y: options.y, width: options.width, height: options.height };
|
|
10915
|
+
}
|
|
10916
|
+
function amount(value, name = "Teaching progress") {
|
|
10917
|
+
finite2(value, name);
|
|
10918
|
+
return Math.max(0, Math.min(1, value));
|
|
10919
|
+
}
|
|
10920
|
+
function domainOf(domain, name) {
|
|
10921
|
+
finite2(domain[0], `${name} start`);
|
|
10922
|
+
finite2(domain[1], `${name} end`);
|
|
10923
|
+
if (domain[1] <= domain[0] || !Number.isFinite(domain[1] - domain[0])) {
|
|
10924
|
+
throw new Error(`${name} must have a finite positive span`);
|
|
10925
|
+
}
|
|
10926
|
+
return [domain[0], domain[1]];
|
|
10927
|
+
}
|
|
10928
|
+
function createTeachingCanvas(painter) {
|
|
10929
|
+
const components = createCanvasComponents(painter);
|
|
10930
|
+
function axes(options) {
|
|
10931
|
+
let bounds2 = boundsOf(options);
|
|
10932
|
+
const xDomain = domainOf(options.xDomain, "Plot x domain");
|
|
10933
|
+
const yDomain = domainOf(options.yDomain, "Plot y domain");
|
|
10934
|
+
if (options.equalUnits) {
|
|
10935
|
+
const xSpan = xDomain[1] - xDomain[0];
|
|
10936
|
+
const ySpan = yDomain[1] - yDomain[0];
|
|
10937
|
+
const pixelsPerUnit = Math.min(bounds2.width / xSpan, bounds2.height / ySpan);
|
|
10938
|
+
const width2 = xSpan * pixelsPerUnit;
|
|
10939
|
+
const height2 = ySpan * pixelsPerUnit;
|
|
10940
|
+
bounds2 = boundsOf({
|
|
10941
|
+
x: bounds2.x + (bounds2.width - width2) / 2,
|
|
10942
|
+
y: bounds2.y + (bounds2.height - height2) / 2,
|
|
10943
|
+
width: width2,
|
|
10944
|
+
height: height2
|
|
10945
|
+
});
|
|
10946
|
+
}
|
|
10947
|
+
const { x, y, width, height } = bounds2;
|
|
10948
|
+
const { color = INK, gridColor, fontSize = 28, xTicks = [], yTicks = [], formatX = String, formatY = String } = options;
|
|
10949
|
+
positive3(fontSize, "Axis font size");
|
|
10950
|
+
xTicks.forEach((tick) => finite2(tick, "Axis x tick"));
|
|
10951
|
+
yTicks.forEach((tick) => finite2(tick, "Axis y tick"));
|
|
10952
|
+
const plot = {
|
|
10953
|
+
bounds: bounds2,
|
|
10954
|
+
xDomain,
|
|
10955
|
+
yDomain,
|
|
10956
|
+
point(px, py) {
|
|
10957
|
+
finite2(px, "Plot point x");
|
|
10958
|
+
finite2(py, "Plot point y");
|
|
10959
|
+
const point = {
|
|
10960
|
+
x: x + (px - xDomain[0]) / (xDomain[1] - xDomain[0]) * width,
|
|
10961
|
+
y: y + height - (py - yDomain[0]) / (yDomain[1] - yDomain[0]) * height
|
|
10962
|
+
};
|
|
10963
|
+
finite2(point.x, "Mapped point x");
|
|
10964
|
+
finite2(point.y, "Mapped point y");
|
|
10965
|
+
return point;
|
|
10966
|
+
}
|
|
10967
|
+
};
|
|
10968
|
+
for (const tick of xTicks) {
|
|
10969
|
+
if (tick < xDomain[0] || tick > xDomain[1]) continue;
|
|
10970
|
+
const point = plot.point(tick, yDomain[0]);
|
|
10971
|
+
if (gridColor) painter.path([{ x: point.x, y }, { x: point.x, y: y + height }], { color: gridColor, width: 1, clip: bounds2 });
|
|
10972
|
+
painter.line(point.x, y + height, point.x, y + height + 7, color, 2);
|
|
10973
|
+
painter.text(formatX(tick), point.x, y + height + 36, fontSize, color, "center");
|
|
10974
|
+
}
|
|
10975
|
+
for (const tick of yTicks) {
|
|
10976
|
+
if (tick < yDomain[0] || tick > yDomain[1]) continue;
|
|
10977
|
+
const point = plot.point(xDomain[0], tick);
|
|
10978
|
+
if (gridColor) painter.path([{ x, y: point.y }, { x: x + width, y: point.y }], { color: gridColor, width: 1, clip: bounds2 });
|
|
10979
|
+
painter.line(x - 7, point.y, x, point.y, color, 2);
|
|
10980
|
+
painter.text(formatY(tick), x - 18, point.y + 9, fontSize, color, "right");
|
|
10981
|
+
}
|
|
10982
|
+
painter.line(x, y + height, x + width, y + height, color, 2);
|
|
10983
|
+
painter.line(x, y, x, y + height, color, 2);
|
|
10984
|
+
if (options.xLabel) painter.text(options.xLabel, x + width / 2, y + height + 72, 30, color, "center");
|
|
10985
|
+
if (options.yLabel) painter.text(options.yLabel, x, y - 26, 30, color, "left");
|
|
10986
|
+
return plot;
|
|
10987
|
+
}
|
|
10988
|
+
function curve(options) {
|
|
10989
|
+
const { plot, points, color, width = 4, progress = 1 } = options;
|
|
10990
|
+
positive3(width, "Curve width");
|
|
10991
|
+
const mapped = points.map((point) => plot.point(point.x, point.y));
|
|
10992
|
+
const visible = tracePolyline(mapped, progress);
|
|
10993
|
+
if (visible.length > 1) painter.path(visible, { color, width, clip: plot.bounds });
|
|
10994
|
+
return visible;
|
|
10995
|
+
}
|
|
10996
|
+
function scatter(options) {
|
|
10997
|
+
const { plot, points, color = ACCENT, radius = 7, opacity = 1 } = options;
|
|
10998
|
+
positive3(radius, "Scatter radius");
|
|
10999
|
+
const alpha2 = amount(opacity, "Scatter opacity");
|
|
11000
|
+
const projected = points.map((point) => {
|
|
11001
|
+
positive3(point.radius ?? radius, "Scatter point radius");
|
|
11002
|
+
return {
|
|
11003
|
+
...plot.point(point.x, point.y),
|
|
11004
|
+
radius: point.radius ?? radius,
|
|
11005
|
+
color: point.color ?? color,
|
|
11006
|
+
inDomain: point.x >= plot.xDomain[0] && point.x <= plot.xDomain[1] && point.y >= plot.yDomain[0] && point.y <= plot.yDomain[1]
|
|
11007
|
+
};
|
|
11008
|
+
});
|
|
11009
|
+
const shapes = [];
|
|
11010
|
+
if (alpha2 === 0) return shapes;
|
|
11011
|
+
painter.opacity(alpha2, () => {
|
|
11012
|
+
for (const point of projected) {
|
|
11013
|
+
if (!point.inDomain) continue;
|
|
11014
|
+
shapes.push(painter.circle(point.x, point.y, point.radius, point.color));
|
|
11015
|
+
}
|
|
11016
|
+
});
|
|
11017
|
+
return shapes;
|
|
11018
|
+
}
|
|
11019
|
+
function bars(options) {
|
|
11020
|
+
const bounds2 = boundsOf(options);
|
|
11021
|
+
const { x, y, width, height } = bounds2;
|
|
11022
|
+
const { values, labels, colors: colors2, color = ACCENT, progress = 1, showValues = false, format = String, fontSize = 28, gap = 20 } = options;
|
|
11023
|
+
positive3(fontSize, "Bar font size");
|
|
11024
|
+
finite2(gap, "Bar gap");
|
|
11025
|
+
if (gap < 0) throw new Error("Bar gap must be nonnegative");
|
|
11026
|
+
values.forEach((value) => {
|
|
11027
|
+
finite2(value, "Bar value");
|
|
11028
|
+
if (value < 0) throw new Error("Bar values must be nonnegative");
|
|
11029
|
+
});
|
|
11030
|
+
if (labels && labels.length !== values.length) throw new Error("Bar labels must match values");
|
|
11031
|
+
if (colors2 && colors2.length !== values.length) throw new Error("Bar colors must match values");
|
|
11032
|
+
const maximumValue = values.reduce((maximum2, value) => Math.max(maximum2, value), 0);
|
|
11033
|
+
const maximum = options.max ?? (maximumValue || 1);
|
|
11034
|
+
positive3(maximum, "Bar maximum");
|
|
11035
|
+
if (maximum < maximumValue) throw new Error("Bar maximum must contain every value");
|
|
11036
|
+
const reveal = amount(progress);
|
|
11037
|
+
if (!values.length) return { bars: [], slots: [], bounds: bounds2 };
|
|
11038
|
+
const barWidth = (width - gap * (values.length - 1)) / values.length;
|
|
11039
|
+
positive3(barWidth, "Bar width after gaps");
|
|
11040
|
+
const shapes = [];
|
|
11041
|
+
const slots = [];
|
|
11042
|
+
values.forEach((value, index) => {
|
|
11043
|
+
const left = x + index * (barWidth + gap);
|
|
11044
|
+
const barHeight = value / maximum * height * reveal;
|
|
11045
|
+
slots.push({ x: left, y, width: barWidth, height });
|
|
11046
|
+
shapes.push(barHeight > 0 ? painter.rect(left, y + height - barHeight, barWidth, barHeight, colors2?.[index] ?? color, void 0, Math.min(8, barWidth / 2, barHeight / 2)) : null);
|
|
11047
|
+
if (labels) painter.text(labels[index], left + barWidth / 2, y + height + 38, fontSize, INK, "center");
|
|
11048
|
+
if (showValues && reveal > 0) painter.text(format(value), left + barWidth / 2, y + height - barHeight - 14, fontSize, colors2?.[index] ?? color, "center");
|
|
11049
|
+
});
|
|
11050
|
+
return { bars: shapes, slots, bounds: bounds2 };
|
|
11051
|
+
}
|
|
11052
|
+
function flowGraph(options) {
|
|
11053
|
+
const { nodes, edges, stroke = ACCENT, fill = PANEL, textColor = "#FFFFFF", padding = 12 } = options;
|
|
11054
|
+
finite2(padding, "Flow node padding");
|
|
11055
|
+
if (padding < 0) throw new Error("Flow node padding must be nonnegative");
|
|
11056
|
+
const descriptors = /* @__PURE__ */ Object.create(null);
|
|
11057
|
+
for (const node of nodes) {
|
|
11058
|
+
if (!node.id || Object.hasOwn(descriptors, node.id)) throw new Error("Flow node IDs must be nonempty and unique");
|
|
11059
|
+
const bounds2 = boundsOf(node);
|
|
11060
|
+
positive3(node.fontSize ?? 30, "Flow node font size");
|
|
11061
|
+
finite2(node.radius ?? 14, "Flow node radius");
|
|
11062
|
+
if ((node.radius ?? 14) < 0) throw new Error("Flow node radius must be nonnegative");
|
|
11063
|
+
descriptors[node.id] = { ...bounds2, radius: node.radius ?? 14 };
|
|
11064
|
+
}
|
|
11065
|
+
for (const edge of edges) {
|
|
11066
|
+
if (!Object.hasOwn(descriptors, edge.from) || !Object.hasOwn(descriptors, edge.to)) throw new Error("Flow edge must reference existing nodes");
|
|
11067
|
+
if (edge.from === edge.to) throw new Error("Flow edges must connect distinct nodes");
|
|
11068
|
+
if (edge.progress !== void 0) amount(edge.progress);
|
|
11069
|
+
if (edge.width !== void 0) positive3(edge.width, "Flow edge width");
|
|
11070
|
+
for (const gap of [edge.gap, edge.fromGap, edge.toGap]) {
|
|
11071
|
+
if (gap !== void 0) finite2(gap, "Flow edge gap");
|
|
11072
|
+
}
|
|
11073
|
+
}
|
|
11074
|
+
const routes = edges.map((edge) => {
|
|
11075
|
+
const { from, to, progress, ...style } = edge;
|
|
11076
|
+
const route = painter.connect(descriptors[from], descriptors[to], { color: stroke, ...style });
|
|
11077
|
+
if (progress !== void 0) components.particle({ points: [route.from, route.to], progress, radius: 7, fill: style.color ?? stroke });
|
|
11078
|
+
return route;
|
|
11079
|
+
});
|
|
11080
|
+
for (const node of nodes) {
|
|
11081
|
+
const shape = components.card({
|
|
11082
|
+
...descriptors[node.id],
|
|
11083
|
+
label: node.label,
|
|
11084
|
+
id: node.id,
|
|
11085
|
+
fill: node.fill ?? fill,
|
|
11086
|
+
stroke: node.color ?? stroke,
|
|
11087
|
+
textColor,
|
|
11088
|
+
fontSize: node.fontSize ?? 30,
|
|
11089
|
+
padding
|
|
11090
|
+
});
|
|
11091
|
+
Object.assign(descriptors[node.id], shape);
|
|
11092
|
+
}
|
|
11093
|
+
return { nodes: descriptors, routes };
|
|
11094
|
+
}
|
|
11095
|
+
return { axes, curve, scatter, bars, flowGraph, transfer: createTeachingTransfer(painter), grid: createTeachingGrid(painter), timeline: createTeachingTimeline(painter), allocation: createTeachingAllocation(painter) };
|
|
11096
|
+
}
|
|
11097
|
+
|
|
11098
|
+
// src/teaching-math.ts
|
|
11099
|
+
function finite3(value, name) {
|
|
11100
|
+
if (!Number.isFinite(value)) throw new Error(`${name} must be finite`);
|
|
11101
|
+
}
|
|
11102
|
+
function finiteValues(values, name) {
|
|
11103
|
+
values.forEach((value) => finite3(value, name));
|
|
11104
|
+
}
|
|
11105
|
+
function seededRandom(seed) {
|
|
11106
|
+
if (!Number.isSafeInteger(seed)) throw new Error("Random seed must be a safe integer");
|
|
11107
|
+
let state = seed >>> 0;
|
|
11108
|
+
return () => {
|
|
11109
|
+
state = state + 1831565813 >>> 0;
|
|
11110
|
+
let value = Math.imul(state ^ state >>> 15, 1 | state);
|
|
11111
|
+
value ^= value + Math.imul(value ^ value >>> 7, 61 | value);
|
|
11112
|
+
return ((value ^ value >>> 14) >>> 0) / 4294967296;
|
|
11113
|
+
};
|
|
11114
|
+
}
|
|
11115
|
+
function lerpArray(from, to, progress) {
|
|
11116
|
+
if (from.length !== to.length) throw new Error("Interpolation vectors must have equal lengths");
|
|
11117
|
+
finite3(progress, "Interpolation progress");
|
|
11118
|
+
finiteValues(from, "Interpolation value");
|
|
11119
|
+
finiteValues(to, "Interpolation value");
|
|
11120
|
+
const result = from.map((value, index) => {
|
|
11121
|
+
const end = to[index];
|
|
11122
|
+
const blended = value * (1 - progress) + end * progress;
|
|
11123
|
+
if (Number.isFinite(blended)) return blended;
|
|
11124
|
+
const scale = Math.max(Math.abs(value), Math.abs(end));
|
|
11125
|
+
return (value / scale + (end / scale - value / scale) * progress) * scale;
|
|
11126
|
+
});
|
|
11127
|
+
finiteValues(result, "Interpolation result");
|
|
11128
|
+
return result;
|
|
11129
|
+
}
|
|
11130
|
+
function dotProduct(left, right) {
|
|
11131
|
+
if (left.length !== right.length) throw new Error("Dot product vectors must have equal lengths");
|
|
11132
|
+
finiteValues(left, "Dot product value");
|
|
11133
|
+
finiteValues(right, "Dot product value");
|
|
11134
|
+
const result = left.reduce((sum, value, index) => sum + value * right[index], 0);
|
|
11135
|
+
finite3(result, "Dot product result");
|
|
11136
|
+
return result;
|
|
11137
|
+
}
|
|
11138
|
+
function matrixWidth(matrix, name) {
|
|
11139
|
+
const width = matrix[0]?.length ?? 0;
|
|
11140
|
+
for (const row of matrix) {
|
|
11141
|
+
if (row.length !== width) throw new Error(`${name} rows must be rectangular`);
|
|
11142
|
+
finiteValues(row, `${name} value`);
|
|
11143
|
+
}
|
|
11144
|
+
return width;
|
|
11145
|
+
}
|
|
11146
|
+
function multiplyMatrices(left, right) {
|
|
11147
|
+
const inner = matrixWidth(left, "Left matrix");
|
|
11148
|
+
const columns = matrixWidth(right, "Right matrix");
|
|
11149
|
+
if (inner !== right.length) throw new Error("Matrix inner dimensions must match");
|
|
11150
|
+
return left.map((row) => Array.from({ length: columns }, (_, column) => {
|
|
11151
|
+
const result = row.reduce((sum, value, index) => sum + value * right[index][column], 0);
|
|
11152
|
+
finite3(result, "Matrix product value");
|
|
11153
|
+
return result;
|
|
11154
|
+
}));
|
|
11155
|
+
}
|
|
11156
|
+
function stableSoftmax(values, temperature = 1) {
|
|
11157
|
+
finite3(temperature, "Softmax temperature");
|
|
11158
|
+
if (temperature <= 0) throw new Error("Softmax temperature must be positive");
|
|
11159
|
+
finiteValues(values, "Softmax logit");
|
|
11160
|
+
if (!values.length) return [];
|
|
11161
|
+
const maximum = values.reduce((largest, value) => Math.max(largest, value), -Infinity);
|
|
11162
|
+
const weights = values.map((value) => Math.exp((value - maximum) / temperature));
|
|
11163
|
+
const total = weights.reduce((sum, value) => sum + value, 0);
|
|
11164
|
+
return weights.map((value) => value / total);
|
|
11165
|
+
}
|
|
11166
|
+
function entropy(probabilities, base = 2) {
|
|
11167
|
+
finite3(base, "Entropy base");
|
|
11168
|
+
if (base <= 0 || base === 1) throw new Error("Entropy base must be positive and different from one");
|
|
11169
|
+
finiteValues(probabilities, "Entropy probability");
|
|
11170
|
+
if (!probabilities.length) return 0;
|
|
11171
|
+
if (probabilities.some((value) => value < 0 || value > 1)) {
|
|
11172
|
+
throw new Error("Entropy probabilities must lie between zero and one");
|
|
11173
|
+
}
|
|
11174
|
+
const total = probabilities.reduce((sum, value) => sum + value, 0);
|
|
11175
|
+
if (Math.abs(total - 1) > 1e-9) throw new Error("Entropy probabilities must sum to one");
|
|
11176
|
+
return -probabilities.reduce((sum, value) => value === 0 ? sum : sum + value * Math.log(value), 0) / Math.log(base);
|
|
11177
|
+
}
|
|
11178
|
+
function normalizeVector(values) {
|
|
11179
|
+
finiteValues(values, "Vector value");
|
|
11180
|
+
const scale = values.reduce((largest, value) => Math.max(largest, Math.abs(value)), 0);
|
|
11181
|
+
if (scale === 0) return values.map(() => 0);
|
|
11182
|
+
const scaled = values.map((value) => value / scale);
|
|
11183
|
+
const length = Math.sqrt(scaled.reduce((sum, value) => sum + value * value, 0));
|
|
11184
|
+
return scaled.map((value) => value / length);
|
|
11185
|
+
}
|
|
11186
|
+
function sampleFunction(fn, low, high, count = 100) {
|
|
11187
|
+
finite3(low, "Sample domain start");
|
|
11188
|
+
finite3(high, "Sample domain end");
|
|
11189
|
+
if (high <= low) throw new Error("Sample domain must increase");
|
|
11190
|
+
if (!Number.isSafeInteger(count) || count < 2) throw new Error("Sample count must be an integer of at least two");
|
|
11191
|
+
return Array.from({ length: count }, (_, index) => {
|
|
11192
|
+
const amount2 = index / (count - 1);
|
|
11193
|
+
const x = low * (1 - amount2) + high * amount2;
|
|
11194
|
+
const y = fn(x);
|
|
11195
|
+
finite3(y, "Sampled function value");
|
|
11196
|
+
return { x, y };
|
|
11197
|
+
});
|
|
11198
|
+
}
|
|
11199
|
+
function gaussian(mean, sigma, x) {
|
|
11200
|
+
finite3(mean, "Gaussian mean");
|
|
11201
|
+
finite3(sigma, "Gaussian standard deviation");
|
|
11202
|
+
finite3(x, "Gaussian x");
|
|
11203
|
+
if (sigma <= 0) throw new Error("Gaussian standard deviation must be positive");
|
|
11204
|
+
const z = (x - mean) / sigma;
|
|
11205
|
+
const density = Math.exp(-0.5 * z * z) / sigma / Math.sqrt(2 * Math.PI);
|
|
11206
|
+
finite3(density, "Gaussian density");
|
|
11207
|
+
return density;
|
|
11208
|
+
}
|
|
11209
|
+
function sampleGaussian(random) {
|
|
11210
|
+
const first = random();
|
|
11211
|
+
const second = random();
|
|
11212
|
+
if (!Number.isFinite(first) || !Number.isFinite(second) || first < 0 || first >= 1 || second < 0 || second >= 1) {
|
|
11213
|
+
throw new Error("Gaussian random draws must lie in [0, 1)");
|
|
11214
|
+
}
|
|
11215
|
+
return Math.sqrt(-2 * Math.log(1 - first)) * Math.cos(2 * Math.PI * second);
|
|
11216
|
+
}
|
|
11217
|
+
|
|
11218
|
+
// src/teaching-cues.ts
|
|
11219
|
+
function position(beat, progress) {
|
|
11220
|
+
if (!Number.isSafeInteger(beat) || beat < 0) throw new Error("Cue beat must be a nonnegative safe integer");
|
|
11221
|
+
if (!Number.isFinite(progress) || progress < 0 || progress > 1) throw new Error("Cue progress must be between zero and one");
|
|
11222
|
+
if (progress === 1) {
|
|
11223
|
+
if (!Number.isSafeInteger(beat + 1)) throw new Error("Cue position exceeds the safe integer range");
|
|
11224
|
+
return { beat: beat + 1, beatP: 0 };
|
|
11225
|
+
}
|
|
11226
|
+
return { beat, beatP: progress };
|
|
11227
|
+
}
|
|
11228
|
+
function compare(left, right) {
|
|
11229
|
+
return left.beat === right.beat ? left.beatP - right.beatP : left.beat - right.beat;
|
|
11230
|
+
}
|
|
11231
|
+
function createCueTrack(options) {
|
|
11232
|
+
const ids = /* @__PURE__ */ new Set();
|
|
11233
|
+
const entry = ({ id, snapshot }) => {
|
|
11234
|
+
if (typeof id !== "string" || !id.trim() || ids.has(id)) throw new Error("Cue IDs must be nonempty and unique");
|
|
11235
|
+
ids.add(id);
|
|
11236
|
+
return Object.freeze({ id, snapshot });
|
|
11237
|
+
};
|
|
11238
|
+
const initial = entry(options.initial);
|
|
11239
|
+
const cues = options.cues.map((cue) => ({ position: position(cue.beat, cue.at), value: entry(cue) }));
|
|
11240
|
+
for (let index = 1; index < cues.length; index += 1) {
|
|
11241
|
+
if (compare(cues[index - 1].position, cues[index].position) >= 0) {
|
|
11242
|
+
throw new Error("Cue positions must be strictly increasing");
|
|
11243
|
+
}
|
|
11244
|
+
}
|
|
11245
|
+
return Object.freeze({
|
|
11246
|
+
sample(current) {
|
|
11247
|
+
const at = position(current.beat, current.beatP);
|
|
11248
|
+
let low = 0, high = cues.length;
|
|
11249
|
+
while (low < high) {
|
|
11250
|
+
const middle = Math.floor((low + high) / 2);
|
|
11251
|
+
if (compare(cues[middle].position, at) <= 0) low = middle + 1;
|
|
11252
|
+
else high = middle;
|
|
11253
|
+
}
|
|
11254
|
+
return low === 0 ? initial : cues[low - 1].value;
|
|
11255
|
+
}
|
|
11256
|
+
});
|
|
11257
|
+
}
|
|
11258
|
+
|
|
11259
|
+
// src/camera-motion.ts
|
|
11260
|
+
function clampProgress3(progress) {
|
|
11261
|
+
if (!Number.isFinite(progress)) throw new Error("Camera progress must be finite");
|
|
11262
|
+
return Math.max(0, Math.min(1, progress));
|
|
11263
|
+
}
|
|
11264
|
+
function assertCamera(camera, context) {
|
|
11265
|
+
if (!Number.isFinite(camera.x) || !Number.isFinite(camera.y)) {
|
|
11266
|
+
throw new Error(`${context} coordinates must be finite`);
|
|
11267
|
+
}
|
|
11268
|
+
if (!Number.isFinite(camera.zoom) || camera.zoom <= 0) {
|
|
11269
|
+
throw new Error(`${context} zoom must be finite and greater than zero`);
|
|
11270
|
+
}
|
|
11271
|
+
}
|
|
11272
|
+
function assertViewport(viewport) {
|
|
11273
|
+
if (!Number.isFinite(viewport.width) || viewport.width <= 0) {
|
|
11274
|
+
throw new Error("Camera viewport width must be finite and greater than zero");
|
|
11275
|
+
}
|
|
11276
|
+
if (!Number.isFinite(viewport.height) || viewport.height <= 0) {
|
|
11277
|
+
throw new Error("Camera viewport height must be finite and greater than zero");
|
|
11278
|
+
}
|
|
11279
|
+
}
|
|
11280
|
+
function assertZoomConstraints(options) {
|
|
11281
|
+
const { minZoom, maxZoom } = options;
|
|
11282
|
+
if (minZoom !== void 0 && (!Number.isFinite(minZoom) || minZoom <= 0)) {
|
|
11283
|
+
throw new Error("Camera minZoom must be finite and greater than zero");
|
|
11284
|
+
}
|
|
11285
|
+
if (maxZoom !== void 0 && (!Number.isFinite(maxZoom) || maxZoom <= 0)) {
|
|
11286
|
+
throw new Error("Camera maxZoom must be finite and greater than zero");
|
|
11287
|
+
}
|
|
11288
|
+
if (minZoom !== void 0 && maxZoom !== void 0 && minZoom > maxZoom) {
|
|
11289
|
+
throw new Error("Camera minZoom cannot exceed maxZoom");
|
|
11290
|
+
}
|
|
11291
|
+
}
|
|
11292
|
+
function assertZoomInRange(camera, options) {
|
|
11293
|
+
if (options.minZoom !== void 0 && camera.zoom < options.minZoom || options.maxZoom !== void 0 && camera.zoom > options.maxZoom) {
|
|
11294
|
+
throw new Error("Camera zoom is outside the configured range");
|
|
11295
|
+
}
|
|
11296
|
+
}
|
|
11297
|
+
function interpolateLinear(from, to, progress) {
|
|
11298
|
+
return from * (1 - progress) + to * progress;
|
|
11299
|
+
}
|
|
11300
|
+
function interpolateCamera(from, to, progress, options = {}) {
|
|
11301
|
+
assertCamera(from, "Camera start");
|
|
11302
|
+
assertCamera(to, "Camera end");
|
|
11303
|
+
assertZoomConstraints(options);
|
|
11304
|
+
assertZoomInRange(from, options);
|
|
11305
|
+
assertZoomInRange(to, options);
|
|
11306
|
+
const amount2 = clampProgress3(progress);
|
|
11307
|
+
if (amount2 === 0) return { ...from };
|
|
11308
|
+
if (amount2 === 1) return { ...to };
|
|
11309
|
+
const eased = (options.easing ?? smoothstep)(amount2);
|
|
11310
|
+
if (!Number.isFinite(eased)) throw new Error("Camera easing must return a finite number");
|
|
11311
|
+
const t = Math.max(0, Math.min(1, eased));
|
|
11312
|
+
if (t === 0) return { ...from };
|
|
11313
|
+
if (t === 1) return { ...to };
|
|
11314
|
+
const camera = {
|
|
11315
|
+
x: interpolateLinear(from.x, to.x, t),
|
|
11316
|
+
y: interpolateLinear(from.y, to.y, t),
|
|
11317
|
+
zoom: Math.exp(Math.log(from.zoom) * (1 - t) + Math.log(to.zoom) * t)
|
|
11318
|
+
};
|
|
11319
|
+
assertCamera(camera, "Camera result");
|
|
11320
|
+
assertZoomInRange(camera, options);
|
|
11321
|
+
return camera;
|
|
11322
|
+
}
|
|
11323
|
+
function cameraSvgTransform(camera, viewport) {
|
|
11324
|
+
assertCamera(camera, "Camera");
|
|
11325
|
+
assertViewport(viewport);
|
|
11326
|
+
return `translate(${viewport.width / 2} ${viewport.height / 2}) scale(${camera.zoom}) translate(${-camera.x} ${-camera.y})`;
|
|
11327
|
+
}
|
|
11328
|
+
function projectWorldPoint(point, camera, viewport) {
|
|
11329
|
+
if (!Number.isFinite(point.x) || !Number.isFinite(point.y)) {
|
|
11330
|
+
throw new Error("World point coordinates must be finite");
|
|
11331
|
+
}
|
|
11332
|
+
assertCamera(camera, "Camera");
|
|
11333
|
+
assertViewport(viewport);
|
|
11334
|
+
const projected = {
|
|
11335
|
+
x: viewport.width / 2 + (point.x - camera.x) * camera.zoom,
|
|
11336
|
+
y: viewport.height / 2 + (point.y - camera.y) * camera.zoom
|
|
11337
|
+
};
|
|
11338
|
+
if (!Number.isFinite(projected.x) || !Number.isFinite(projected.y)) {
|
|
11339
|
+
throw new Error("Projected world point coordinates must be finite");
|
|
11340
|
+
}
|
|
11341
|
+
return projected;
|
|
11342
|
+
}
|
|
11343
|
+
|
|
11344
|
+
// src/path-morph.ts
|
|
11345
|
+
var DEFAULT_MORPH_SAMPLES = 64;
|
|
11346
|
+
var MAX_MORPH_SAMPLES = 4096;
|
|
11347
|
+
function clampProgress4(progress) {
|
|
11348
|
+
if (!Number.isFinite(progress)) throw new Error("Polyline morph progress must be finite");
|
|
11349
|
+
return Math.max(0, Math.min(1, progress));
|
|
11350
|
+
}
|
|
11351
|
+
function validatePolyline(points, context) {
|
|
11352
|
+
if (!Array.isArray(points) || points.length === 0) {
|
|
11353
|
+
throw new Error(`${context} polyline must be a non-empty array`);
|
|
11354
|
+
}
|
|
11355
|
+
for (let index = 0; index < points.length; index += 1) {
|
|
11356
|
+
const point = points[index];
|
|
11357
|
+
if (!point || !Number.isFinite(point.x) || !Number.isFinite(point.y)) {
|
|
11358
|
+
throw new Error(`${context} point ${index} coordinates must be finite`);
|
|
11359
|
+
}
|
|
11360
|
+
}
|
|
11361
|
+
}
|
|
11362
|
+
function validateSamples(samples) {
|
|
11363
|
+
if (!Number.isInteger(samples) || samples < 2) {
|
|
11364
|
+
throw new Error("Polyline morph samples must be an integer of at least 2");
|
|
11365
|
+
}
|
|
11366
|
+
if (samples > MAX_MORPH_SAMPLES) {
|
|
11367
|
+
throw new Error(`Polyline morph samples cannot exceed ${MAX_MORPH_SAMPLES}`);
|
|
11368
|
+
}
|
|
11369
|
+
}
|
|
11370
|
+
function resamplePolyline(points, samples) {
|
|
11371
|
+
const lengths = points.slice(1).map((point, index) => Math.hypot(point.x - points[index].x, point.y - points[index].y));
|
|
11372
|
+
const total = lengths.reduce((sum, length) => sum + length, 0);
|
|
11373
|
+
if (!Number.isFinite(total)) throw new Error("Polyline morph arc length must be finite");
|
|
11374
|
+
if (total === 0) return Array.from({ length: samples }, () => ({ ...points[0] }));
|
|
11375
|
+
let segment = 0;
|
|
11376
|
+
let offset = 0;
|
|
11377
|
+
return Array.from({ length: samples }, (_, index) => {
|
|
11378
|
+
if (index === samples - 1) return { ...points[points.length - 1] };
|
|
11379
|
+
const distance = total * (index / (samples - 1));
|
|
11380
|
+
while (segment < lengths.length - 1 && (lengths[segment] === 0 || distance > offset + lengths[segment])) {
|
|
11381
|
+
offset += lengths[segment++];
|
|
11382
|
+
}
|
|
11383
|
+
const t = (distance - offset) / lengths[segment];
|
|
11384
|
+
const from = points[segment], to = points[segment + 1];
|
|
11385
|
+
return { x: from.x * (1 - t) + to.x * t, y: from.y * (1 - t) + to.y * t };
|
|
11386
|
+
});
|
|
11387
|
+
}
|
|
11388
|
+
function createPolylineMorph(from, to, options = {}) {
|
|
11389
|
+
validatePolyline(from, "Start");
|
|
11390
|
+
validatePolyline(to, "End");
|
|
11391
|
+
const samples = options.samples ?? DEFAULT_MORPH_SAMPLES;
|
|
11392
|
+
validateSamples(samples);
|
|
11393
|
+
const startSamples = resamplePolyline(from, samples);
|
|
11394
|
+
const endSamples = resamplePolyline(to, samples);
|
|
11395
|
+
const easing = options.easing ?? smoothstep;
|
|
11396
|
+
return (progress) => {
|
|
11397
|
+
const amount2 = clampProgress4(progress);
|
|
11398
|
+
const eased = amount2 === 0 || amount2 === 1 ? amount2 : easing(amount2);
|
|
11399
|
+
if (!Number.isFinite(eased)) throw new Error("Polyline morph easing must return a finite number");
|
|
11400
|
+
const t = Math.max(0, Math.min(1, eased));
|
|
11401
|
+
return startSamples.map((start, index) => {
|
|
11402
|
+
const end = endSamples[index];
|
|
11403
|
+
return { x: start.x * (1 - t) + end.x * t, y: start.y * (1 - t) + end.y * t };
|
|
11404
|
+
});
|
|
11405
|
+
};
|
|
11406
|
+
}
|
|
11407
|
+
function morphPolyline(from, to, progress, options = {}) {
|
|
11408
|
+
return createPolylineMorph(from, to, options)(progress);
|
|
11409
|
+
}
|
|
11410
|
+
|
|
11411
|
+
// src/video.ts
|
|
11412
|
+
import { spawn } from "child_process";
|
|
11413
|
+
import { randomUUID } from "crypto";
|
|
11414
|
+
import { mkdir as mkdir3, open, rename, rm, stat } from "fs/promises";
|
|
11415
|
+
import { basename, dirname as dirname3, join as join2, resolve } from "path";
|
|
11416
|
+
import { Resvg as Resvg3 } from "@resvg/resvg-js";
|
|
11417
|
+
import parseCssColor3 from "parse-css-color";
|
|
11418
|
+
var MAX_STDERR_CHARS = 8192;
|
|
11419
|
+
function validateTiming(duration, fps) {
|
|
11420
|
+
if (!Number.isFinite(duration) || duration <= 0) {
|
|
11421
|
+
throw new Error("duration must be a positive finite number");
|
|
11422
|
+
}
|
|
11423
|
+
if (!Number.isInteger(fps) || fps < 1 || fps > 120) {
|
|
11424
|
+
throw new Error("fps must be an integer between 1 and 120");
|
|
11425
|
+
}
|
|
11426
|
+
const count = Math.round(duration * fps / 1e3);
|
|
11427
|
+
if (!Number.isSafeInteger(count) || count < 1) {
|
|
11428
|
+
throw new Error("duration must round to at least one frame and no more than Number.MAX_SAFE_INTEGER frames");
|
|
11429
|
+
}
|
|
11430
|
+
return { count, duration: count * 1e3 / fps };
|
|
11431
|
+
}
|
|
11432
|
+
function frameInfo(index, schedule, fps) {
|
|
11433
|
+
return {
|
|
11434
|
+
index,
|
|
11435
|
+
count: schedule.count,
|
|
11436
|
+
time: index * 1e3 / fps,
|
|
11437
|
+
duration: schedule.duration,
|
|
11438
|
+
progress: index / schedule.count,
|
|
11439
|
+
fps
|
|
11440
|
+
};
|
|
11441
|
+
}
|
|
11442
|
+
function* videoFrameSchedule(duration, fps = 30) {
|
|
11443
|
+
const schedule = validateTiming(duration, fps);
|
|
11444
|
+
for (let index = 0; index < schedule.count; index++) {
|
|
11445
|
+
yield frameInfo(index, schedule, fps);
|
|
11446
|
+
}
|
|
11447
|
+
}
|
|
11448
|
+
async function renderAnimationVideo(animation, options) {
|
|
11449
|
+
const scale = options.scale ?? 1;
|
|
11450
|
+
if (!Number.isFinite(options.width) || options.width <= 0 || !Number.isFinite(options.height) || options.height <= 0) {
|
|
11451
|
+
throw new Error("Animation width and height must be positive finite numbers");
|
|
11452
|
+
}
|
|
11453
|
+
if (!Number.isFinite(scale) || scale <= 0) throw new Error("scale must be a positive finite number");
|
|
11454
|
+
const theme = options.theme ?? "dark";
|
|
11455
|
+
const background = options.background ?? "theme";
|
|
11456
|
+
const backgroundColor = background === "theme" ? getThemeColors(theme).bg : background;
|
|
11457
|
+
const parsedBackground = parseCssColor3(backgroundColor);
|
|
11458
|
+
if (!parsedBackground || parsedBackground.alpha !== 1) {
|
|
11459
|
+
throw new Error('MP4 requires an opaque background; use "theme" or an opaque CSS color');
|
|
11460
|
+
}
|
|
11461
|
+
return renderRgbaVideo(async (info) => {
|
|
11462
|
+
const sampled = sampleAnimationFrame(animation, info.time, {
|
|
11463
|
+
index: info.index,
|
|
11464
|
+
count: info.count,
|
|
11465
|
+
delay: 1e3 / info.fps,
|
|
11466
|
+
fps: info.fps
|
|
11467
|
+
});
|
|
11468
|
+
const edges = { top: false, right: false, bottom: false, left: false };
|
|
11469
|
+
const svg = await renderToSvg(animation.render(sampled.state, sampled.frame), options.width, options.height, {
|
|
11470
|
+
theme,
|
|
11471
|
+
background,
|
|
11472
|
+
watermark: options.watermark ?? options.brand,
|
|
11473
|
+
onNodeDetected: (node) => {
|
|
11474
|
+
edges.top ||= node.top < -0.5;
|
|
11475
|
+
edges.right ||= node.left + node.width > options.width + 0.5;
|
|
11476
|
+
edges.bottom ||= node.top + node.height > options.height + 0.5;
|
|
11477
|
+
edges.left ||= node.left < -0.5;
|
|
11478
|
+
}
|
|
11479
|
+
});
|
|
11480
|
+
const names = Object.keys(edges).filter((edge) => edges[edge]);
|
|
11481
|
+
if (names.length) {
|
|
11482
|
+
const overflow = {
|
|
11483
|
+
overflows: true,
|
|
11484
|
+
edges,
|
|
11485
|
+
message: `Content overflows canvas at: ${names.join(", ")}. Increase the illustration dimensions.`
|
|
11486
|
+
};
|
|
11487
|
+
throw new CanvasOverflowError(options.width, options.height, overflow, {
|
|
11488
|
+
frameIndex: info.index,
|
|
11489
|
+
frameCount: info.count,
|
|
11490
|
+
time: info.time,
|
|
11491
|
+
label: sampled.frame.label
|
|
11492
|
+
});
|
|
11493
|
+
}
|
|
11494
|
+
const rendered = new Resvg3(svg, {
|
|
11495
|
+
fitTo: { mode: "width", value: options.width * scale },
|
|
11496
|
+
background: backgroundColor
|
|
11497
|
+
}).render();
|
|
11498
|
+
if (rendered.width !== options.width * scale || rendered.height !== options.height * scale) {
|
|
11499
|
+
throw new Error("All video frames must match the scaled canvas dimensions");
|
|
11500
|
+
}
|
|
11501
|
+
return rendered.pixels;
|
|
11502
|
+
}, {
|
|
11503
|
+
...options,
|
|
11504
|
+
width: options.width * scale,
|
|
11505
|
+
height: options.height * scale,
|
|
11506
|
+
duration: animation.duration
|
|
11507
|
+
});
|
|
11508
|
+
}
|
|
11509
|
+
function abortError() {
|
|
11510
|
+
const error = new Error("Video export was aborted.");
|
|
11511
|
+
error.name = "AbortError";
|
|
11512
|
+
return error;
|
|
11513
|
+
}
|
|
11514
|
+
function withAbort(promise, signal) {
|
|
11515
|
+
if (!signal) return promise;
|
|
11516
|
+
if (signal.aborted) return Promise.reject(abortError());
|
|
11517
|
+
return new Promise((resolvePromise, rejectPromise) => {
|
|
11518
|
+
const cleanup = () => signal.removeEventListener("abort", onAbort);
|
|
11519
|
+
const onAbort = () => {
|
|
11520
|
+
cleanup();
|
|
11521
|
+
rejectPromise(abortError());
|
|
11522
|
+
};
|
|
11523
|
+
signal.addEventListener("abort", onAbort, { once: true });
|
|
11524
|
+
promise.then(
|
|
11525
|
+
(value) => {
|
|
11526
|
+
cleanup();
|
|
11527
|
+
resolvePromise(value);
|
|
11528
|
+
},
|
|
11529
|
+
(error) => {
|
|
11530
|
+
cleanup();
|
|
11531
|
+
rejectPromise(error);
|
|
11532
|
+
}
|
|
11533
|
+
);
|
|
11534
|
+
});
|
|
11535
|
+
}
|
|
11536
|
+
function formatSeconds(durationMs) {
|
|
11537
|
+
return (durationMs / 1e3).toFixed(12).replace(/0+$/, "").replace(/\.$/, "");
|
|
11538
|
+
}
|
|
11539
|
+
function describeExit(code, signal, stderr) {
|
|
11540
|
+
const status = signal ? `signal ${signal}` : `exit code ${code}`;
|
|
11541
|
+
const detail = stderr.trim();
|
|
11542
|
+
return new Error(`FFmpeg failed (${status})${detail ? `: ${detail}` : ""}`);
|
|
11543
|
+
}
|
|
11544
|
+
async function stopEncoder(child, exited) {
|
|
11545
|
+
if (child.exitCode !== null || child.signalCode !== null) return;
|
|
11546
|
+
child.kill("SIGTERM");
|
|
11547
|
+
let timer;
|
|
11548
|
+
const terminated = await Promise.race([
|
|
11549
|
+
exited.then(() => true),
|
|
11550
|
+
new Promise((resolvePromise) => {
|
|
11551
|
+
timer = setTimeout(() => resolvePromise(false), 1e3);
|
|
11552
|
+
})
|
|
11553
|
+
]);
|
|
11554
|
+
if (timer) clearTimeout(timer);
|
|
11555
|
+
if (!terminated) {
|
|
11556
|
+
child.kill("SIGKILL");
|
|
11557
|
+
await exited;
|
|
11558
|
+
}
|
|
11559
|
+
}
|
|
11560
|
+
async function renderRgbaVideo(renderFrame2, options) {
|
|
11561
|
+
const fps = options.fps ?? 30;
|
|
11562
|
+
const schedule = validateTiming(options.duration, fps);
|
|
11563
|
+
const { width, height } = options;
|
|
11564
|
+
if (!Number.isSafeInteger(width) || width <= 0 || width % 2 !== 0) {
|
|
11565
|
+
throw new Error("width must be a positive even integer");
|
|
11566
|
+
}
|
|
11567
|
+
if (!Number.isSafeInteger(height) || height <= 0 || height % 2 !== 0) {
|
|
11568
|
+
throw new Error("height must be a positive even integer");
|
|
11569
|
+
}
|
|
11570
|
+
const expectedBytes = width * height * 4;
|
|
11571
|
+
if (!Number.isSafeInteger(expectedBytes)) {
|
|
11572
|
+
throw new Error("frame dimensions are too large");
|
|
11573
|
+
}
|
|
11574
|
+
if (typeof renderFrame2 !== "function") throw new Error("renderFrame must be a function");
|
|
11575
|
+
if (typeof options.outputPath !== "string" || options.outputPath.length === 0) {
|
|
11576
|
+
throw new Error("outputPath must be a non-empty path");
|
|
11577
|
+
}
|
|
11578
|
+
const ffmpegPath = options.ffmpegPath ?? "ffmpeg";
|
|
11579
|
+
const preset = options.preset ?? "fast";
|
|
11580
|
+
const crf = options.crf ?? 18;
|
|
11581
|
+
const threads = options.threads ?? 4;
|
|
11582
|
+
if (typeof ffmpegPath !== "string" || ffmpegPath.length === 0) throw new Error("ffmpegPath must be a non-empty path");
|
|
11583
|
+
if (typeof preset !== "string" || preset.length === 0) throw new Error("preset must be a non-empty string");
|
|
11584
|
+
if (!Number.isInteger(crf) || crf < 0 || crf > 51) throw new Error("crf must be an integer between 0 and 51");
|
|
11585
|
+
if (!Number.isSafeInteger(threads) || threads < 1) throw new Error("threads must be a positive safe integer");
|
|
11586
|
+
if (options.audioPath !== void 0 && (typeof options.audioPath !== "string" || options.audioPath.length === 0)) {
|
|
11587
|
+
throw new Error("audioPath must be a non-empty path when provided");
|
|
11588
|
+
}
|
|
11589
|
+
if (options.signal?.aborted) throw abortError();
|
|
11590
|
+
const outputPath = resolve(options.outputPath);
|
|
11591
|
+
const outputDirectory = dirname3(outputPath);
|
|
11592
|
+
await mkdir3(outputDirectory, { recursive: true });
|
|
11593
|
+
const tempPath = join2(outputDirectory, `.${basename(outputPath)}.${randomUUID()}.tmp.mp4`);
|
|
11594
|
+
const tempFile = await open(tempPath, "wx", 384);
|
|
11595
|
+
try {
|
|
11596
|
+
await tempFile.close();
|
|
11597
|
+
} catch (error) {
|
|
11598
|
+
await rm(tempPath, { force: true });
|
|
11599
|
+
throw error;
|
|
11600
|
+
}
|
|
11601
|
+
const seconds = formatSeconds(schedule.duration);
|
|
11602
|
+
const args = [
|
|
11603
|
+
"-hide_banner",
|
|
11604
|
+
"-loglevel",
|
|
11605
|
+
"error",
|
|
11606
|
+
"-nostdin",
|
|
11607
|
+
"-y",
|
|
11608
|
+
"-f",
|
|
11609
|
+
"rawvideo",
|
|
11610
|
+
"-pixel_format",
|
|
11611
|
+
"rgba",
|
|
11612
|
+
"-video_size",
|
|
11613
|
+
`${width}x${height}`,
|
|
11614
|
+
"-framerate",
|
|
11615
|
+
String(fps),
|
|
11616
|
+
"-i",
|
|
11617
|
+
"pipe:0"
|
|
11618
|
+
];
|
|
11619
|
+
if (options.audioPath) args.push("-i", resolve(options.audioPath));
|
|
11620
|
+
args.push("-map", "0:v:0");
|
|
11621
|
+
if (options.audioPath) args.push("-map", "1:a:0", "-af", `asetpts=PTS-STARTPTS,apad,atrim=duration=${seconds}`);
|
|
11622
|
+
args.push(
|
|
11623
|
+
"-frames:v",
|
|
11624
|
+
String(schedule.count),
|
|
11625
|
+
"-t",
|
|
11626
|
+
seconds,
|
|
11627
|
+
"-c:v",
|
|
11628
|
+
"libx264",
|
|
11629
|
+
"-preset",
|
|
11630
|
+
preset,
|
|
11631
|
+
"-crf",
|
|
11632
|
+
String(crf),
|
|
11633
|
+
"-threads:v",
|
|
11634
|
+
String(threads),
|
|
11635
|
+
"-pix_fmt",
|
|
11636
|
+
"yuv420p"
|
|
11637
|
+
);
|
|
11638
|
+
if (options.audioPath) args.push("-c:a", "aac", "-b:a", "192k", "-ar", "48000", "-ac", "2");
|
|
11639
|
+
args.push("-movflags", "+faststart", tempPath);
|
|
11640
|
+
let stderr = "";
|
|
11641
|
+
let inputError;
|
|
11642
|
+
let child;
|
|
11643
|
+
try {
|
|
11644
|
+
child = spawn(ffmpegPath, args, { stdio: ["pipe", "ignore", "pipe"] });
|
|
11645
|
+
} catch (error) {
|
|
11646
|
+
await rm(tempPath, { force: true });
|
|
11647
|
+
throw error;
|
|
11648
|
+
}
|
|
11649
|
+
child.stderr?.on("data", (chunk) => {
|
|
11650
|
+
stderr += chunk.toString();
|
|
11651
|
+
if (stderr.length > MAX_STDERR_CHARS) stderr = stderr.slice(-MAX_STDERR_CHARS);
|
|
11652
|
+
});
|
|
11653
|
+
child.stdin?.on("error", (error) => {
|
|
11654
|
+
inputError = error;
|
|
11655
|
+
});
|
|
11656
|
+
let exitResult;
|
|
11657
|
+
const exited = new Promise((resolvePromise) => {
|
|
11658
|
+
child.once("error", (error) => {
|
|
11659
|
+
exitResult = { code: null, signal: null, error };
|
|
11660
|
+
resolvePromise(exitResult);
|
|
11661
|
+
});
|
|
11662
|
+
child.once("close", (code, signal) => {
|
|
11663
|
+
exitResult = { code, signal };
|
|
11664
|
+
resolvePromise(exitResult);
|
|
11665
|
+
});
|
|
11666
|
+
});
|
|
11667
|
+
function observeEncoder(operation, index, finishAfterSuccess) {
|
|
11668
|
+
const lastFrame = index === schedule.count - 1;
|
|
11669
|
+
const completed = (exit) => {
|
|
11670
|
+
if (!exit.error && exit.code === 0 && lastFrame) {
|
|
11671
|
+
return finishAfterSuccess ? Promise.resolve(void 0) : operation;
|
|
11672
|
+
}
|
|
11673
|
+
if (exit.error) return Promise.reject(new Error(`Unable to start FFmpeg: ${exit.error.message}`, { cause: exit.error }));
|
|
11674
|
+
return Promise.reject(describeExit(exit.code, exit.signal, stderr));
|
|
11675
|
+
};
|
|
11676
|
+
if (exitResult) return completed(exitResult);
|
|
11677
|
+
return new Promise((resolvePromise, rejectPromise) => {
|
|
11678
|
+
const cleanup = () => {
|
|
11679
|
+
child.removeListener("error", onError);
|
|
11680
|
+
child.removeListener("close", onClose);
|
|
11681
|
+
};
|
|
11682
|
+
const onError = (error) => {
|
|
11683
|
+
cleanup();
|
|
11684
|
+
rejectPromise(new Error(`Unable to start FFmpeg: ${error.message}`, { cause: error }));
|
|
11685
|
+
};
|
|
11686
|
+
const onClose = (code, signal) => {
|
|
11687
|
+
cleanup();
|
|
11688
|
+
void completed({ code, signal }).then(resolvePromise, rejectPromise);
|
|
11689
|
+
};
|
|
11690
|
+
child.once("error", onError);
|
|
11691
|
+
child.once("close", onClose);
|
|
11692
|
+
operation.then(
|
|
11693
|
+
(value) => {
|
|
11694
|
+
cleanup();
|
|
11695
|
+
resolvePromise(value);
|
|
11696
|
+
},
|
|
11697
|
+
(error) => {
|
|
11698
|
+
cleanup();
|
|
11699
|
+
rejectPromise(error);
|
|
11700
|
+
}
|
|
11701
|
+
);
|
|
11702
|
+
});
|
|
11703
|
+
}
|
|
11704
|
+
try {
|
|
11705
|
+
const input = child.stdin;
|
|
11706
|
+
if (!input) throw new Error("FFmpeg did not provide a frame input stream");
|
|
11707
|
+
for (let index = 0; index < schedule.count; index++) {
|
|
11708
|
+
const info = frameInfo(index, schedule, fps);
|
|
11709
|
+
const rendered = await withAbort(observeEncoder(Promise.resolve(renderFrame2(info)), index, false), options.signal);
|
|
11710
|
+
if (!(rendered instanceof Uint8Array) || rendered.byteLength !== expectedBytes) {
|
|
11711
|
+
throw new Error(`Frame ${index} must contain exactly ${expectedBytes} RGBA bytes`);
|
|
11712
|
+
}
|
|
11713
|
+
if (inputError) throw describeExit(null, null, inputError.message || stderr);
|
|
11714
|
+
const pixels = Buffer.from(rendered.buffer, rendered.byteOffset, rendered.byteLength);
|
|
11715
|
+
const write = new Promise((resolvePromise, rejectPromise) => {
|
|
11716
|
+
input.write(pixels, (error) => error ? rejectPromise(error) : resolvePromise());
|
|
11717
|
+
});
|
|
11718
|
+
await withAbort(observeEncoder(write, index, true), options.signal);
|
|
11719
|
+
if (options.onProgress) {
|
|
11720
|
+
await withAbort(observeEncoder(Promise.resolve(options.onProgress(info)), index, false), options.signal);
|
|
11721
|
+
}
|
|
11722
|
+
}
|
|
11723
|
+
input.end();
|
|
11724
|
+
const exit = await withAbort(exited, options.signal);
|
|
11725
|
+
if (exit.error) throw new Error(`Unable to start FFmpeg: ${exit.error.message}`, { cause: exit.error });
|
|
11726
|
+
if (exit.code !== 0) throw describeExit(exit.code, exit.signal, stderr);
|
|
11727
|
+
const outputStat = await stat(tempPath);
|
|
11728
|
+
await rename(tempPath, outputPath);
|
|
11729
|
+
return {
|
|
11730
|
+
width,
|
|
11731
|
+
height,
|
|
11732
|
+
frameCount: schedule.count,
|
|
11733
|
+
duration: schedule.duration,
|
|
11734
|
+
fps,
|
|
11735
|
+
bytes: outputStat.size,
|
|
11736
|
+
outputPath,
|
|
11737
|
+
audioIncluded: options.audioPath !== void 0
|
|
11738
|
+
};
|
|
11739
|
+
} catch (error) {
|
|
11740
|
+
await stopEncoder(child, exited);
|
|
11741
|
+
if (inputError && error instanceof Error && (error.message === "write EPIPE" || error.code === "EPIPE")) {
|
|
11742
|
+
throw describeExit(null, null, stderr || inputError.message);
|
|
11743
|
+
}
|
|
11744
|
+
throw error;
|
|
11745
|
+
} finally {
|
|
11746
|
+
await rm(tempPath, { force: true });
|
|
11747
|
+
}
|
|
11748
|
+
}
|
|
11749
|
+
|
|
11750
|
+
// src/scene-renderer.ts
|
|
11751
|
+
import React15 from "react";
|
|
11752
|
+
import { readFile as readFile2, mkdir as mkdir4, open as open2, rename as rename2, rm as rm2 } from "fs/promises";
|
|
11753
|
+
import { createReadStream } from "fs";
|
|
11754
|
+
import { dirname as dirname4, join as join3, resolve as resolve2 } from "path";
|
|
11755
|
+
import { fileURLToPath as fileURLToPath2 } from "url";
|
|
11756
|
+
import { createHash, randomUUID as randomUUID2 } from "crypto";
|
|
11757
|
+
import { brotliDecompressSync as brotliDecompressSync2 } from "zlib";
|
|
11758
|
+
import { Resvg as Resvg4 } from "@resvg/resvg-js";
|
|
11759
|
+
function outputSettings(prepared, outputScale = 1, previewFps) {
|
|
11760
|
+
if (!Number.isFinite(outputScale) || outputScale < 0.25 || outputScale > 1) {
|
|
11761
|
+
throw new Error("Scene outputScale must be from 0.25 to 1.");
|
|
11762
|
+
}
|
|
11763
|
+
const { width: logicalWidth, height: logicalHeight, fps: logicalFps, duration } = prepared.request;
|
|
11764
|
+
const width = logicalWidth * outputScale, height = logicalHeight * outputScale;
|
|
11765
|
+
if (![width, height].every((value) => Number.isInteger(value) && value >= 2 && value % 2 === 0)) {
|
|
11766
|
+
throw new Error("Scaled scene width and height must be positive even integers.");
|
|
11767
|
+
}
|
|
11768
|
+
const fps = previewFps === void 0 ? logicalFps : previewFps;
|
|
11769
|
+
if (!Number.isInteger(fps) || fps < 1 || fps > logicalFps) {
|
|
11770
|
+
throw new Error("Scene previewFps must be an integer from 1 to the logical scene fps.");
|
|
11771
|
+
}
|
|
11772
|
+
const frameCount = Math.round(duration * fps);
|
|
11773
|
+
if (frameCount < 1) throw new Error("Scene preview duration must round to at least one output frame.");
|
|
11774
|
+
return { width, height, fps, frameCount, outputScale, preview: outputScale !== 1 || fps !== logicalFps };
|
|
11775
|
+
}
|
|
11776
|
+
var assetPins = {
|
|
11777
|
+
"fonts/Inter-Regular.ttf": "1b08e7fc267a5c7e1d614100f604b83e7e8a0be241f0f288faa2b3ac93a683ba",
|
|
11778
|
+
"fonts/Inter-SemiBold.ttf": "e7a1aaf7eda9f2fad4131725fa556265ec75ca7b2d756260173a040363e8d4f7",
|
|
11779
|
+
"fonts/Inter-Bold.ttf": "b37284b5701b6b168dfc770aa1a4ac492106422fd3ba76bc7641e37434e8019c",
|
|
11780
|
+
"fonts/JetBrainsMono-Regular.ttf": "44ce4a84f20d60f24539bd0cef11f79c29e38609e0f8adf18551c9794a5d9dc3",
|
|
11781
|
+
"fonts/NotoSans-Regular.ttf": "5be701a9511117e73603bdab95947feef4f18bd1851dbddc30659370b26c69f1",
|
|
11782
|
+
"fonts/NotoSansMath-Regular.ttf": "3cbaf44af13f592bc7f7172a50edab4c73ac2f3d19af2d697a01ebd3288e322d",
|
|
11783
|
+
"emoji.json.br": "4911e822be2ed684fe811cadf036139e3efe353ffe2990311e1763f38ae7daab"
|
|
11784
|
+
};
|
|
11785
|
+
var assetsPromise;
|
|
11786
|
+
async function sceneAssets() {
|
|
11787
|
+
assetsPromise ??= loadSceneAssets().catch((error) => {
|
|
11788
|
+
assetsPromise = void 0;
|
|
11789
|
+
throw error;
|
|
11790
|
+
});
|
|
11791
|
+
return assetsPromise;
|
|
11792
|
+
}
|
|
11793
|
+
async function loadSceneAssets() {
|
|
11794
|
+
const moduleDir = typeof __dirname !== "undefined" ? __dirname : dirname4(fileURLToPath2(import.meta.url));
|
|
11795
|
+
const assetDir = join3(moduleDir, "..", "assets");
|
|
11796
|
+
const files = /* @__PURE__ */ new Map();
|
|
11797
|
+
for (const [name, expected] of Object.entries(assetPins)) {
|
|
11798
|
+
const bytes = await readFile2(join3(assetDir, name));
|
|
11799
|
+
if (await sceneSha256(bytes) !== expected) throw new Error(`Pinned scene asset does not match: ${name}`);
|
|
11800
|
+
files.set(name, bytes);
|
|
11801
|
+
}
|
|
11802
|
+
const fontDefinitions = [
|
|
11803
|
+
["Inter", "Inter-Regular.ttf", 400],
|
|
11804
|
+
["Inter", "Inter-SemiBold.ttf", 600],
|
|
11805
|
+
["Inter", "Inter-Bold.ttf", 700],
|
|
11806
|
+
["JetBrains Mono", "JetBrainsMono-Regular.ttf", 400],
|
|
11807
|
+
["Noto Sans", "NotoSans-Regular.ttf", 400],
|
|
11808
|
+
["Noto Sans Math", "NotoSansMath-Regular.ttf", 400]
|
|
11809
|
+
];
|
|
11810
|
+
return {
|
|
11811
|
+
fonts: fontDefinitions.map(([name, filename, weight]) => ({
|
|
11812
|
+
name,
|
|
11813
|
+
weight,
|
|
11814
|
+
style: "normal",
|
|
11815
|
+
data: Uint8Array.from(files.get(`fonts/${filename}`)).buffer
|
|
11816
|
+
})),
|
|
11817
|
+
fontFiles: fontDefinitions.map(([, filename]) => join3(assetDir, "fonts", filename)),
|
|
11818
|
+
emoji: JSON.parse(brotliDecompressSync2(files.get("emoji.json.br")).toString("utf8")),
|
|
11819
|
+
sha256: await sceneSha256(JSON.stringify(assetPins))
|
|
11820
|
+
};
|
|
11821
|
+
}
|
|
11822
|
+
var trustedComponents = Object.fromEntries(SCENE_COMPONENT_NAMES.map((name) => [name, primitives_exports[name]]));
|
|
11823
|
+
var svgTags = new Set(SCENE_DOM_TAGS.filter((name) => !["div", "span", "p", "strong", "em", "b", "i", "br"].includes(name)));
|
|
11824
|
+
function isElement(value) {
|
|
11825
|
+
return Boolean(value && !Array.isArray(value) && typeof value === "object" && value.kind === "vizmatic.element");
|
|
11826
|
+
}
|
|
11827
|
+
var xml = (value) => String(value).replace(/[&<>"']/g, (character) => ({
|
|
11828
|
+
"&": "&",
|
|
11829
|
+
"<": "<",
|
|
11830
|
+
">": ">",
|
|
11831
|
+
'"': """,
|
|
11832
|
+
"'": "'"
|
|
11833
|
+
})[character]);
|
|
11834
|
+
function svgAttribute(name) {
|
|
11835
|
+
if (name === "className") return "class";
|
|
11836
|
+
if (name === "xlinkHref") return "href";
|
|
11837
|
+
if (/^(?:viewBox|preserveAspectRatio|gradientUnits|gradientTransform|patternUnits|patternContentUnits|patternTransform|markerWidth|markerHeight|markerUnits|refX|refY|textLength|lengthAdjust|clipPathUnits)$/.test(name)) return name;
|
|
11838
|
+
return name.replace(/[A-Z]/g, (character) => `-${character.toLowerCase()}`);
|
|
11839
|
+
}
|
|
11840
|
+
function serializeSvg(node, budget, depth = 0) {
|
|
11841
|
+
if (++budget.nodes > SCENE_LIMITS.nodes * 16) throw new Error("Resolved scene exceeds its host element budget.");
|
|
11842
|
+
if (depth > SCENE_LIMITS.depth * 2) throw new Error("Resolved SVG exceeds its depth limit.");
|
|
11843
|
+
const emit = (chunk) => {
|
|
11844
|
+
budget.svgBytes += Buffer.byteLength(chunk);
|
|
11845
|
+
if (budget.svgBytes > SCENE_LIMITS.graphBytes * 4) throw new Error("Resolved SVG exceeds its serialized byte budget.");
|
|
11846
|
+
return chunk;
|
|
11847
|
+
};
|
|
11848
|
+
if (node === null || node === void 0 || typeof node === "boolean") return "";
|
|
11849
|
+
if (typeof node === "string" || typeof node === "number") return emit(xml(node));
|
|
11850
|
+
if (Array.isArray(node)) return node.map((child) => serializeSvg(child, budget, depth + 1)).join("");
|
|
11851
|
+
if (!React15.isValidElement(node)) throw new Error("Invalid resolved SVG child.");
|
|
11852
|
+
if (node.type === React15.Fragment) return serializeSvg(node.props.children, budget, depth + 1);
|
|
11853
|
+
if (node.type === SvgMathText) {
|
|
11854
|
+
const { text, x, y, fill, fontSize = 13, fontFamily = "JetBrains Mono", fontWeight = 700, textAnchor = "middle", dominantBaseline = "middle", opacity = 1 } = node.props;
|
|
11855
|
+
return serializeSvg(React15.createElement("text", { x, y, fill, fontSize, fontFamily, fontWeight, textAnchor, dominantBaseline, opacity }, String(text)), budget, depth + 1);
|
|
11856
|
+
}
|
|
11857
|
+
if (typeof node.type === "function") {
|
|
11858
|
+
return serializeSvg(node.type(node.props), budget, depth + 1);
|
|
11859
|
+
}
|
|
11860
|
+
if (typeof node.type !== "string" || !svgTags.has(node.type)) throw new Error("Only SVG components may be placed inside an SVG scene.");
|
|
11861
|
+
validateResolvedSceneResources(node.props);
|
|
11862
|
+
const attributes = Object.entries(node.props).filter(([key, value]) => key !== "children" && key !== "key" && value !== void 0 && value !== null).map(([key, value]) => {
|
|
11863
|
+
if (key === "style" && typeof value === "object") {
|
|
11864
|
+
const style = Object.entries(value).map(([property, item]) => `${svgAttribute(property)}:${String(item)}`).join(";");
|
|
11865
|
+
return ` style="${xml(style)}"`;
|
|
11866
|
+
}
|
|
11867
|
+
if (!/^[A-Za-z_][\w:.-]*$/.test(key) || typeof value === "object" || typeof value === "function") throw new Error("Unsupported SVG attribute.");
|
|
11868
|
+
return ` ${svgAttribute(key)}="${xml(String(value))}"`;
|
|
11869
|
+
}).join("");
|
|
11870
|
+
return emit(`<${node.type}${attributes}>`) + serializeSvg(node.props.children, budget, depth + 1) + emit(`</${node.type}>`);
|
|
11871
|
+
}
|
|
11872
|
+
function graphToReact(value, theme) {
|
|
11873
|
+
if (Array.isArray(value)) return value.map((child) => graphToReact(child, theme));
|
|
11874
|
+
if (!isElement(value)) return value;
|
|
11875
|
+
const convertProp = (prop) => {
|
|
11876
|
+
if (isElement(prop)) return graphToReact(prop, theme);
|
|
11877
|
+
if (Array.isArray(prop)) return prop.map(convertProp);
|
|
11878
|
+
if (prop && typeof prop === "object") return Object.fromEntries(Object.entries(prop).map(([key, item]) => [key, convertProp(item)]));
|
|
11879
|
+
return prop;
|
|
11880
|
+
};
|
|
11881
|
+
const props = Object.fromEntries(Object.entries(value.props).map(([name, prop]) => [name, convertProp(prop)]));
|
|
11882
|
+
const component = trustedComponents[value.type];
|
|
11883
|
+
if (component) props.c ??= theme;
|
|
11884
|
+
return React15.createElement(component ?? value.type, props, ...value.children.map((child) => graphToReact(child, theme)));
|
|
11885
|
+
}
|
|
11886
|
+
function renderSvgImage(element, assets, width, height, budget, outputScale = 1, includePng = true) {
|
|
11887
|
+
const root = React15.cloneElement(element, { xmlns: "http://www.w3.org/2000/svg", width, height });
|
|
11888
|
+
const svg = serializeSvg(root, budget);
|
|
11889
|
+
const image = new Resvg4(svg, {
|
|
11890
|
+
font: { loadSystemFonts: false, fontFiles: assets.fontFiles, defaultFontFamily: "Inter" },
|
|
11891
|
+
background: "rgba(0,0,0,0)",
|
|
11892
|
+
...outputScale !== 1 ? { fitTo: { mode: "width", value: width * outputScale } } : {}
|
|
11893
|
+
}).render();
|
|
11894
|
+
if (image.width !== width * outputScale || image.height !== height * outputScale) throw new Error("SVG frame does not match scaled scene dimensions.");
|
|
11895
|
+
return { pixels: image.pixels, ...includePng ? { png: image.asPng() } : {} };
|
|
11896
|
+
}
|
|
11897
|
+
function rasterizeNestedSvg(node, assets, defaultWidth, defaultHeight, budget) {
|
|
11898
|
+
if (++budget.nodes > SCENE_LIMITS.nodes * 16) throw new Error("Resolved scene exceeds its host element budget.");
|
|
11899
|
+
if (Array.isArray(node)) return node.map((child) => rasterizeNestedSvg(child, assets, defaultWidth, defaultHeight, budget));
|
|
11900
|
+
if (!React15.isValidElement(node)) return node;
|
|
11901
|
+
if (node.type === "svg") {
|
|
11902
|
+
const width = typeof node.props.width === "number" ? node.props.width : defaultWidth;
|
|
11903
|
+
const height = typeof node.props.height === "number" ? node.props.height : defaultHeight;
|
|
11904
|
+
if (!Number.isInteger(width) || !Number.isInteger(height) || width < 1 || height < 1 || width > SCENE_LIMITS.canvasEdge || height > SCENE_LIMITS.canvasEdge || width * height > SCENE_LIMITS.canvasPixels) {
|
|
11905
|
+
throw new Error("Nested SVG dimensions exceed the scene canvas limits.");
|
|
11906
|
+
}
|
|
11907
|
+
budget.pixels += width * height;
|
|
11908
|
+
budget.count += 1;
|
|
11909
|
+
if (budget.pixels > defaultWidth * defaultHeight * 4 || budget.count > 16) {
|
|
11910
|
+
throw new Error("Nested SVG rasterization exceeds the per-frame pixel or image budget.");
|
|
11911
|
+
}
|
|
11912
|
+
const { png } = renderSvgImage(node, assets, width, height, budget);
|
|
11913
|
+
return React15.createElement("img", {
|
|
11914
|
+
width,
|
|
11915
|
+
height,
|
|
11916
|
+
src: `data:image/png;base64,${Buffer.from(png).toString("base64")}`,
|
|
11917
|
+
style: { display: "flex", flexShrink: 0, ...node.props.style }
|
|
11918
|
+
});
|
|
11919
|
+
}
|
|
11920
|
+
if (typeof node.type === "function") return rasterizeNestedSvg(node.type(node.props), assets, defaultWidth, defaultHeight, budget);
|
|
11921
|
+
validateResolvedSceneResources(node.props);
|
|
11922
|
+
return React15.cloneElement(node, {}, rasterizeNestedSvg(node.props.children, assets, defaultWidth, defaultHeight, budget));
|
|
11923
|
+
}
|
|
11924
|
+
async function renderPreparedFrame(prepared, assets, time, outputScale, includePng) {
|
|
11925
|
+
const evaluated = await prepared.evaluate(time);
|
|
11926
|
+
const { width, height, theme } = prepared.request;
|
|
11927
|
+
const c = getThemeColors(theme);
|
|
11928
|
+
let element = graphToReact(evaluated.graph, c);
|
|
11929
|
+
if (React15.isValidElement(element) && element.type === "svg") {
|
|
11930
|
+
const image = renderSvgImage(React15.cloneElement(element, {
|
|
11931
|
+
children: [React15.createElement("rect", { key: "__scene_background", width, height, fill: c.bg }), element.props.children]
|
|
11932
|
+
}), assets, width, height, { pixels: 0, count: 0, nodes: 0, svgBytes: 0 }, outputScale, includePng);
|
|
11933
|
+
return image;
|
|
11934
|
+
}
|
|
11935
|
+
element = React15.createElement("div", { style: { display: "flex", position: "relative", width, height, backgroundColor: c.bg, fontFamily: "Inter", color: c.textPrimary } }, element);
|
|
11936
|
+
return withRenderContext({ background: "theme" }, async () => {
|
|
11937
|
+
element = rasterizeNestedSvg(element, assets, width, height, { pixels: 0, count: 0, nodes: 0, svgBytes: 0 });
|
|
11938
|
+
const accessible = prepareAccessibleSvg(element);
|
|
11939
|
+
const layoutNodes = [];
|
|
11940
|
+
const rendered = await satori(accessible.element, {
|
|
11941
|
+
width,
|
|
11942
|
+
height,
|
|
11943
|
+
fonts: assets.fonts,
|
|
11944
|
+
loadAdditionalAsset: async (code, segment) => {
|
|
11945
|
+
if (code !== "emoji") return [];
|
|
11946
|
+
const points = [...segment].map((character) => character.codePointAt(0).toString(16));
|
|
11947
|
+
const candidates = [points.join("-"), points.filter((point) => point !== "fe0f").join("-")];
|
|
11948
|
+
const svg2 = candidates.map((name) => assets.emoji[`${name}.svg`]).find(Boolean);
|
|
11949
|
+
if (!svg2) throw new Error("A scene glyph is not available in the pinned offline font and emoji assets.");
|
|
11950
|
+
return `data:image/svg+xml;base64,${Buffer.from(svg2).toString("base64")}`;
|
|
11951
|
+
},
|
|
11952
|
+
onNodeDetected: (node) => layoutNodes.push(node)
|
|
11953
|
+
});
|
|
11954
|
+
const svg = addSvgAccessibility(rendered, accessible.graphs, layoutNodes);
|
|
11955
|
+
const image = new Resvg4(svg, {
|
|
11956
|
+
background: c.bg,
|
|
11957
|
+
font: { loadSystemFonts: false, fontFiles: assets.fontFiles },
|
|
11958
|
+
...outputScale !== 1 ? { fitTo: { mode: "width", value: width * outputScale } } : {}
|
|
11959
|
+
}).render();
|
|
11960
|
+
if (image.width !== width * outputScale || image.height !== height * outputScale) throw new Error("Layout frame does not match scaled scene dimensions.");
|
|
11961
|
+
return { pixels: image.pixels, ...includePng ? { png: image.asPng() } : {} };
|
|
11962
|
+
});
|
|
11963
|
+
}
|
|
11964
|
+
async function outputMetadata(prepared, assets, settings, outputPath, bytes, kind, time) {
|
|
11965
|
+
const { width, height, duration, fps, frameCount } = prepared.request;
|
|
11966
|
+
const digest = createHash("sha256");
|
|
11967
|
+
for await (const chunk of createReadStream(outputPath)) digest.update(chunk);
|
|
11968
|
+
return {
|
|
11969
|
+
runtimeVersion: SCENE_RUNTIME_VERSION,
|
|
11970
|
+
sourceSha256: prepared.sourceSha256,
|
|
11971
|
+
inputSha256: await sceneSha256(JSON.stringify({
|
|
11972
|
+
requestSha256: prepared.inputSha256,
|
|
11973
|
+
fontAssetsSha256: assets.sha256,
|
|
11974
|
+
kind,
|
|
11975
|
+
...time !== void 0 ? { time } : {},
|
|
11976
|
+
...settings.preview ? { outputScale: settings.outputScale, width: settings.width, height: settings.height, fps: settings.fps, frameCount: settings.frameCount } : {}
|
|
11977
|
+
})),
|
|
11978
|
+
assetSha256: digest.digest("hex"),
|
|
11979
|
+
fontAssetsSha256: assets.sha256,
|
|
11980
|
+
width: settings.width,
|
|
11981
|
+
height: settings.height,
|
|
11982
|
+
duration,
|
|
11983
|
+
fps: settings.fps,
|
|
11984
|
+
frameCount: settings.frameCount,
|
|
11985
|
+
bytes,
|
|
11986
|
+
outputPath: resolve2(outputPath),
|
|
11987
|
+
...settings.preview ? {
|
|
11988
|
+
outputScale: settings.outputScale,
|
|
11989
|
+
...kind === "mp4" ? { previewFps: settings.fps } : {},
|
|
11990
|
+
logicalWidth: width,
|
|
11991
|
+
logicalHeight: height,
|
|
11992
|
+
logicalFps: fps,
|
|
11993
|
+
logicalFrameCount: frameCount
|
|
11994
|
+
} : {}
|
|
11995
|
+
};
|
|
11996
|
+
}
|
|
11997
|
+
async function atomicWrite(outputPath, bytes) {
|
|
11998
|
+
const target = resolve2(outputPath);
|
|
11999
|
+
await mkdir4(dirname4(target), { recursive: true });
|
|
12000
|
+
const temporary = join3(dirname4(target), `.vizmatic-scene-${randomUUID2()}.tmp`);
|
|
12001
|
+
const file = await open2(temporary, "wx", 384);
|
|
12002
|
+
try {
|
|
12003
|
+
await file.writeFile(bytes);
|
|
12004
|
+
await file.close();
|
|
12005
|
+
await rename2(temporary, target);
|
|
12006
|
+
} catch (error) {
|
|
12007
|
+
await file.close().catch(() => {
|
|
12008
|
+
});
|
|
12009
|
+
await rm2(temporary, { force: true });
|
|
12010
|
+
throw error;
|
|
12011
|
+
}
|
|
12012
|
+
}
|
|
12013
|
+
async function renderSceneFrame(options) {
|
|
12014
|
+
if (typeof options.outputPath !== "string" || !options.outputPath) throw new Error("Scene outputPath is required.");
|
|
12015
|
+
const prepared = await prepareScene(options);
|
|
12016
|
+
const settings = outputSettings(prepared, options.outputScale);
|
|
12017
|
+
const time = normalizeSceneTime(options.time, prepared.request.duration);
|
|
12018
|
+
const assets = await sceneAssets();
|
|
12019
|
+
const image = await renderPreparedFrame(prepared, assets, time, settings.outputScale, true);
|
|
12020
|
+
await atomicWrite(options.outputPath, image.png);
|
|
12021
|
+
return { ...await outputMetadata(prepared, assets, settings, options.outputPath, image.png.byteLength, "png", time), time };
|
|
12022
|
+
}
|
|
12023
|
+
async function renderSceneVideo(options) {
|
|
12024
|
+
if (typeof options.outputPath !== "string" || !options.outputPath) throw new Error("Scene outputPath is required.");
|
|
12025
|
+
const prepared = await prepareScene(options);
|
|
12026
|
+
const settings = outputSettings(prepared, options.outputScale, options.previewFps);
|
|
12027
|
+
const assets = await sceneAssets();
|
|
12028
|
+
const { duration } = prepared.request;
|
|
12029
|
+
const output = await renderRgbaVideo(async (frame) => (await renderPreparedFrame(prepared, assets, frame.time / 1e3, settings.outputScale, false)).pixels, {
|
|
12030
|
+
width: settings.width,
|
|
12031
|
+
height: settings.height,
|
|
12032
|
+
duration: duration * 1e3,
|
|
12033
|
+
fps: settings.fps,
|
|
12034
|
+
outputPath: options.outputPath,
|
|
12035
|
+
signal: options.signal
|
|
12036
|
+
});
|
|
12037
|
+
return { ...await outputMetadata(prepared, assets, settings, options.outputPath, output.bytes, "mp4"), encodedDuration: output.duration / 1e3 };
|
|
12038
|
+
}
|
|
12039
|
+
|
|
10612
12040
|
// src/import-types.ts
|
|
10613
12041
|
function graphImportResult(source, graph, diagnostics) {
|
|
10614
12042
|
if (graph.nodes.length === 0 && diagnostics.every(({ severity }) => severity !== "error")) {
|
|
@@ -10694,7 +12122,7 @@ function readEndpoint(line, from) {
|
|
|
10694
12122
|
{ open: "(", close: ")", lossy: true },
|
|
10695
12123
|
{ open: "{", close: "}", lossy: true }
|
|
10696
12124
|
];
|
|
10697
|
-
const delimiter = delimiters.find(({ open }) => rest.startsWith(
|
|
12125
|
+
const delimiter = delimiters.find(({ open: open3 }) => rest.startsWith(open3));
|
|
10698
12126
|
if (!delimiter) return { id, label: id, shape: "rectangle", next: index };
|
|
10699
12127
|
const content = readDelimited(line, afterId + delimiter.open.length, delimiter.close);
|
|
10700
12128
|
if (!content) return void 0;
|
|
@@ -11165,13 +12593,13 @@ function importD2Graph(source) {
|
|
|
11165
12593
|
}
|
|
11166
12594
|
|
|
11167
12595
|
// src/check.ts
|
|
11168
|
-
import { mkdtemp, rm } from "fs/promises";
|
|
12596
|
+
import { mkdtemp, rm as rm3 } from "fs/promises";
|
|
11169
12597
|
import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
|
|
11170
12598
|
import { tmpdir } from "os";
|
|
11171
|
-
import { join as
|
|
12599
|
+
import { join as join4 } from "path";
|
|
11172
12600
|
|
|
11173
12601
|
// src/diagnostics.ts
|
|
11174
|
-
import
|
|
12602
|
+
import parseCssColor4 from "parse-css-color";
|
|
11175
12603
|
import { Children, isValidElement as isValidElement3 } from "react";
|
|
11176
12604
|
var CHECK_DIAGNOSTIC_CODES = [
|
|
11177
12605
|
"accessibility.low_contrast",
|
|
@@ -11212,7 +12640,7 @@ function hslToRgb2(hue, saturation, lightness) {
|
|
|
11212
12640
|
}
|
|
11213
12641
|
function colorFromCss(value) {
|
|
11214
12642
|
if (typeof value !== "string") return void 0;
|
|
11215
|
-
const parsed =
|
|
12643
|
+
const parsed = parseCssColor4(value);
|
|
11216
12644
|
if (!parsed || parsed.values.length < 3) return void 0;
|
|
11217
12645
|
const [r, g, b] = parsed.type === "hsl" ? hslToRgb2(parsed.values[0] ?? 0, parsed.values[1] ?? 0, parsed.values[2] ?? 0) : [parsed.values[0] ?? 0, parsed.values[1] ?? 0, parsed.values[2] ?? 0];
|
|
11218
12646
|
return {
|
|
@@ -11224,13 +12652,13 @@ function colorFromCss(value) {
|
|
|
11224
12652
|
}
|
|
11225
12653
|
function compositeOver(foreground, background) {
|
|
11226
12654
|
if (foreground.alpha >= 1 || !background) return foreground;
|
|
11227
|
-
const
|
|
11228
|
-
if (
|
|
12655
|
+
const alpha2 = foreground.alpha + background.alpha * (1 - foreground.alpha);
|
|
12656
|
+
if (alpha2 <= 0) return { r: 0, g: 0, b: 0, alpha: 0 };
|
|
11229
12657
|
return {
|
|
11230
|
-
r: (foreground.r * foreground.alpha + background.r * background.alpha * (1 - foreground.alpha)) /
|
|
11231
|
-
g: (foreground.g * foreground.alpha + background.g * background.alpha * (1 - foreground.alpha)) /
|
|
11232
|
-
b: (foreground.b * foreground.alpha + background.b * background.alpha * (1 - foreground.alpha)) /
|
|
11233
|
-
alpha
|
|
12658
|
+
r: (foreground.r * foreground.alpha + background.r * background.alpha * (1 - foreground.alpha)) / alpha2,
|
|
12659
|
+
g: (foreground.g * foreground.alpha + background.g * background.alpha * (1 - foreground.alpha)) / alpha2,
|
|
12660
|
+
b: (foreground.b * foreground.alpha + background.b * background.alpha * (1 - foreground.alpha)) / alpha2,
|
|
12661
|
+
alpha: alpha2
|
|
11234
12662
|
};
|
|
11235
12663
|
}
|
|
11236
12664
|
function isUnresolvedColor(value) {
|
|
@@ -11260,13 +12688,13 @@ function fontSizePixels(value, inherited) {
|
|
|
11260
12688
|
if (typeof value !== "string") return inherited;
|
|
11261
12689
|
const match = value.trim().match(/^(\d+(?:\.\d+)?|\.\d+)(px|pt|rem|em|%)?$/);
|
|
11262
12690
|
if (!match?.[1]) return inherited;
|
|
11263
|
-
const
|
|
12691
|
+
const amount2 = Number(match[1]);
|
|
11264
12692
|
const unit = match[2] ?? "px";
|
|
11265
|
-
if (unit === "pt") return
|
|
11266
|
-
if (unit === "rem") return
|
|
11267
|
-
if (unit === "em") return
|
|
11268
|
-
if (unit === "%") return
|
|
11269
|
-
return
|
|
12693
|
+
if (unit === "pt") return amount2 * 4 / 3;
|
|
12694
|
+
if (unit === "rem") return amount2 * 16;
|
|
12695
|
+
if (unit === "em") return amount2 * (inherited ?? 16);
|
|
12696
|
+
if (unit === "%") return amount2 / 100 * (inherited ?? 16);
|
|
12697
|
+
return amount2;
|
|
11270
12698
|
}
|
|
11271
12699
|
function requiredContrast(context) {
|
|
11272
12700
|
const large = (context.fontSize ?? 16) >= 24 || (context.fontSize ?? 16) >= 18.66 && (context.fontWeight ?? 400) >= 700;
|
|
@@ -11283,8 +12711,8 @@ function elementId(props) {
|
|
|
11283
12711
|
const value = props.id ?? props["data-vizmatic-id"];
|
|
11284
12712
|
return typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
|
|
11285
12713
|
}
|
|
11286
|
-
function resolveFunctionComponent(node,
|
|
11287
|
-
if (!isValidElement3(node) || typeof node.type !== "function" ||
|
|
12714
|
+
function resolveFunctionComponent(node, trustedComponents2) {
|
|
12715
|
+
if (!isValidElement3(node) || typeof node.type !== "function" || trustedComponents2.has(node.type)) return void 0;
|
|
11288
12716
|
const component = node.type;
|
|
11289
12717
|
if (component.__vizmaticPrimitive) return void 0;
|
|
11290
12718
|
if (component.prototype?.isReactComponent) return void 0;
|
|
@@ -11294,13 +12722,13 @@ function resolveFunctionComponent(node, trustedComponents) {
|
|
|
11294
12722
|
return void 0;
|
|
11295
12723
|
}
|
|
11296
12724
|
}
|
|
11297
|
-
function analyzeContrast(element, theme,
|
|
12725
|
+
function analyzeContrast(element, theme, trustedComponents2 = /* @__PURE__ */ new Set(), rootBackground2) {
|
|
11298
12726
|
const diagnostics = [];
|
|
11299
12727
|
const seen = /* @__PURE__ */ new Set();
|
|
11300
12728
|
let visited = 0;
|
|
11301
12729
|
function visit(node, inherited, path) {
|
|
11302
12730
|
if (visited++ >= MAX_CONTRAST_NODES || !isValidElement3(node)) return;
|
|
11303
|
-
const resolved = resolveFunctionComponent(node,
|
|
12731
|
+
const resolved = resolveFunctionComponent(node, trustedComponents2);
|
|
11304
12732
|
if (resolved !== void 0) {
|
|
11305
12733
|
visit(resolved, inherited, path);
|
|
11306
12734
|
return;
|
|
@@ -11309,7 +12737,7 @@ function analyzeContrast(element, theme, trustedComponents = /* @__PURE__ */ new
|
|
|
11309
12737
|
const style = typeof node.type === "string" ? styleRecord(props.style) : {};
|
|
11310
12738
|
const backgroundImage = typeof style.backgroundImage === "string" ? style.backgroundImage.trim().toLowerCase() : "";
|
|
11311
12739
|
const backgroundShorthand = typeof style.background === "string" ? style.background.trim() : "";
|
|
11312
|
-
const isBackgroundWrapper = typeof node.type === "function" && (
|
|
12740
|
+
const isBackgroundWrapper = typeof node.type === "function" && (trustedComponents2.has(node.type) || Boolean(node.type.__vizmaticPrimitive));
|
|
11313
12741
|
const wrapperBackground = isBackgroundWrapper ? props.background : void 0;
|
|
11314
12742
|
const hasUnresolvedBackground = backgroundImage !== "" && backgroundImage !== "none" || isUnresolvedColor(style.backgroundColor) || backgroundShorthand !== "" && backgroundShorthand.toLowerCase() !== "none" && !colorFromCss(backgroundShorthand) || isUnresolvedColor(wrapperBackground);
|
|
11315
12743
|
const ownBackground = colorFromCss(style.backgroundColor) ?? colorFromCss(style.background) ?? colorFromCss(wrapperBackground);
|
|
@@ -11363,7 +12791,7 @@ function renderedTextNodes(nodes) {
|
|
|
11363
12791
|
const style = styleRecord(node.props.style);
|
|
11364
12792
|
const fontSize = fontSizePixels(style.fontSize, inherited?.fontSize) ?? 16;
|
|
11365
12793
|
const textAlign = typeof style.textAlign === "string" ? style.textAlign : inherited?.textAlign ?? "left";
|
|
11366
|
-
const text = node.textContent
|
|
12794
|
+
const text = String(node.textContent ?? "").trim();
|
|
11367
12795
|
if (text && node.width > 0 && node.height > 0) {
|
|
11368
12796
|
const estimatedLines = Math.max(1, Math.round(node.height / Math.max(fontSize * 1.5, 1)));
|
|
11369
12797
|
const paintHeight = Math.min(
|
|
@@ -11568,12 +12996,12 @@ function analyzeRenderedLayout(nodes, theme) {
|
|
|
11568
12996
|
}
|
|
11569
12997
|
return diagnostics;
|
|
11570
12998
|
}
|
|
11571
|
-
function analyzeWhitespaceBalance(
|
|
12999
|
+
function analyzeWhitespaceBalance(bounds2, width, height, theme) {
|
|
11572
13000
|
const gutters = {
|
|
11573
|
-
left:
|
|
11574
|
-
right: width -
|
|
11575
|
-
top:
|
|
11576
|
-
bottom: height -
|
|
13001
|
+
left: bounds2.x,
|
|
13002
|
+
right: width - bounds2.x - bounds2.width,
|
|
13003
|
+
top: bounds2.y,
|
|
13004
|
+
bottom: height - bounds2.y - bounds2.height
|
|
11577
13005
|
};
|
|
11578
13006
|
const diagnostics = [];
|
|
11579
13007
|
const horizontalDifference = Math.abs(gutters.left - gutters.right);
|
|
@@ -11585,7 +13013,7 @@ function analyzeWhitespaceBalance(bounds, width, height, theme) {
|
|
|
11585
13013
|
theme,
|
|
11586
13014
|
message: `Horizontal gutters differ by ${Math.round(horizontalDifference)}px (${Math.round(gutters.left)}px left, ${Math.round(gutters.right)}px right).`,
|
|
11587
13015
|
suggestion: "Recenter the composition, crop the canvas, or use the open space intentionally.",
|
|
11588
|
-
location: { x:
|
|
13016
|
+
location: { x: bounds2.x, y: bounds2.y, width: bounds2.width, height: bounds2.height }
|
|
11589
13017
|
});
|
|
11590
13018
|
}
|
|
11591
13019
|
if (verticalDifference > 48 && verticalDifference / height > 0.12) {
|
|
@@ -11595,7 +13023,7 @@ function analyzeWhitespaceBalance(bounds, width, height, theme) {
|
|
|
11595
13023
|
theme,
|
|
11596
13024
|
message: `Vertical gutters differ by ${Math.round(verticalDifference)}px (${Math.round(gutters.top)}px top, ${Math.round(gutters.bottom)}px bottom).`,
|
|
11597
13025
|
suggestion: "Recenter the composition, crop the canvas, or use the open space intentionally.",
|
|
11598
|
-
location: { x:
|
|
13026
|
+
location: { x: bounds2.x, y: bounds2.y, width: bounds2.width, height: bounds2.height }
|
|
11599
13027
|
});
|
|
11600
13028
|
}
|
|
11601
13029
|
return diagnostics;
|
|
@@ -11819,7 +13247,7 @@ async function checkFrame(input, options = {}) {
|
|
|
11819
13247
|
});
|
|
11820
13248
|
const create = input.create ?? (() => input.scene);
|
|
11821
13249
|
const failOn = options.failOn ?? "error";
|
|
11822
|
-
const tempDir = await mkdtemp(
|
|
13250
|
+
const tempDir = await mkdtemp(join4(tmpdir(), "vizmatic-check-"));
|
|
11823
13251
|
const reports = [];
|
|
11824
13252
|
try {
|
|
11825
13253
|
for (const [themeIndex, theme] of themes.entries()) {
|
|
@@ -11851,7 +13279,7 @@ async function checkFrame(input, options = {}) {
|
|
|
11851
13279
|
height,
|
|
11852
13280
|
autoSize,
|
|
11853
13281
|
background: options.background,
|
|
11854
|
-
outputPath:
|
|
13282
|
+
outputPath: join4(tempDir, `${themeIndex}.png`)
|
|
11855
13283
|
}));
|
|
11856
13284
|
diagnostics2.push(...messageDiagnostics(rendered.messages, theme));
|
|
11857
13285
|
if (rendered.value) {
|
|
@@ -11892,7 +13320,7 @@ async function checkFrame(input, options = {}) {
|
|
|
11892
13320
|
height,
|
|
11893
13321
|
autoSize: { width: true, height: true },
|
|
11894
13322
|
background: options.background,
|
|
11895
|
-
outputPath:
|
|
13323
|
+
outputPath: join4(tempDir, `${themeIndex}-suggestion.png`)
|
|
11896
13324
|
}));
|
|
11897
13325
|
const suggestedDimensions = suggestion.value ? { width: suggestion.value.width, height: suggestion.value.height } : void 0;
|
|
11898
13326
|
diagnostics2.push({
|
|
@@ -11919,7 +13347,7 @@ async function checkFrame(input, options = {}) {
|
|
|
11919
13347
|
});
|
|
11920
13348
|
}
|
|
11921
13349
|
} finally {
|
|
11922
|
-
await
|
|
13350
|
+
await rm3(tempDir, { recursive: true, force: true });
|
|
11923
13351
|
}
|
|
11924
13352
|
const summary = counts(reports);
|
|
11925
13353
|
const diagnostics = reports.flatMap(({ diagnostics: themeDiagnostics }) => themeDiagnostics);
|
|
@@ -11987,6 +13415,8 @@ export {
|
|
|
11987
13415
|
ProgressRow,
|
|
11988
13416
|
QuadrantChart,
|
|
11989
13417
|
Row,
|
|
13418
|
+
SCENE_LIMITS,
|
|
13419
|
+
SCENE_RUNTIME_VERSION,
|
|
11990
13420
|
ScatterPlot,
|
|
11991
13421
|
Scene,
|
|
11992
13422
|
SequenceDiagram,
|
|
@@ -12013,10 +13443,16 @@ export {
|
|
|
12013
13443
|
Watermark,
|
|
12014
13444
|
WindowFrame,
|
|
12015
13445
|
analyzeAnimationCadence,
|
|
13446
|
+
arcSwap,
|
|
13447
|
+
cameraSvgTransform,
|
|
12016
13448
|
canvas,
|
|
12017
13449
|
checkFrame,
|
|
12018
13450
|
colors,
|
|
13451
|
+
createCanvasComponents,
|
|
13452
|
+
createCueTrack,
|
|
12019
13453
|
createPlotArea,
|
|
13454
|
+
createPolylineMorph,
|
|
13455
|
+
createTeachingCanvas,
|
|
12020
13456
|
cropPixels,
|
|
12021
13457
|
defineAnimation,
|
|
12022
13458
|
defineDiagramIcon,
|
|
@@ -12025,8 +13461,12 @@ export {
|
|
|
12025
13461
|
detectBackgroundColor,
|
|
12026
13462
|
detectContentBounds,
|
|
12027
13463
|
detectOverflow,
|
|
13464
|
+
dotProduct,
|
|
13465
|
+
entropy,
|
|
13466
|
+
evaluateSceneSource,
|
|
12028
13467
|
formatMathText,
|
|
12029
13468
|
formatTensorShape,
|
|
13469
|
+
gaussian,
|
|
12030
13470
|
getColor,
|
|
12031
13471
|
getFonts,
|
|
12032
13472
|
getGradient,
|
|
@@ -12043,24 +13483,48 @@ export {
|
|
|
12043
13483
|
hold,
|
|
12044
13484
|
importD2Graph,
|
|
12045
13485
|
importMermaidGraph,
|
|
13486
|
+
interpolateCamera,
|
|
12046
13487
|
keyframe,
|
|
13488
|
+
layoutAllocation,
|
|
13489
|
+
layoutCellGrid,
|
|
13490
|
+
layoutTokenRow,
|
|
13491
|
+
lerpArray,
|
|
12047
13492
|
loadAdditionalAsset,
|
|
13493
|
+
morphPolyline,
|
|
13494
|
+
multiplyMatrices,
|
|
13495
|
+
normalizeVector,
|
|
12048
13496
|
normalizeWatermark,
|
|
12049
13497
|
parallel,
|
|
13498
|
+
pointAlongPath,
|
|
13499
|
+
prepareScene,
|
|
13500
|
+
projectWorldPoint,
|
|
12050
13501
|
renderAnimatedGif,
|
|
12051
13502
|
renderAnimatedGifWithOutput,
|
|
12052
13503
|
renderAnimationGif,
|
|
12053
13504
|
renderAnimationGifWithOutput,
|
|
13505
|
+
renderAnimationVideo,
|
|
13506
|
+
renderMathSvg,
|
|
13507
|
+
renderRgbaVideo,
|
|
13508
|
+
renderSceneFrame,
|
|
13509
|
+
renderSceneVideo,
|
|
12054
13510
|
renderToBuffer,
|
|
12055
13511
|
renderToPng,
|
|
12056
13512
|
renderToPngWithOutput,
|
|
12057
13513
|
renderToSvg,
|
|
12058
13514
|
sampleAnimation,
|
|
13515
|
+
sampleAnimationFrame,
|
|
12059
13516
|
sampleAnimationFrames,
|
|
13517
|
+
sampleFunction,
|
|
13518
|
+
sampleGaussian,
|
|
13519
|
+
seededRandom,
|
|
13520
|
+
smoothstep,
|
|
13521
|
+
stableSoftmax,
|
|
12060
13522
|
styles,
|
|
12061
13523
|
toneGradients,
|
|
13524
|
+
tracePolyline,
|
|
12062
13525
|
tween,
|
|
12063
13526
|
typography,
|
|
13527
|
+
videoFrameSchedule,
|
|
12064
13528
|
withColorAlpha,
|
|
12065
13529
|
wrapWithBrand,
|
|
12066
13530
|
wrapWithWatermark
|