@framefields/compositions 0.0.0-stage → 2.0.3
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/LICENCE +202 -0
- package/dist/index.d.mts +81 -0
- package/dist/index.d.mts.map +1 -0
- package/dist/index.mjs +898 -0
- package/dist/index.mjs.map +1 -0
- package/dist/layer-logic-DBs4NHoi.mjs +162 -0
- package/dist/layer-logic-DBs4NHoi.mjs.map +1 -0
- package/dist/program/index.d.mts +3401 -0
- package/dist/program/index.d.mts.map +1 -0
- package/dist/program/index.mjs +5454 -0
- package/dist/program/index.mjs.map +1 -0
- package/dist/server.d.mts +2 -0
- package/dist/server.mjs +3 -0
- package/dist/timing-CHy-6wsp.d.mts +53 -0
- package/dist/timing-CHy-6wsp.d.mts.map +1 -0
- package/package.json +63 -3
- package/README.md +0 -3
|
@@ -0,0 +1,3401 @@
|
|
|
1
|
+
import { MeshAudioDeformConfig, TextSpan, TextSpanMark, VirtualMediaData } from "@framefields/core";
|
|
2
|
+
import { Yoga } from "yoga-layout/load";
|
|
3
|
+
import { z } from "zod";
|
|
4
|
+
|
|
5
|
+
//#region src/program/text-animations/advanced-types.d.ts
|
|
6
|
+
declare const AnchorGroupingSchema: z.ZodEnum<{
|
|
7
|
+
character: "character";
|
|
8
|
+
word: "word";
|
|
9
|
+
line: "line";
|
|
10
|
+
all: "all";
|
|
11
|
+
}>;
|
|
12
|
+
type AnchorGrouping = z.infer<typeof AnchorGroupingSchema>;
|
|
13
|
+
declare const AnchorPresetSchema: z.ZodEnum<{
|
|
14
|
+
center: "center";
|
|
15
|
+
custom: "custom";
|
|
16
|
+
baseline: "baseline";
|
|
17
|
+
bottom_left: "bottom_left";
|
|
18
|
+
bottom_center: "bottom_center";
|
|
19
|
+
bottom_right: "bottom_right";
|
|
20
|
+
top_left: "top_left";
|
|
21
|
+
top_center: "top_center";
|
|
22
|
+
top_right: "top_right";
|
|
23
|
+
}>;
|
|
24
|
+
type AnchorPreset = z.infer<typeof AnchorPresetSchema>;
|
|
25
|
+
declare const TextAnchorConfigSchema: z.ZodObject<{
|
|
26
|
+
grouping: z.ZodDefault<z.ZodEnum<{
|
|
27
|
+
character: "character";
|
|
28
|
+
word: "word";
|
|
29
|
+
line: "line";
|
|
30
|
+
all: "all";
|
|
31
|
+
}>>;
|
|
32
|
+
preset: z.ZodDefault<z.ZodEnum<{
|
|
33
|
+
center: "center";
|
|
34
|
+
custom: "custom";
|
|
35
|
+
baseline: "baseline";
|
|
36
|
+
bottom_left: "bottom_left";
|
|
37
|
+
bottom_center: "bottom_center";
|
|
38
|
+
bottom_right: "bottom_right";
|
|
39
|
+
top_left: "top_left";
|
|
40
|
+
top_center: "top_center";
|
|
41
|
+
top_right: "top_right";
|
|
42
|
+
}>>;
|
|
43
|
+
anchorX: z.ZodDefault<z.ZodNumber>;
|
|
44
|
+
anchorY: z.ZodDefault<z.ZodNumber>;
|
|
45
|
+
offsetX: z.ZodDefault<z.ZodNumber>;
|
|
46
|
+
offsetY: z.ZodDefault<z.ZodNumber>;
|
|
47
|
+
}, z.core.$strip>;
|
|
48
|
+
type TextAnchorConfig = z.infer<typeof TextAnchorConfigSchema>;
|
|
49
|
+
declare const SkewPropertiesSchema: z.ZodObject<{
|
|
50
|
+
skew: z.ZodNumber;
|
|
51
|
+
skewAxis: z.ZodDefault<z.ZodNumber>;
|
|
52
|
+
}, z.core.$strip>;
|
|
53
|
+
type SkewProperties = z.infer<typeof SkewPropertiesSchema>;
|
|
54
|
+
declare const LineSpacingDynamicsSchema: z.ZodObject<{
|
|
55
|
+
lineSpacing: z.ZodNumber;
|
|
56
|
+
lineAnchor: z.ZodDefault<z.ZodNumber>;
|
|
57
|
+
}, z.core.$strip>;
|
|
58
|
+
type LineSpacingDynamics = z.infer<typeof LineSpacingDynamicsSchema>;
|
|
59
|
+
declare const VolumetricFormationModeSchema: z.ZodEnum<{
|
|
60
|
+
planar: "planar";
|
|
61
|
+
vortex: "vortex";
|
|
62
|
+
cylinder: "cylinder";
|
|
63
|
+
helix: "helix";
|
|
64
|
+
}>;
|
|
65
|
+
type VolumetricFormationMode = z.infer<typeof VolumetricFormationModeSchema>;
|
|
66
|
+
declare const VolumetricFormationConfigSchema: z.ZodObject<{
|
|
67
|
+
mode: z.ZodDefault<z.ZodEnum<{
|
|
68
|
+
planar: "planar";
|
|
69
|
+
vortex: "vortex";
|
|
70
|
+
cylinder: "cylinder";
|
|
71
|
+
helix: "helix";
|
|
72
|
+
}>>;
|
|
73
|
+
radius: z.ZodDefault<z.ZodNumber>;
|
|
74
|
+
pitch: z.ZodDefault<z.ZodNumber>;
|
|
75
|
+
totalAngle: z.ZodDefault<z.ZodNumber>;
|
|
76
|
+
axis: z.ZodDefault<z.ZodEnum<{
|
|
77
|
+
x: "x";
|
|
78
|
+
y: "y";
|
|
79
|
+
z: "z";
|
|
80
|
+
}>>;
|
|
81
|
+
perspective: z.ZodDefault<z.ZodNumber>;
|
|
82
|
+
}, z.core.$strip>;
|
|
83
|
+
type VolumetricFormationConfig = z.infer<typeof VolumetricFormationConfigSchema>;
|
|
84
|
+
declare const Spatial3DPropertiesSchema: z.ZodObject<{
|
|
85
|
+
translateZ: z.ZodOptional<z.ZodNumber>;
|
|
86
|
+
rotationX: z.ZodOptional<z.ZodNumber>;
|
|
87
|
+
rotationY: z.ZodOptional<z.ZodNumber>;
|
|
88
|
+
rotationZ: z.ZodOptional<z.ZodNumber>;
|
|
89
|
+
formation: z.ZodOptional<z.ZodObject<{
|
|
90
|
+
mode: z.ZodDefault<z.ZodEnum<{
|
|
91
|
+
planar: "planar";
|
|
92
|
+
vortex: "vortex";
|
|
93
|
+
cylinder: "cylinder";
|
|
94
|
+
helix: "helix";
|
|
95
|
+
}>>;
|
|
96
|
+
radius: z.ZodDefault<z.ZodNumber>;
|
|
97
|
+
pitch: z.ZodDefault<z.ZodNumber>;
|
|
98
|
+
totalAngle: z.ZodDefault<z.ZodNumber>;
|
|
99
|
+
axis: z.ZodDefault<z.ZodEnum<{
|
|
100
|
+
x: "x";
|
|
101
|
+
y: "y";
|
|
102
|
+
z: "z";
|
|
103
|
+
}>>;
|
|
104
|
+
perspective: z.ZodDefault<z.ZodNumber>;
|
|
105
|
+
}, z.core.$strip>>;
|
|
106
|
+
}, z.core.$strip>;
|
|
107
|
+
type Spatial3DProperties = z.infer<typeof Spatial3DPropertiesSchema>;
|
|
108
|
+
declare const SpringPhysicsSchema: z.ZodObject<{
|
|
109
|
+
stiffness: z.ZodDefault<z.ZodNumber>;
|
|
110
|
+
damping: z.ZodDefault<z.ZodNumber>;
|
|
111
|
+
mass: z.ZodDefault<z.ZodNumber>;
|
|
112
|
+
initialVelocity: z.ZodDefault<z.ZodNumber>;
|
|
113
|
+
overshootMultiplier: z.ZodDefault<z.ZodNumber>;
|
|
114
|
+
}, z.core.$strip>;
|
|
115
|
+
type SpringPhysics = z.infer<typeof SpringPhysicsSchema>;
|
|
116
|
+
interface ExpressionEvaluationContext {
|
|
117
|
+
/** 0-based index of the current character */
|
|
118
|
+
charIndex: number;
|
|
119
|
+
/** 0-based index of the current word */
|
|
120
|
+
wordIndex: number;
|
|
121
|
+
/** 0-based index of the current line */
|
|
122
|
+
lineIndex: number;
|
|
123
|
+
/** Total count of characters in paragraph */
|
|
124
|
+
totalChars: number;
|
|
125
|
+
/** Total count of words in paragraph */
|
|
126
|
+
totalWords: number;
|
|
127
|
+
/** Total count of lines in paragraph */
|
|
128
|
+
totalLines: number;
|
|
129
|
+
/** Current timeline frame number */
|
|
130
|
+
frame: number;
|
|
131
|
+
/** Timeline frame rate */
|
|
132
|
+
fps: number;
|
|
133
|
+
/** Current timeline timestamp in seconds */
|
|
134
|
+
time: number;
|
|
135
|
+
/** Bound reactive signals map */
|
|
136
|
+
signals?: Record<string, unknown>;
|
|
137
|
+
}
|
|
138
|
+
declare const ExpressionSelectorSchema: z.ZodObject<{
|
|
139
|
+
type: z.ZodLiteral<"expression">;
|
|
140
|
+
name: z.ZodOptional<z.ZodString>;
|
|
141
|
+
expression: z.ZodString;
|
|
142
|
+
mode: z.ZodDefault<z.ZodEnum<{
|
|
143
|
+
difference: "difference";
|
|
144
|
+
add: "add";
|
|
145
|
+
subtract: "subtract";
|
|
146
|
+
intersect: "intersect";
|
|
147
|
+
min: "min";
|
|
148
|
+
max: "max";
|
|
149
|
+
}>>;
|
|
150
|
+
amount: z.ZodDefault<z.ZodNumber>;
|
|
151
|
+
}, z.core.$strip>;
|
|
152
|
+
type ExpressionSelector = z.infer<typeof ExpressionSelectorSchema>;
|
|
153
|
+
declare const DynamicStrokePropertiesSchema: z.ZodObject<{
|
|
154
|
+
strokeWidth: z.ZodDefault<z.ZodNumber>;
|
|
155
|
+
strokeColor: z.ZodDefault<z.ZodString>;
|
|
156
|
+
strokeAlign: z.ZodDefault<z.ZodEnum<{
|
|
157
|
+
inside: "inside";
|
|
158
|
+
center: "center";
|
|
159
|
+
outside: "outside";
|
|
160
|
+
}>>;
|
|
161
|
+
fillOpacity: z.ZodDefault<z.ZodNumber>;
|
|
162
|
+
dashArray: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
|
|
163
|
+
dashOffset: z.ZodDefault<z.ZodNumber>;
|
|
164
|
+
}, z.core.$strip>;
|
|
165
|
+
type DynamicStrokeProperties = z.infer<typeof DynamicStrokePropertiesSchema>;
|
|
166
|
+
declare const KineticMarqueeConfigSchema: z.ZodObject<{
|
|
167
|
+
direction: z.ZodDefault<z.ZodEnum<{
|
|
168
|
+
left: "left";
|
|
169
|
+
right: "right";
|
|
170
|
+
up: "up";
|
|
171
|
+
down: "down";
|
|
172
|
+
}>>;
|
|
173
|
+
velocity: z.ZodDefault<z.ZodNumber>;
|
|
174
|
+
loop: z.ZodDefault<z.ZodBoolean>;
|
|
175
|
+
repeatGap: z.ZodDefault<z.ZodNumber>;
|
|
176
|
+
snap: z.ZodOptional<z.ZodObject<{
|
|
177
|
+
enabled: z.ZodDefault<z.ZodBoolean>;
|
|
178
|
+
granularity: z.ZodDefault<z.ZodEnum<{
|
|
179
|
+
character: "character";
|
|
180
|
+
word: "word";
|
|
181
|
+
line: "line";
|
|
182
|
+
}>>;
|
|
183
|
+
stopIndex: z.ZodDefault<z.ZodNumber>;
|
|
184
|
+
decelEase: z.ZodDefault<z.ZodString>;
|
|
185
|
+
}, z.core.$strip>>;
|
|
186
|
+
}, z.core.$strip>;
|
|
187
|
+
type KineticMarqueeConfig = z.infer<typeof KineticMarqueeConfigSchema>;
|
|
188
|
+
declare const VariableFontAxesSchema: z.ZodObject<{
|
|
189
|
+
weight: z.ZodOptional<z.ZodNumber>;
|
|
190
|
+
width: z.ZodOptional<z.ZodNumber>;
|
|
191
|
+
slant: z.ZodOptional<z.ZodNumber>;
|
|
192
|
+
italic: z.ZodOptional<z.ZodNumber>;
|
|
193
|
+
opticalSize: z.ZodOptional<z.ZodNumber>;
|
|
194
|
+
}, z.core.$strip>;
|
|
195
|
+
type VariableFontAxes = z.infer<typeof VariableFontAxesSchema>;
|
|
196
|
+
declare const ChromaticGlitchConfigSchema: z.ZodObject<{
|
|
197
|
+
redShiftX: z.ZodDefault<z.ZodNumber>;
|
|
198
|
+
redShiftY: z.ZodDefault<z.ZodNumber>;
|
|
199
|
+
blueShiftX: z.ZodDefault<z.ZodNumber>;
|
|
200
|
+
blueShiftY: z.ZodDefault<z.ZodNumber>;
|
|
201
|
+
sliceProbability: z.ZodDefault<z.ZodNumber>;
|
|
202
|
+
sliceAmplitude: z.ZodDefault<z.ZodNumber>;
|
|
203
|
+
}, z.core.$strip>;
|
|
204
|
+
type ChromaticGlitchConfig = z.infer<typeof ChromaticGlitchConfigSchema>;
|
|
205
|
+
declare const AudioSpectrumTypographySchema: z.ZodObject<{
|
|
206
|
+
signalChannel: z.ZodString;
|
|
207
|
+
minFreqHz: z.ZodDefault<z.ZodNumber>;
|
|
208
|
+
maxFreqHz: z.ZodDefault<z.ZodNumber>;
|
|
209
|
+
scaleAxis: z.ZodDefault<z.ZodEnum<{
|
|
210
|
+
y: "y";
|
|
211
|
+
scale: "scale";
|
|
212
|
+
scaleX: "scaleX";
|
|
213
|
+
scaleY: "scaleY";
|
|
214
|
+
}>>;
|
|
215
|
+
minScale: z.ZodDefault<z.ZodNumber>;
|
|
216
|
+
maxScale: z.ZodDefault<z.ZodNumber>;
|
|
217
|
+
peakDecay: z.ZodDefault<z.ZodNumber>;
|
|
218
|
+
}, z.core.$strip>;
|
|
219
|
+
type AudioSpectrumTypography = z.infer<typeof AudioSpectrumTypographySchema>;
|
|
220
|
+
declare const LongShadowConfigSchema: z.ZodObject<{
|
|
221
|
+
angle: z.ZodDefault<z.ZodNumber>;
|
|
222
|
+
length: z.ZodDefault<z.ZodNumber>;
|
|
223
|
+
color: z.ZodDefault<z.ZodString>;
|
|
224
|
+
startOpacity: z.ZodDefault<z.ZodNumber>;
|
|
225
|
+
endOpacity: z.ZodDefault<z.ZodNumber>;
|
|
226
|
+
steps: z.ZodDefault<z.ZodNumber>;
|
|
227
|
+
}, z.core.$strip>;
|
|
228
|
+
type LongShadowConfig = z.infer<typeof LongShadowConfigSchema>;
|
|
229
|
+
declare const ParticleDissolveConfigSchema: z.ZodObject<{
|
|
230
|
+
progress: z.ZodDefault<z.ZodNumber>;
|
|
231
|
+
dispersalAngle: z.ZodDefault<z.ZodNumber>;
|
|
232
|
+
maxDisplacement: z.ZodDefault<z.ZodNumber>;
|
|
233
|
+
turbulence: z.ZodDefault<z.ZodNumber>;
|
|
234
|
+
particleSize: z.ZodDefault<z.ZodNumber>;
|
|
235
|
+
}, z.core.$strip>;
|
|
236
|
+
type ParticleDissolveConfig = z.infer<typeof ParticleDissolveConfigSchema>;
|
|
237
|
+
declare const ExtendedGlyphPropertiesSchema: z.ZodObject<{
|
|
238
|
+
x: z.ZodOptional<z.ZodNumber>;
|
|
239
|
+
y: z.ZodOptional<z.ZodNumber>;
|
|
240
|
+
translateZ: z.ZodOptional<z.ZodNumber>;
|
|
241
|
+
scale: z.ZodOptional<z.ZodNumber>;
|
|
242
|
+
scaleX: z.ZodOptional<z.ZodNumber>;
|
|
243
|
+
scaleY: z.ZodOptional<z.ZodNumber>;
|
|
244
|
+
rotation: z.ZodOptional<z.ZodNumber>;
|
|
245
|
+
rotationX: z.ZodOptional<z.ZodNumber>;
|
|
246
|
+
rotationY: z.ZodOptional<z.ZodNumber>;
|
|
247
|
+
rotationZ: z.ZodOptional<z.ZodNumber>;
|
|
248
|
+
formation: z.ZodOptional<z.ZodObject<{
|
|
249
|
+
mode: z.ZodDefault<z.ZodEnum<{
|
|
250
|
+
planar: "planar";
|
|
251
|
+
vortex: "vortex";
|
|
252
|
+
cylinder: "cylinder";
|
|
253
|
+
helix: "helix";
|
|
254
|
+
}>>;
|
|
255
|
+
radius: z.ZodDefault<z.ZodNumber>;
|
|
256
|
+
pitch: z.ZodDefault<z.ZodNumber>;
|
|
257
|
+
totalAngle: z.ZodDefault<z.ZodNumber>;
|
|
258
|
+
axis: z.ZodDefault<z.ZodEnum<{
|
|
259
|
+
x: "x";
|
|
260
|
+
y: "y";
|
|
261
|
+
z: "z";
|
|
262
|
+
}>>;
|
|
263
|
+
perspective: z.ZodDefault<z.ZodNumber>;
|
|
264
|
+
}, z.core.$strip>>;
|
|
265
|
+
skew: z.ZodOptional<z.ZodNumber>;
|
|
266
|
+
skewAxis: z.ZodOptional<z.ZodNumber>;
|
|
267
|
+
tracking: z.ZodOptional<z.ZodNumber>;
|
|
268
|
+
lineSpacing: z.ZodOptional<z.ZodNumber>;
|
|
269
|
+
lineAnchor: z.ZodOptional<z.ZodNumber>;
|
|
270
|
+
anchor: z.ZodOptional<z.ZodObject<{
|
|
271
|
+
grouping: z.ZodDefault<z.ZodEnum<{
|
|
272
|
+
character: "character";
|
|
273
|
+
word: "word";
|
|
274
|
+
line: "line";
|
|
275
|
+
all: "all";
|
|
276
|
+
}>>;
|
|
277
|
+
preset: z.ZodDefault<z.ZodEnum<{
|
|
278
|
+
center: "center";
|
|
279
|
+
custom: "custom";
|
|
280
|
+
baseline: "baseline";
|
|
281
|
+
bottom_left: "bottom_left";
|
|
282
|
+
bottom_center: "bottom_center";
|
|
283
|
+
bottom_right: "bottom_right";
|
|
284
|
+
top_left: "top_left";
|
|
285
|
+
top_center: "top_center";
|
|
286
|
+
top_right: "top_right";
|
|
287
|
+
}>>;
|
|
288
|
+
anchorX: z.ZodDefault<z.ZodNumber>;
|
|
289
|
+
anchorY: z.ZodDefault<z.ZodNumber>;
|
|
290
|
+
offsetX: z.ZodDefault<z.ZodNumber>;
|
|
291
|
+
offsetY: z.ZodDefault<z.ZodNumber>;
|
|
292
|
+
}, z.core.$strip>>;
|
|
293
|
+
opacity: z.ZodOptional<z.ZodNumber>;
|
|
294
|
+
blur: z.ZodOptional<z.ZodNumber>;
|
|
295
|
+
fillColor: z.ZodOptional<z.ZodString>;
|
|
296
|
+
stroke: z.ZodOptional<z.ZodObject<{
|
|
297
|
+
strokeWidth: z.ZodDefault<z.ZodNumber>;
|
|
298
|
+
strokeColor: z.ZodDefault<z.ZodString>;
|
|
299
|
+
strokeAlign: z.ZodDefault<z.ZodEnum<{
|
|
300
|
+
inside: "inside";
|
|
301
|
+
center: "center";
|
|
302
|
+
outside: "outside";
|
|
303
|
+
}>>;
|
|
304
|
+
fillOpacity: z.ZodDefault<z.ZodNumber>;
|
|
305
|
+
dashArray: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
|
|
306
|
+
dashOffset: z.ZodDefault<z.ZodNumber>;
|
|
307
|
+
}, z.core.$strip>>;
|
|
308
|
+
variableAxes: z.ZodOptional<z.ZodObject<{
|
|
309
|
+
weight: z.ZodOptional<z.ZodNumber>;
|
|
310
|
+
width: z.ZodOptional<z.ZodNumber>;
|
|
311
|
+
slant: z.ZodOptional<z.ZodNumber>;
|
|
312
|
+
italic: z.ZodOptional<z.ZodNumber>;
|
|
313
|
+
opticalSize: z.ZodOptional<z.ZodNumber>;
|
|
314
|
+
}, z.core.$strip>>;
|
|
315
|
+
chromaticGlitch: z.ZodOptional<z.ZodObject<{
|
|
316
|
+
redShiftX: z.ZodDefault<z.ZodNumber>;
|
|
317
|
+
redShiftY: z.ZodDefault<z.ZodNumber>;
|
|
318
|
+
blueShiftX: z.ZodDefault<z.ZodNumber>;
|
|
319
|
+
blueShiftY: z.ZodDefault<z.ZodNumber>;
|
|
320
|
+
sliceProbability: z.ZodDefault<z.ZodNumber>;
|
|
321
|
+
sliceAmplitude: z.ZodDefault<z.ZodNumber>;
|
|
322
|
+
}, z.core.$strip>>;
|
|
323
|
+
longShadow: z.ZodOptional<z.ZodObject<{
|
|
324
|
+
angle: z.ZodDefault<z.ZodNumber>;
|
|
325
|
+
length: z.ZodDefault<z.ZodNumber>;
|
|
326
|
+
color: z.ZodDefault<z.ZodString>;
|
|
327
|
+
startOpacity: z.ZodDefault<z.ZodNumber>;
|
|
328
|
+
endOpacity: z.ZodDefault<z.ZodNumber>;
|
|
329
|
+
steps: z.ZodDefault<z.ZodNumber>;
|
|
330
|
+
}, z.core.$strip>>;
|
|
331
|
+
particleDissolve: z.ZodOptional<z.ZodObject<{
|
|
332
|
+
progress: z.ZodDefault<z.ZodNumber>;
|
|
333
|
+
dispersalAngle: z.ZodDefault<z.ZodNumber>;
|
|
334
|
+
maxDisplacement: z.ZodDefault<z.ZodNumber>;
|
|
335
|
+
turbulence: z.ZodDefault<z.ZodNumber>;
|
|
336
|
+
particleSize: z.ZodDefault<z.ZodNumber>;
|
|
337
|
+
}, z.core.$strip>>;
|
|
338
|
+
audioSpectrum: z.ZodOptional<z.ZodObject<{
|
|
339
|
+
signalChannel: z.ZodString;
|
|
340
|
+
minFreqHz: z.ZodDefault<z.ZodNumber>;
|
|
341
|
+
maxFreqHz: z.ZodDefault<z.ZodNumber>;
|
|
342
|
+
scaleAxis: z.ZodDefault<z.ZodEnum<{
|
|
343
|
+
y: "y";
|
|
344
|
+
scale: "scale";
|
|
345
|
+
scaleX: "scaleX";
|
|
346
|
+
scaleY: "scaleY";
|
|
347
|
+
}>>;
|
|
348
|
+
minScale: z.ZodDefault<z.ZodNumber>;
|
|
349
|
+
maxScale: z.ZodDefault<z.ZodNumber>;
|
|
350
|
+
peakDecay: z.ZodDefault<z.ZodNumber>;
|
|
351
|
+
}, z.core.$strip>>;
|
|
352
|
+
spring: z.ZodOptional<z.ZodObject<{
|
|
353
|
+
stiffness: z.ZodDefault<z.ZodNumber>;
|
|
354
|
+
damping: z.ZodDefault<z.ZodNumber>;
|
|
355
|
+
mass: z.ZodDefault<z.ZodNumber>;
|
|
356
|
+
initialVelocity: z.ZodDefault<z.ZodNumber>;
|
|
357
|
+
overshootMultiplier: z.ZodDefault<z.ZodNumber>;
|
|
358
|
+
}, z.core.$strip>>;
|
|
359
|
+
}, z.core.$strip>;
|
|
360
|
+
type ExtendedGlyphProperties = z.infer<typeof ExtendedGlyphPropertiesSchema>;
|
|
361
|
+
declare const AdvancedTextAnimatorSchema: z.ZodObject<{
|
|
362
|
+
name: z.ZodDefault<z.ZodString>;
|
|
363
|
+
selectors: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
|
|
364
|
+
props: z.ZodObject<{
|
|
365
|
+
x: z.ZodOptional<z.ZodNumber>;
|
|
366
|
+
y: z.ZodOptional<z.ZodNumber>;
|
|
367
|
+
translateZ: z.ZodOptional<z.ZodNumber>;
|
|
368
|
+
scale: z.ZodOptional<z.ZodNumber>;
|
|
369
|
+
scaleX: z.ZodOptional<z.ZodNumber>;
|
|
370
|
+
scaleY: z.ZodOptional<z.ZodNumber>;
|
|
371
|
+
rotation: z.ZodOptional<z.ZodNumber>;
|
|
372
|
+
rotationX: z.ZodOptional<z.ZodNumber>;
|
|
373
|
+
rotationY: z.ZodOptional<z.ZodNumber>;
|
|
374
|
+
rotationZ: z.ZodOptional<z.ZodNumber>;
|
|
375
|
+
formation: z.ZodOptional<z.ZodObject<{
|
|
376
|
+
mode: z.ZodDefault<z.ZodEnum<{
|
|
377
|
+
planar: "planar";
|
|
378
|
+
vortex: "vortex";
|
|
379
|
+
cylinder: "cylinder";
|
|
380
|
+
helix: "helix";
|
|
381
|
+
}>>;
|
|
382
|
+
radius: z.ZodDefault<z.ZodNumber>;
|
|
383
|
+
pitch: z.ZodDefault<z.ZodNumber>;
|
|
384
|
+
totalAngle: z.ZodDefault<z.ZodNumber>;
|
|
385
|
+
axis: z.ZodDefault<z.ZodEnum<{
|
|
386
|
+
x: "x";
|
|
387
|
+
y: "y";
|
|
388
|
+
z: "z";
|
|
389
|
+
}>>;
|
|
390
|
+
perspective: z.ZodDefault<z.ZodNumber>;
|
|
391
|
+
}, z.core.$strip>>;
|
|
392
|
+
skew: z.ZodOptional<z.ZodNumber>;
|
|
393
|
+
skewAxis: z.ZodOptional<z.ZodNumber>;
|
|
394
|
+
tracking: z.ZodOptional<z.ZodNumber>;
|
|
395
|
+
lineSpacing: z.ZodOptional<z.ZodNumber>;
|
|
396
|
+
lineAnchor: z.ZodOptional<z.ZodNumber>;
|
|
397
|
+
anchor: z.ZodOptional<z.ZodObject<{
|
|
398
|
+
grouping: z.ZodDefault<z.ZodEnum<{
|
|
399
|
+
character: "character";
|
|
400
|
+
word: "word";
|
|
401
|
+
line: "line";
|
|
402
|
+
all: "all";
|
|
403
|
+
}>>;
|
|
404
|
+
preset: z.ZodDefault<z.ZodEnum<{
|
|
405
|
+
center: "center";
|
|
406
|
+
custom: "custom";
|
|
407
|
+
baseline: "baseline";
|
|
408
|
+
bottom_left: "bottom_left";
|
|
409
|
+
bottom_center: "bottom_center";
|
|
410
|
+
bottom_right: "bottom_right";
|
|
411
|
+
top_left: "top_left";
|
|
412
|
+
top_center: "top_center";
|
|
413
|
+
top_right: "top_right";
|
|
414
|
+
}>>;
|
|
415
|
+
anchorX: z.ZodDefault<z.ZodNumber>;
|
|
416
|
+
anchorY: z.ZodDefault<z.ZodNumber>;
|
|
417
|
+
offsetX: z.ZodDefault<z.ZodNumber>;
|
|
418
|
+
offsetY: z.ZodDefault<z.ZodNumber>;
|
|
419
|
+
}, z.core.$strip>>;
|
|
420
|
+
opacity: z.ZodOptional<z.ZodNumber>;
|
|
421
|
+
blur: z.ZodOptional<z.ZodNumber>;
|
|
422
|
+
fillColor: z.ZodOptional<z.ZodString>;
|
|
423
|
+
stroke: z.ZodOptional<z.ZodObject<{
|
|
424
|
+
strokeWidth: z.ZodDefault<z.ZodNumber>;
|
|
425
|
+
strokeColor: z.ZodDefault<z.ZodString>;
|
|
426
|
+
strokeAlign: z.ZodDefault<z.ZodEnum<{
|
|
427
|
+
inside: "inside";
|
|
428
|
+
center: "center";
|
|
429
|
+
outside: "outside";
|
|
430
|
+
}>>;
|
|
431
|
+
fillOpacity: z.ZodDefault<z.ZodNumber>;
|
|
432
|
+
dashArray: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
|
|
433
|
+
dashOffset: z.ZodDefault<z.ZodNumber>;
|
|
434
|
+
}, z.core.$strip>>;
|
|
435
|
+
variableAxes: z.ZodOptional<z.ZodObject<{
|
|
436
|
+
weight: z.ZodOptional<z.ZodNumber>;
|
|
437
|
+
width: z.ZodOptional<z.ZodNumber>;
|
|
438
|
+
slant: z.ZodOptional<z.ZodNumber>;
|
|
439
|
+
italic: z.ZodOptional<z.ZodNumber>;
|
|
440
|
+
opticalSize: z.ZodOptional<z.ZodNumber>;
|
|
441
|
+
}, z.core.$strip>>;
|
|
442
|
+
chromaticGlitch: z.ZodOptional<z.ZodObject<{
|
|
443
|
+
redShiftX: z.ZodDefault<z.ZodNumber>;
|
|
444
|
+
redShiftY: z.ZodDefault<z.ZodNumber>;
|
|
445
|
+
blueShiftX: z.ZodDefault<z.ZodNumber>;
|
|
446
|
+
blueShiftY: z.ZodDefault<z.ZodNumber>;
|
|
447
|
+
sliceProbability: z.ZodDefault<z.ZodNumber>;
|
|
448
|
+
sliceAmplitude: z.ZodDefault<z.ZodNumber>;
|
|
449
|
+
}, z.core.$strip>>;
|
|
450
|
+
longShadow: z.ZodOptional<z.ZodObject<{
|
|
451
|
+
angle: z.ZodDefault<z.ZodNumber>;
|
|
452
|
+
length: z.ZodDefault<z.ZodNumber>;
|
|
453
|
+
color: z.ZodDefault<z.ZodString>;
|
|
454
|
+
startOpacity: z.ZodDefault<z.ZodNumber>;
|
|
455
|
+
endOpacity: z.ZodDefault<z.ZodNumber>;
|
|
456
|
+
steps: z.ZodDefault<z.ZodNumber>;
|
|
457
|
+
}, z.core.$strip>>;
|
|
458
|
+
particleDissolve: z.ZodOptional<z.ZodObject<{
|
|
459
|
+
progress: z.ZodDefault<z.ZodNumber>;
|
|
460
|
+
dispersalAngle: z.ZodDefault<z.ZodNumber>;
|
|
461
|
+
maxDisplacement: z.ZodDefault<z.ZodNumber>;
|
|
462
|
+
turbulence: z.ZodDefault<z.ZodNumber>;
|
|
463
|
+
particleSize: z.ZodDefault<z.ZodNumber>;
|
|
464
|
+
}, z.core.$strip>>;
|
|
465
|
+
audioSpectrum: z.ZodOptional<z.ZodObject<{
|
|
466
|
+
signalChannel: z.ZodString;
|
|
467
|
+
minFreqHz: z.ZodDefault<z.ZodNumber>;
|
|
468
|
+
maxFreqHz: z.ZodDefault<z.ZodNumber>;
|
|
469
|
+
scaleAxis: z.ZodDefault<z.ZodEnum<{
|
|
470
|
+
y: "y";
|
|
471
|
+
scale: "scale";
|
|
472
|
+
scaleX: "scaleX";
|
|
473
|
+
scaleY: "scaleY";
|
|
474
|
+
}>>;
|
|
475
|
+
minScale: z.ZodDefault<z.ZodNumber>;
|
|
476
|
+
maxScale: z.ZodDefault<z.ZodNumber>;
|
|
477
|
+
peakDecay: z.ZodDefault<z.ZodNumber>;
|
|
478
|
+
}, z.core.$strip>>;
|
|
479
|
+
spring: z.ZodOptional<z.ZodObject<{
|
|
480
|
+
stiffness: z.ZodDefault<z.ZodNumber>;
|
|
481
|
+
damping: z.ZodDefault<z.ZodNumber>;
|
|
482
|
+
mass: z.ZodDefault<z.ZodNumber>;
|
|
483
|
+
initialVelocity: z.ZodDefault<z.ZodNumber>;
|
|
484
|
+
overshootMultiplier: z.ZodDefault<z.ZodNumber>;
|
|
485
|
+
}, z.core.$strip>>;
|
|
486
|
+
}, z.core.$strip>;
|
|
487
|
+
}, z.core.$strip>;
|
|
488
|
+
type AdvancedTextAnimator = z.infer<typeof AdvancedTextAnimatorSchema>;
|
|
489
|
+
//#endregion
|
|
490
|
+
//#region src/program/text-animations/advanced-builder.d.ts
|
|
491
|
+
/**
|
|
492
|
+
* Fluent Builder for Extended Text Animators.
|
|
493
|
+
*/
|
|
494
|
+
declare class AdvancedTextAnimatorBuilder {
|
|
495
|
+
private readonly name;
|
|
496
|
+
private props;
|
|
497
|
+
private selectors;
|
|
498
|
+
constructor(name: string);
|
|
499
|
+
static create(name: string): AdvancedTextAnimatorBuilder;
|
|
500
|
+
/** Directional Skew */
|
|
501
|
+
skew(angleDeg: number, axisDeg?: number): this;
|
|
502
|
+
/** Anchor Point Grouping and Preset Pivot */
|
|
503
|
+
anchor(preset: AnchorPreset, grouping?: AnchorGrouping, offsetX?: number, offsetY?: number): this;
|
|
504
|
+
/** Custom Anchor Point Coordinates (0 to 1 normalized) */
|
|
505
|
+
anchorNormalized(ax: number, ay: number, grouping?: AnchorGrouping): this;
|
|
506
|
+
/** 3D Spatial Z-Depth */
|
|
507
|
+
translateZ(zPixels: number): this;
|
|
508
|
+
/** 3D Tilts */
|
|
509
|
+
tilt3D(rx?: number, ry?: number, rz?: number): this;
|
|
510
|
+
/** 3D Rotation along X axis */
|
|
511
|
+
rotationX(deg: number): this;
|
|
512
|
+
/** 3D Rotation along Y axis */
|
|
513
|
+
rotationY(deg: number): this;
|
|
514
|
+
/** 3D Rotation along Z axis */
|
|
515
|
+
rotationZ(deg: number): this;
|
|
516
|
+
/** 3D Volumetric Formations */
|
|
517
|
+
volumetricFormation(mode?: VolumetricFormationMode, radius?: number, pitch?: number, totalAngle?: number, perspective?: number, axis?: "x" | "y" | "z"): this;
|
|
518
|
+
/** Dynamic Line Spacing (Leading) */
|
|
519
|
+
lineSpacing(extraLeadingPixels: number, lineAnchor?: number): this;
|
|
520
|
+
/** Normalized Line Anchor (0=top, 0.5=center, 1=bottom) */
|
|
521
|
+
lineAnchor(anchor: number): this;
|
|
522
|
+
/** Inertial Spring Settling Physics */
|
|
523
|
+
spring(stiffness?: number, damping?: number, mass?: number, initialVelocity?: number): this;
|
|
524
|
+
/** Dynamic Stroke & Wireframe Properties */
|
|
525
|
+
stroke(widthPixels: number, color?: string, fillOpacity?: number): this;
|
|
526
|
+
/** Variable Font Axes */
|
|
527
|
+
variableFont(axes: VariableFontAxes): this;
|
|
528
|
+
/** Chromatic Aberration / Cyberpunk Glitch */
|
|
529
|
+
chromaticGlitch(redShiftX: number, redShiftY?: number, blueShiftX?: number, blueShiftY?: number): this;
|
|
530
|
+
/** Multi-Band Audio Spectrum Equalizer */
|
|
531
|
+
audioSpectrum(signalChannel: string, minFreqHz?: number, maxFreqHz?: number, maxScale?: number): this;
|
|
532
|
+
/** Long Shadow Extrusion */
|
|
533
|
+
longShadow(angle?: number, length?: number, color?: string, startOpacity?: number, endOpacity?: number, steps?: number): this;
|
|
534
|
+
/** Particle Dust / Quantum Dissolve */
|
|
535
|
+
particleDissolve(progress?: number, dispersalAngle?: number, maxDisplacement?: number): this;
|
|
536
|
+
/** Add Expression Selector */
|
|
537
|
+
addExpressionSelector(expression: string, mode?: "add" | "subtract" | "intersect"): this;
|
|
538
|
+
/** Alias for addExpressionSelector */
|
|
539
|
+
expressionSelector(expression: string, mode?: "add" | "subtract" | "intersect"): this;
|
|
540
|
+
/** Standard 2D Transforms */
|
|
541
|
+
x(v: number): this;
|
|
542
|
+
y(v: number): this;
|
|
543
|
+
scale(v: number): this;
|
|
544
|
+
scaleX(v: number): this;
|
|
545
|
+
scaleY(v: number): this;
|
|
546
|
+
rotation(deg: number): this;
|
|
547
|
+
opacity(v: number): this;
|
|
548
|
+
blur(v: number): this;
|
|
549
|
+
fillColor(hex: string): this;
|
|
550
|
+
build(): {
|
|
551
|
+
name: string;
|
|
552
|
+
selectors: (ExpressionSelector | Record<string, unknown>)[];
|
|
553
|
+
props: ExtendedGlyphProperties;
|
|
554
|
+
};
|
|
555
|
+
}
|
|
556
|
+
//#endregion
|
|
557
|
+
//#region src/program/text-animations/types.d.ts
|
|
558
|
+
declare const Vec2Schema: z.ZodObject<{
|
|
559
|
+
x: z.ZodNumber;
|
|
560
|
+
y: z.ZodNumber;
|
|
561
|
+
}, z.core.$strip>;
|
|
562
|
+
type Vec2 = z.infer<typeof Vec2Schema>;
|
|
563
|
+
declare const CubicBezierSegmentSchema: z.ZodObject<{
|
|
564
|
+
p0: z.ZodObject<{
|
|
565
|
+
x: z.ZodNumber;
|
|
566
|
+
y: z.ZodNumber;
|
|
567
|
+
}, z.core.$strip>;
|
|
568
|
+
p1: z.ZodObject<{
|
|
569
|
+
x: z.ZodNumber;
|
|
570
|
+
y: z.ZodNumber;
|
|
571
|
+
}, z.core.$strip>;
|
|
572
|
+
p2: z.ZodObject<{
|
|
573
|
+
x: z.ZodNumber;
|
|
574
|
+
y: z.ZodNumber;
|
|
575
|
+
}, z.core.$strip>;
|
|
576
|
+
p3: z.ZodObject<{
|
|
577
|
+
x: z.ZodNumber;
|
|
578
|
+
y: z.ZodNumber;
|
|
579
|
+
}, z.core.$strip>;
|
|
580
|
+
}, z.core.$strip>;
|
|
581
|
+
type CubicBezierSegment = z.infer<typeof CubicBezierSegmentSchema>;
|
|
582
|
+
declare const TextPathSourceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
583
|
+
type: z.ZodLiteral<"svg">;
|
|
584
|
+
d: z.ZodString;
|
|
585
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
586
|
+
type: z.ZodLiteral<"bezier">;
|
|
587
|
+
segments: z.ZodArray<z.ZodObject<{
|
|
588
|
+
p0: z.ZodObject<{
|
|
589
|
+
x: z.ZodNumber;
|
|
590
|
+
y: z.ZodNumber;
|
|
591
|
+
}, z.core.$strip>;
|
|
592
|
+
p1: z.ZodObject<{
|
|
593
|
+
x: z.ZodNumber;
|
|
594
|
+
y: z.ZodNumber;
|
|
595
|
+
}, z.core.$strip>;
|
|
596
|
+
p2: z.ZodObject<{
|
|
597
|
+
x: z.ZodNumber;
|
|
598
|
+
y: z.ZodNumber;
|
|
599
|
+
}, z.core.$strip>;
|
|
600
|
+
p3: z.ZodObject<{
|
|
601
|
+
x: z.ZodNumber;
|
|
602
|
+
y: z.ZodNumber;
|
|
603
|
+
}, z.core.$strip>;
|
|
604
|
+
}, z.core.$strip>>;
|
|
605
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
606
|
+
type: z.ZodLiteral<"ellipse">;
|
|
607
|
+
cx: z.ZodNumber;
|
|
608
|
+
cy: z.ZodNumber;
|
|
609
|
+
rx: z.ZodNumber;
|
|
610
|
+
ry: z.ZodNumber;
|
|
611
|
+
startAngleDeg: z.ZodDefault<z.ZodNumber>;
|
|
612
|
+
endAngleDeg: z.ZodDefault<z.ZodNumber>;
|
|
613
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
614
|
+
type: z.ZodLiteral<"wave">;
|
|
615
|
+
startX: z.ZodNumber;
|
|
616
|
+
startY: z.ZodNumber;
|
|
617
|
+
length: z.ZodNumber;
|
|
618
|
+
amplitude: z.ZodNumber;
|
|
619
|
+
frequency: z.ZodNumber;
|
|
620
|
+
phaseDeg: z.ZodDefault<z.ZodNumber>;
|
|
621
|
+
}, z.core.$strip>], "type">;
|
|
622
|
+
type TextPathSource = z.infer<typeof TextPathSourceSchema>;
|
|
623
|
+
declare const TextPathOptionsSchema: z.ZodObject<{
|
|
624
|
+
path: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
625
|
+
type: z.ZodLiteral<"svg">;
|
|
626
|
+
d: z.ZodString;
|
|
627
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
628
|
+
type: z.ZodLiteral<"bezier">;
|
|
629
|
+
segments: z.ZodArray<z.ZodObject<{
|
|
630
|
+
p0: z.ZodObject<{
|
|
631
|
+
x: z.ZodNumber;
|
|
632
|
+
y: z.ZodNumber;
|
|
633
|
+
}, z.core.$strip>;
|
|
634
|
+
p1: z.ZodObject<{
|
|
635
|
+
x: z.ZodNumber;
|
|
636
|
+
y: z.ZodNumber;
|
|
637
|
+
}, z.core.$strip>;
|
|
638
|
+
p2: z.ZodObject<{
|
|
639
|
+
x: z.ZodNumber;
|
|
640
|
+
y: z.ZodNumber;
|
|
641
|
+
}, z.core.$strip>;
|
|
642
|
+
p3: z.ZodObject<{
|
|
643
|
+
x: z.ZodNumber;
|
|
644
|
+
y: z.ZodNumber;
|
|
645
|
+
}, z.core.$strip>;
|
|
646
|
+
}, z.core.$strip>>;
|
|
647
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
648
|
+
type: z.ZodLiteral<"ellipse">;
|
|
649
|
+
cx: z.ZodNumber;
|
|
650
|
+
cy: z.ZodNumber;
|
|
651
|
+
rx: z.ZodNumber;
|
|
652
|
+
ry: z.ZodNumber;
|
|
653
|
+
startAngleDeg: z.ZodDefault<z.ZodNumber>;
|
|
654
|
+
endAngleDeg: z.ZodDefault<z.ZodNumber>;
|
|
655
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
656
|
+
type: z.ZodLiteral<"wave">;
|
|
657
|
+
startX: z.ZodNumber;
|
|
658
|
+
startY: z.ZodNumber;
|
|
659
|
+
length: z.ZodNumber;
|
|
660
|
+
amplitude: z.ZodNumber;
|
|
661
|
+
frequency: z.ZodNumber;
|
|
662
|
+
phaseDeg: z.ZodDefault<z.ZodNumber>;
|
|
663
|
+
}, z.core.$strip>], "type">;
|
|
664
|
+
firstMargin: z.ZodDefault<z.ZodNumber>;
|
|
665
|
+
lastMargin: z.ZodDefault<z.ZodNumber>;
|
|
666
|
+
reversePath: z.ZodDefault<z.ZodBoolean>;
|
|
667
|
+
perpendicularToPath: z.ZodDefault<z.ZodBoolean>;
|
|
668
|
+
forceAlignment: z.ZodDefault<z.ZodBoolean>;
|
|
669
|
+
loop: z.ZodDefault<z.ZodBoolean>;
|
|
670
|
+
baselineOffset: z.ZodDefault<z.ZodEnum<{
|
|
671
|
+
center: "center";
|
|
672
|
+
baseline: "baseline";
|
|
673
|
+
ascender: "ascender";
|
|
674
|
+
descender: "descender";
|
|
675
|
+
}>>;
|
|
676
|
+
baselineShift: z.ZodDefault<z.ZodNumber>;
|
|
677
|
+
}, z.core.$strip>;
|
|
678
|
+
type TextPathOptions = z.infer<typeof TextPathOptionsSchema>;
|
|
679
|
+
declare const TextCursorStyleSchema: z.ZodEnum<{
|
|
680
|
+
custom: "custom";
|
|
681
|
+
bar: "bar";
|
|
682
|
+
underscore: "underscore";
|
|
683
|
+
block: "block";
|
|
684
|
+
}>;
|
|
685
|
+
type TextCursorStyle = z.infer<typeof TextCursorStyleSchema>;
|
|
686
|
+
declare const TextCursorConfigSchema: z.ZodObject<{
|
|
687
|
+
enabled: z.ZodDefault<z.ZodBoolean>;
|
|
688
|
+
style: z.ZodDefault<z.ZodEnum<{
|
|
689
|
+
custom: "custom";
|
|
690
|
+
bar: "bar";
|
|
691
|
+
underscore: "underscore";
|
|
692
|
+
block: "block";
|
|
693
|
+
}>>;
|
|
694
|
+
customChar: z.ZodDefault<z.ZodString>;
|
|
695
|
+
color: z.ZodOptional<z.ZodString>;
|
|
696
|
+
blinkFrequency: z.ZodDefault<z.ZodNumber>;
|
|
697
|
+
hideOnComplete: z.ZodDefault<z.ZodBoolean>;
|
|
698
|
+
width: z.ZodDefault<z.ZodNumber>;
|
|
699
|
+
spacing: z.ZodDefault<z.ZodNumber>;
|
|
700
|
+
}, z.core.$strip>;
|
|
701
|
+
type TextCursorConfig = z.infer<typeof TextCursorConfigSchema>;
|
|
702
|
+
declare const TypingCadenceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
703
|
+
mode: z.ZodLiteral<"constant">;
|
|
704
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
705
|
+
mode: z.ZodLiteral<"human">;
|
|
706
|
+
jitter: z.ZodDefault<z.ZodNumber>;
|
|
707
|
+
commaPauseMultiplier: z.ZodDefault<z.ZodNumber>;
|
|
708
|
+
sentencePauseMultiplier: z.ZodDefault<z.ZodNumber>;
|
|
709
|
+
paragraphPauseMultiplier: z.ZodDefault<z.ZodNumber>;
|
|
710
|
+
}, z.core.$strip>], "mode">;
|
|
711
|
+
type TypingCadence = z.infer<typeof TypingCadenceSchema>;
|
|
712
|
+
declare const TextScrambleConfigSchema: z.ZodObject<{
|
|
713
|
+
enabled: z.ZodDefault<z.ZodBoolean>;
|
|
714
|
+
charset: z.ZodDefault<z.ZodEnum<{
|
|
715
|
+
custom: "custom";
|
|
716
|
+
ascii: "ascii";
|
|
717
|
+
alphanumeric: "alphanumeric";
|
|
718
|
+
matrix: "matrix";
|
|
719
|
+
binary: "binary";
|
|
720
|
+
hex: "hex";
|
|
721
|
+
}>>;
|
|
722
|
+
customCharset: z.ZodOptional<z.ZodString>;
|
|
723
|
+
scrambleFramesPerChar: z.ZodDefault<z.ZodNumber>;
|
|
724
|
+
highlightProbability: z.ZodDefault<z.ZodNumber>;
|
|
725
|
+
scrambleColor: z.ZodOptional<z.ZodString>;
|
|
726
|
+
}, z.core.$strip>;
|
|
727
|
+
type TextScrambleConfig = z.infer<typeof TextScrambleConfigSchema>;
|
|
728
|
+
declare const TypewriterAnimatorSchema: z.ZodObject<{
|
|
729
|
+
granularity: z.ZodDefault<z.ZodEnum<{
|
|
730
|
+
character: "character";
|
|
731
|
+
word: "word";
|
|
732
|
+
line: "line";
|
|
733
|
+
}>>;
|
|
734
|
+
cursor: z.ZodDefault<z.ZodObject<{
|
|
735
|
+
enabled: z.ZodDefault<z.ZodBoolean>;
|
|
736
|
+
style: z.ZodDefault<z.ZodEnum<{
|
|
737
|
+
custom: "custom";
|
|
738
|
+
bar: "bar";
|
|
739
|
+
underscore: "underscore";
|
|
740
|
+
block: "block";
|
|
741
|
+
}>>;
|
|
742
|
+
customChar: z.ZodDefault<z.ZodString>;
|
|
743
|
+
color: z.ZodOptional<z.ZodString>;
|
|
744
|
+
blinkFrequency: z.ZodDefault<z.ZodNumber>;
|
|
745
|
+
hideOnComplete: z.ZodDefault<z.ZodBoolean>;
|
|
746
|
+
width: z.ZodDefault<z.ZodNumber>;
|
|
747
|
+
spacing: z.ZodDefault<z.ZodNumber>;
|
|
748
|
+
}, z.core.$strip>>;
|
|
749
|
+
cadence: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
750
|
+
mode: z.ZodLiteral<"constant">;
|
|
751
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
752
|
+
mode: z.ZodLiteral<"human">;
|
|
753
|
+
jitter: z.ZodDefault<z.ZodNumber>;
|
|
754
|
+
commaPauseMultiplier: z.ZodDefault<z.ZodNumber>;
|
|
755
|
+
sentencePauseMultiplier: z.ZodDefault<z.ZodNumber>;
|
|
756
|
+
paragraphPauseMultiplier: z.ZodDefault<z.ZodNumber>;
|
|
757
|
+
}, z.core.$strip>], "mode">>;
|
|
758
|
+
scramble: z.ZodDefault<z.ZodObject<{
|
|
759
|
+
enabled: z.ZodDefault<z.ZodBoolean>;
|
|
760
|
+
charset: z.ZodDefault<z.ZodEnum<{
|
|
761
|
+
custom: "custom";
|
|
762
|
+
ascii: "ascii";
|
|
763
|
+
alphanumeric: "alphanumeric";
|
|
764
|
+
matrix: "matrix";
|
|
765
|
+
binary: "binary";
|
|
766
|
+
hex: "hex";
|
|
767
|
+
}>>;
|
|
768
|
+
customCharset: z.ZodOptional<z.ZodString>;
|
|
769
|
+
scrambleFramesPerChar: z.ZodDefault<z.ZodNumber>;
|
|
770
|
+
highlightProbability: z.ZodDefault<z.ZodNumber>;
|
|
771
|
+
scrambleColor: z.ZodOptional<z.ZodString>;
|
|
772
|
+
}, z.core.$strip>>;
|
|
773
|
+
soundSync: z.ZodDefault<z.ZodBoolean>;
|
|
774
|
+
}, z.core.$strip>;
|
|
775
|
+
type TypewriterAnimator = z.infer<typeof TypewriterAnimatorSchema>;
|
|
776
|
+
declare const SelectorBasedOnSchema: z.ZodEnum<{
|
|
777
|
+
characters: "characters";
|
|
778
|
+
characters_excluding_spaces: "characters_excluding_spaces";
|
|
779
|
+
words: "words";
|
|
780
|
+
lines: "lines";
|
|
781
|
+
}>;
|
|
782
|
+
type SelectorBasedOn = z.infer<typeof SelectorBasedOnSchema>;
|
|
783
|
+
declare const SelectorUnitsSchema: z.ZodEnum<{
|
|
784
|
+
percentage: "percentage";
|
|
785
|
+
index: "index";
|
|
786
|
+
}>;
|
|
787
|
+
type SelectorUnits = z.infer<typeof SelectorUnitsSchema>;
|
|
788
|
+
declare const SelectorShapeSchema: z.ZodEnum<{
|
|
789
|
+
round: "round";
|
|
790
|
+
square: "square";
|
|
791
|
+
ramp_up: "ramp_up";
|
|
792
|
+
ramp_down: "ramp_down";
|
|
793
|
+
triangle: "triangle";
|
|
794
|
+
smooth: "smooth";
|
|
795
|
+
}>;
|
|
796
|
+
type SelectorShape = z.infer<typeof SelectorShapeSchema>;
|
|
797
|
+
declare const SelectorModeSchema: z.ZodEnum<{
|
|
798
|
+
difference: "difference";
|
|
799
|
+
add: "add";
|
|
800
|
+
subtract: "subtract";
|
|
801
|
+
intersect: "intersect";
|
|
802
|
+
min: "min";
|
|
803
|
+
max: "max";
|
|
804
|
+
}>;
|
|
805
|
+
type SelectorMode = z.infer<typeof SelectorModeSchema>;
|
|
806
|
+
declare const TextRangeSelectorSchema: z.ZodObject<{
|
|
807
|
+
type: z.ZodLiteral<"range">;
|
|
808
|
+
start: z.ZodDefault<z.ZodNumber>;
|
|
809
|
+
end: z.ZodDefault<z.ZodNumber>;
|
|
810
|
+
offset: z.ZodDefault<z.ZodNumber>;
|
|
811
|
+
units: z.ZodDefault<z.ZodEnum<{
|
|
812
|
+
percentage: "percentage";
|
|
813
|
+
index: "index";
|
|
814
|
+
}>>;
|
|
815
|
+
basedOn: z.ZodDefault<z.ZodEnum<{
|
|
816
|
+
characters: "characters";
|
|
817
|
+
characters_excluding_spaces: "characters_excluding_spaces";
|
|
818
|
+
words: "words";
|
|
819
|
+
lines: "lines";
|
|
820
|
+
}>>;
|
|
821
|
+
shape: z.ZodDefault<z.ZodEnum<{
|
|
822
|
+
round: "round";
|
|
823
|
+
square: "square";
|
|
824
|
+
ramp_up: "ramp_up";
|
|
825
|
+
ramp_down: "ramp_down";
|
|
826
|
+
triangle: "triangle";
|
|
827
|
+
smooth: "smooth";
|
|
828
|
+
}>>;
|
|
829
|
+
mode: z.ZodDefault<z.ZodEnum<{
|
|
830
|
+
difference: "difference";
|
|
831
|
+
add: "add";
|
|
832
|
+
subtract: "subtract";
|
|
833
|
+
intersect: "intersect";
|
|
834
|
+
min: "min";
|
|
835
|
+
max: "max";
|
|
836
|
+
}>>;
|
|
837
|
+
amount: z.ZodDefault<z.ZodNumber>;
|
|
838
|
+
easeHigh: z.ZodDefault<z.ZodNumber>;
|
|
839
|
+
easeLow: z.ZodDefault<z.ZodNumber>;
|
|
840
|
+
randomizeOrder: z.ZodDefault<z.ZodBoolean>;
|
|
841
|
+
randomSeed: z.ZodDefault<z.ZodNumber>;
|
|
842
|
+
}, z.core.$strip>;
|
|
843
|
+
type TextRangeSelector = z.infer<typeof TextRangeSelectorSchema>;
|
|
844
|
+
declare const TextWigglySelectorSchema: z.ZodObject<{
|
|
845
|
+
type: z.ZodLiteral<"wiggly">;
|
|
846
|
+
wigglesPerSecond: z.ZodDefault<z.ZodNumber>;
|
|
847
|
+
correlation: z.ZodDefault<z.ZodNumber>;
|
|
848
|
+
temporalPhaseDeg: z.ZodDefault<z.ZodNumber>;
|
|
849
|
+
spatialPhaseDeg: z.ZodDefault<z.ZodNumber>;
|
|
850
|
+
minAmount: z.ZodDefault<z.ZodNumber>;
|
|
851
|
+
maxAmount: z.ZodDefault<z.ZodNumber>;
|
|
852
|
+
randomSeed: z.ZodDefault<z.ZodNumber>;
|
|
853
|
+
basedOn: z.ZodDefault<z.ZodEnum<{
|
|
854
|
+
characters: "characters";
|
|
855
|
+
characters_excluding_spaces: "characters_excluding_spaces";
|
|
856
|
+
words: "words";
|
|
857
|
+
lines: "lines";
|
|
858
|
+
}>>;
|
|
859
|
+
mode: z.ZodDefault<z.ZodEnum<{
|
|
860
|
+
difference: "difference";
|
|
861
|
+
add: "add";
|
|
862
|
+
subtract: "subtract";
|
|
863
|
+
intersect: "intersect";
|
|
864
|
+
min: "min";
|
|
865
|
+
max: "max";
|
|
866
|
+
}>>;
|
|
867
|
+
}, z.core.$strip>;
|
|
868
|
+
type TextWigglySelector = z.infer<typeof TextWigglySelectorSchema>;
|
|
869
|
+
declare const TextSignalSelectorSchema: z.ZodObject<{
|
|
870
|
+
type: z.ZodLiteral<"signal">;
|
|
871
|
+
signalId: z.ZodString;
|
|
872
|
+
multiplier: z.ZodDefault<z.ZodNumber>;
|
|
873
|
+
offset: z.ZodDefault<z.ZodNumber>;
|
|
874
|
+
phaseSpread: z.ZodDefault<z.ZodNumber>;
|
|
875
|
+
basedOn: z.ZodDefault<z.ZodEnum<{
|
|
876
|
+
characters: "characters";
|
|
877
|
+
characters_excluding_spaces: "characters_excluding_spaces";
|
|
878
|
+
words: "words";
|
|
879
|
+
lines: "lines";
|
|
880
|
+
}>>;
|
|
881
|
+
mode: z.ZodDefault<z.ZodEnum<{
|
|
882
|
+
difference: "difference";
|
|
883
|
+
add: "add";
|
|
884
|
+
subtract: "subtract";
|
|
885
|
+
intersect: "intersect";
|
|
886
|
+
min: "min";
|
|
887
|
+
max: "max";
|
|
888
|
+
}>>;
|
|
889
|
+
}, z.core.$strip>;
|
|
890
|
+
type TextSignalSelector = z.infer<typeof TextSignalSelectorSchema>;
|
|
891
|
+
declare const TextSelectorSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
892
|
+
type: z.ZodLiteral<"range">;
|
|
893
|
+
start: z.ZodDefault<z.ZodNumber>;
|
|
894
|
+
end: z.ZodDefault<z.ZodNumber>;
|
|
895
|
+
offset: z.ZodDefault<z.ZodNumber>;
|
|
896
|
+
units: z.ZodDefault<z.ZodEnum<{
|
|
897
|
+
percentage: "percentage";
|
|
898
|
+
index: "index";
|
|
899
|
+
}>>;
|
|
900
|
+
basedOn: z.ZodDefault<z.ZodEnum<{
|
|
901
|
+
characters: "characters";
|
|
902
|
+
characters_excluding_spaces: "characters_excluding_spaces";
|
|
903
|
+
words: "words";
|
|
904
|
+
lines: "lines";
|
|
905
|
+
}>>;
|
|
906
|
+
shape: z.ZodDefault<z.ZodEnum<{
|
|
907
|
+
round: "round";
|
|
908
|
+
square: "square";
|
|
909
|
+
ramp_up: "ramp_up";
|
|
910
|
+
ramp_down: "ramp_down";
|
|
911
|
+
triangle: "triangle";
|
|
912
|
+
smooth: "smooth";
|
|
913
|
+
}>>;
|
|
914
|
+
mode: z.ZodDefault<z.ZodEnum<{
|
|
915
|
+
difference: "difference";
|
|
916
|
+
add: "add";
|
|
917
|
+
subtract: "subtract";
|
|
918
|
+
intersect: "intersect";
|
|
919
|
+
min: "min";
|
|
920
|
+
max: "max";
|
|
921
|
+
}>>;
|
|
922
|
+
amount: z.ZodDefault<z.ZodNumber>;
|
|
923
|
+
easeHigh: z.ZodDefault<z.ZodNumber>;
|
|
924
|
+
easeLow: z.ZodDefault<z.ZodNumber>;
|
|
925
|
+
randomizeOrder: z.ZodDefault<z.ZodBoolean>;
|
|
926
|
+
randomSeed: z.ZodDefault<z.ZodNumber>;
|
|
927
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
928
|
+
type: z.ZodLiteral<"wiggly">;
|
|
929
|
+
wigglesPerSecond: z.ZodDefault<z.ZodNumber>;
|
|
930
|
+
correlation: z.ZodDefault<z.ZodNumber>;
|
|
931
|
+
temporalPhaseDeg: z.ZodDefault<z.ZodNumber>;
|
|
932
|
+
spatialPhaseDeg: z.ZodDefault<z.ZodNumber>;
|
|
933
|
+
minAmount: z.ZodDefault<z.ZodNumber>;
|
|
934
|
+
maxAmount: z.ZodDefault<z.ZodNumber>;
|
|
935
|
+
randomSeed: z.ZodDefault<z.ZodNumber>;
|
|
936
|
+
basedOn: z.ZodDefault<z.ZodEnum<{
|
|
937
|
+
characters: "characters";
|
|
938
|
+
characters_excluding_spaces: "characters_excluding_spaces";
|
|
939
|
+
words: "words";
|
|
940
|
+
lines: "lines";
|
|
941
|
+
}>>;
|
|
942
|
+
mode: z.ZodDefault<z.ZodEnum<{
|
|
943
|
+
difference: "difference";
|
|
944
|
+
add: "add";
|
|
945
|
+
subtract: "subtract";
|
|
946
|
+
intersect: "intersect";
|
|
947
|
+
min: "min";
|
|
948
|
+
max: "max";
|
|
949
|
+
}>>;
|
|
950
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
951
|
+
type: z.ZodLiteral<"signal">;
|
|
952
|
+
signalId: z.ZodString;
|
|
953
|
+
multiplier: z.ZodDefault<z.ZodNumber>;
|
|
954
|
+
offset: z.ZodDefault<z.ZodNumber>;
|
|
955
|
+
phaseSpread: z.ZodDefault<z.ZodNumber>;
|
|
956
|
+
basedOn: z.ZodDefault<z.ZodEnum<{
|
|
957
|
+
characters: "characters";
|
|
958
|
+
characters_excluding_spaces: "characters_excluding_spaces";
|
|
959
|
+
words: "words";
|
|
960
|
+
lines: "lines";
|
|
961
|
+
}>>;
|
|
962
|
+
mode: z.ZodDefault<z.ZodEnum<{
|
|
963
|
+
difference: "difference";
|
|
964
|
+
add: "add";
|
|
965
|
+
subtract: "subtract";
|
|
966
|
+
intersect: "intersect";
|
|
967
|
+
min: "min";
|
|
968
|
+
max: "max";
|
|
969
|
+
}>>;
|
|
970
|
+
}, z.core.$strip>], "type">;
|
|
971
|
+
type TextSelector = z.infer<typeof TextSelectorSchema>;
|
|
972
|
+
declare const AnimatableGlyphPropsSchema: z.ZodObject<{
|
|
973
|
+
x: z.ZodOptional<z.ZodNumber>;
|
|
974
|
+
y: z.ZodOptional<z.ZodNumber>;
|
|
975
|
+
z: z.ZodOptional<z.ZodNumber>;
|
|
976
|
+
scale: z.ZodOptional<z.ZodNumber>;
|
|
977
|
+
scaleX: z.ZodOptional<z.ZodNumber>;
|
|
978
|
+
scaleY: z.ZodOptional<z.ZodNumber>;
|
|
979
|
+
rotation: z.ZodOptional<z.ZodNumber>;
|
|
980
|
+
rotationX: z.ZodOptional<z.ZodNumber>;
|
|
981
|
+
rotationY: z.ZodOptional<z.ZodNumber>;
|
|
982
|
+
skew: z.ZodOptional<z.ZodNumber>;
|
|
983
|
+
skewAxis: z.ZodOptional<z.ZodNumber>;
|
|
984
|
+
tracking: z.ZodOptional<z.ZodNumber>;
|
|
985
|
+
lineSpacing: z.ZodOptional<z.ZodNumber>;
|
|
986
|
+
opacity: z.ZodOptional<z.ZodNumber>;
|
|
987
|
+
fillColor: z.ZodOptional<z.ZodString>;
|
|
988
|
+
strokeColor: z.ZodOptional<z.ZodString>;
|
|
989
|
+
strokeWidth: z.ZodOptional<z.ZodNumber>;
|
|
990
|
+
blur: z.ZodOptional<z.ZodNumber>;
|
|
991
|
+
characterOffset: z.ZodOptional<z.ZodNumber>;
|
|
992
|
+
}, z.core.$strip>;
|
|
993
|
+
type AnimatableGlyphProps = z.infer<typeof AnimatableGlyphPropsSchema>;
|
|
994
|
+
declare const GlyphAnchorGroupingSchema: z.ZodEnum<{
|
|
995
|
+
character: "character";
|
|
996
|
+
word: "word";
|
|
997
|
+
line: "line";
|
|
998
|
+
all: "all";
|
|
999
|
+
}>;
|
|
1000
|
+
type GlyphAnchorGrouping = z.infer<typeof GlyphAnchorGroupingSchema>;
|
|
1001
|
+
declare const GlyphAnchorPointSchema: z.ZodObject<{
|
|
1002
|
+
grouping: z.ZodDefault<z.ZodEnum<{
|
|
1003
|
+
character: "character";
|
|
1004
|
+
word: "word";
|
|
1005
|
+
line: "line";
|
|
1006
|
+
all: "all";
|
|
1007
|
+
}>>;
|
|
1008
|
+
anchorX: z.ZodDefault<z.ZodNumber>;
|
|
1009
|
+
anchorY: z.ZodDefault<z.ZodNumber>;
|
|
1010
|
+
}, z.core.$strip>;
|
|
1011
|
+
type GlyphAnchorPoint = z.infer<typeof GlyphAnchorPointSchema>;
|
|
1012
|
+
declare const AETextAnimatorSchema: z.ZodObject<{
|
|
1013
|
+
name: z.ZodDefault<z.ZodString>;
|
|
1014
|
+
selectors: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1015
|
+
type: z.ZodLiteral<"range">;
|
|
1016
|
+
start: z.ZodDefault<z.ZodNumber>;
|
|
1017
|
+
end: z.ZodDefault<z.ZodNumber>;
|
|
1018
|
+
offset: z.ZodDefault<z.ZodNumber>;
|
|
1019
|
+
units: z.ZodDefault<z.ZodEnum<{
|
|
1020
|
+
percentage: "percentage";
|
|
1021
|
+
index: "index";
|
|
1022
|
+
}>>;
|
|
1023
|
+
basedOn: z.ZodDefault<z.ZodEnum<{
|
|
1024
|
+
characters: "characters";
|
|
1025
|
+
characters_excluding_spaces: "characters_excluding_spaces";
|
|
1026
|
+
words: "words";
|
|
1027
|
+
lines: "lines";
|
|
1028
|
+
}>>;
|
|
1029
|
+
shape: z.ZodDefault<z.ZodEnum<{
|
|
1030
|
+
round: "round";
|
|
1031
|
+
square: "square";
|
|
1032
|
+
ramp_up: "ramp_up";
|
|
1033
|
+
ramp_down: "ramp_down";
|
|
1034
|
+
triangle: "triangle";
|
|
1035
|
+
smooth: "smooth";
|
|
1036
|
+
}>>;
|
|
1037
|
+
mode: z.ZodDefault<z.ZodEnum<{
|
|
1038
|
+
difference: "difference";
|
|
1039
|
+
add: "add";
|
|
1040
|
+
subtract: "subtract";
|
|
1041
|
+
intersect: "intersect";
|
|
1042
|
+
min: "min";
|
|
1043
|
+
max: "max";
|
|
1044
|
+
}>>;
|
|
1045
|
+
amount: z.ZodDefault<z.ZodNumber>;
|
|
1046
|
+
easeHigh: z.ZodDefault<z.ZodNumber>;
|
|
1047
|
+
easeLow: z.ZodDefault<z.ZodNumber>;
|
|
1048
|
+
randomizeOrder: z.ZodDefault<z.ZodBoolean>;
|
|
1049
|
+
randomSeed: z.ZodDefault<z.ZodNumber>;
|
|
1050
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1051
|
+
type: z.ZodLiteral<"wiggly">;
|
|
1052
|
+
wigglesPerSecond: z.ZodDefault<z.ZodNumber>;
|
|
1053
|
+
correlation: z.ZodDefault<z.ZodNumber>;
|
|
1054
|
+
temporalPhaseDeg: z.ZodDefault<z.ZodNumber>;
|
|
1055
|
+
spatialPhaseDeg: z.ZodDefault<z.ZodNumber>;
|
|
1056
|
+
minAmount: z.ZodDefault<z.ZodNumber>;
|
|
1057
|
+
maxAmount: z.ZodDefault<z.ZodNumber>;
|
|
1058
|
+
randomSeed: z.ZodDefault<z.ZodNumber>;
|
|
1059
|
+
basedOn: z.ZodDefault<z.ZodEnum<{
|
|
1060
|
+
characters: "characters";
|
|
1061
|
+
characters_excluding_spaces: "characters_excluding_spaces";
|
|
1062
|
+
words: "words";
|
|
1063
|
+
lines: "lines";
|
|
1064
|
+
}>>;
|
|
1065
|
+
mode: z.ZodDefault<z.ZodEnum<{
|
|
1066
|
+
difference: "difference";
|
|
1067
|
+
add: "add";
|
|
1068
|
+
subtract: "subtract";
|
|
1069
|
+
intersect: "intersect";
|
|
1070
|
+
min: "min";
|
|
1071
|
+
max: "max";
|
|
1072
|
+
}>>;
|
|
1073
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1074
|
+
type: z.ZodLiteral<"signal">;
|
|
1075
|
+
signalId: z.ZodString;
|
|
1076
|
+
multiplier: z.ZodDefault<z.ZodNumber>;
|
|
1077
|
+
offset: z.ZodDefault<z.ZodNumber>;
|
|
1078
|
+
phaseSpread: z.ZodDefault<z.ZodNumber>;
|
|
1079
|
+
basedOn: z.ZodDefault<z.ZodEnum<{
|
|
1080
|
+
characters: "characters";
|
|
1081
|
+
characters_excluding_spaces: "characters_excluding_spaces";
|
|
1082
|
+
words: "words";
|
|
1083
|
+
lines: "lines";
|
|
1084
|
+
}>>;
|
|
1085
|
+
mode: z.ZodDefault<z.ZodEnum<{
|
|
1086
|
+
difference: "difference";
|
|
1087
|
+
add: "add";
|
|
1088
|
+
subtract: "subtract";
|
|
1089
|
+
intersect: "intersect";
|
|
1090
|
+
min: "min";
|
|
1091
|
+
max: "max";
|
|
1092
|
+
}>>;
|
|
1093
|
+
}, z.core.$strip>], "type">>;
|
|
1094
|
+
props: z.ZodObject<{
|
|
1095
|
+
x: z.ZodOptional<z.ZodNumber>;
|
|
1096
|
+
y: z.ZodOptional<z.ZodNumber>;
|
|
1097
|
+
z: z.ZodOptional<z.ZodNumber>;
|
|
1098
|
+
scale: z.ZodOptional<z.ZodNumber>;
|
|
1099
|
+
scaleX: z.ZodOptional<z.ZodNumber>;
|
|
1100
|
+
scaleY: z.ZodOptional<z.ZodNumber>;
|
|
1101
|
+
rotation: z.ZodOptional<z.ZodNumber>;
|
|
1102
|
+
rotationX: z.ZodOptional<z.ZodNumber>;
|
|
1103
|
+
rotationY: z.ZodOptional<z.ZodNumber>;
|
|
1104
|
+
skew: z.ZodOptional<z.ZodNumber>;
|
|
1105
|
+
skewAxis: z.ZodOptional<z.ZodNumber>;
|
|
1106
|
+
tracking: z.ZodOptional<z.ZodNumber>;
|
|
1107
|
+
lineSpacing: z.ZodOptional<z.ZodNumber>;
|
|
1108
|
+
opacity: z.ZodOptional<z.ZodNumber>;
|
|
1109
|
+
fillColor: z.ZodOptional<z.ZodString>;
|
|
1110
|
+
strokeColor: z.ZodOptional<z.ZodString>;
|
|
1111
|
+
strokeWidth: z.ZodOptional<z.ZodNumber>;
|
|
1112
|
+
blur: z.ZodOptional<z.ZodNumber>;
|
|
1113
|
+
characterOffset: z.ZodOptional<z.ZodNumber>;
|
|
1114
|
+
}, z.core.$strip>;
|
|
1115
|
+
anchor: z.ZodDefault<z.ZodObject<{
|
|
1116
|
+
grouping: z.ZodDefault<z.ZodEnum<{
|
|
1117
|
+
character: "character";
|
|
1118
|
+
word: "word";
|
|
1119
|
+
line: "line";
|
|
1120
|
+
all: "all";
|
|
1121
|
+
}>>;
|
|
1122
|
+
anchorX: z.ZodDefault<z.ZodNumber>;
|
|
1123
|
+
anchorY: z.ZodDefault<z.ZodNumber>;
|
|
1124
|
+
}, z.core.$strip>>;
|
|
1125
|
+
}, z.core.$strip>;
|
|
1126
|
+
type AETextAnimator = z.infer<typeof AETextAnimatorSchema>;
|
|
1127
|
+
declare const EnhancedTextNodeSchema: z.ZodObject<{
|
|
1128
|
+
text: z.ZodString;
|
|
1129
|
+
fontFamily: z.ZodDefault<z.ZodString>;
|
|
1130
|
+
fontSize: z.ZodDefault<z.ZodNumber>;
|
|
1131
|
+
fontWeight: z.ZodDefault<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
|
|
1132
|
+
fill: z.ZodDefault<z.ZodString>;
|
|
1133
|
+
letterSpacing: z.ZodDefault<z.ZodNumber>;
|
|
1134
|
+
lineHeight: z.ZodDefault<z.ZodNumber>;
|
|
1135
|
+
textAlign: z.ZodDefault<z.ZodEnum<{
|
|
1136
|
+
center: "center";
|
|
1137
|
+
left: "left";
|
|
1138
|
+
right: "right";
|
|
1139
|
+
}>>;
|
|
1140
|
+
pathOptions: z.ZodOptional<z.ZodObject<{
|
|
1141
|
+
path: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1142
|
+
type: z.ZodLiteral<"svg">;
|
|
1143
|
+
d: z.ZodString;
|
|
1144
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1145
|
+
type: z.ZodLiteral<"bezier">;
|
|
1146
|
+
segments: z.ZodArray<z.ZodObject<{
|
|
1147
|
+
p0: z.ZodObject<{
|
|
1148
|
+
x: z.ZodNumber;
|
|
1149
|
+
y: z.ZodNumber;
|
|
1150
|
+
}, z.core.$strip>;
|
|
1151
|
+
p1: z.ZodObject<{
|
|
1152
|
+
x: z.ZodNumber;
|
|
1153
|
+
y: z.ZodNumber;
|
|
1154
|
+
}, z.core.$strip>;
|
|
1155
|
+
p2: z.ZodObject<{
|
|
1156
|
+
x: z.ZodNumber;
|
|
1157
|
+
y: z.ZodNumber;
|
|
1158
|
+
}, z.core.$strip>;
|
|
1159
|
+
p3: z.ZodObject<{
|
|
1160
|
+
x: z.ZodNumber;
|
|
1161
|
+
y: z.ZodNumber;
|
|
1162
|
+
}, z.core.$strip>;
|
|
1163
|
+
}, z.core.$strip>>;
|
|
1164
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1165
|
+
type: z.ZodLiteral<"ellipse">;
|
|
1166
|
+
cx: z.ZodNumber;
|
|
1167
|
+
cy: z.ZodNumber;
|
|
1168
|
+
rx: z.ZodNumber;
|
|
1169
|
+
ry: z.ZodNumber;
|
|
1170
|
+
startAngleDeg: z.ZodDefault<z.ZodNumber>;
|
|
1171
|
+
endAngleDeg: z.ZodDefault<z.ZodNumber>;
|
|
1172
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1173
|
+
type: z.ZodLiteral<"wave">;
|
|
1174
|
+
startX: z.ZodNumber;
|
|
1175
|
+
startY: z.ZodNumber;
|
|
1176
|
+
length: z.ZodNumber;
|
|
1177
|
+
amplitude: z.ZodNumber;
|
|
1178
|
+
frequency: z.ZodNumber;
|
|
1179
|
+
phaseDeg: z.ZodDefault<z.ZodNumber>;
|
|
1180
|
+
}, z.core.$strip>], "type">;
|
|
1181
|
+
firstMargin: z.ZodDefault<z.ZodNumber>;
|
|
1182
|
+
lastMargin: z.ZodDefault<z.ZodNumber>;
|
|
1183
|
+
reversePath: z.ZodDefault<z.ZodBoolean>;
|
|
1184
|
+
perpendicularToPath: z.ZodDefault<z.ZodBoolean>;
|
|
1185
|
+
forceAlignment: z.ZodDefault<z.ZodBoolean>;
|
|
1186
|
+
loop: z.ZodDefault<z.ZodBoolean>;
|
|
1187
|
+
baselineOffset: z.ZodDefault<z.ZodEnum<{
|
|
1188
|
+
center: "center";
|
|
1189
|
+
baseline: "baseline";
|
|
1190
|
+
ascender: "ascender";
|
|
1191
|
+
descender: "descender";
|
|
1192
|
+
}>>;
|
|
1193
|
+
baselineShift: z.ZodDefault<z.ZodNumber>;
|
|
1194
|
+
}, z.core.$strip>>;
|
|
1195
|
+
typewriter: z.ZodOptional<z.ZodObject<{
|
|
1196
|
+
granularity: z.ZodDefault<z.ZodEnum<{
|
|
1197
|
+
character: "character";
|
|
1198
|
+
word: "word";
|
|
1199
|
+
line: "line";
|
|
1200
|
+
}>>;
|
|
1201
|
+
cursor: z.ZodDefault<z.ZodObject<{
|
|
1202
|
+
enabled: z.ZodDefault<z.ZodBoolean>;
|
|
1203
|
+
style: z.ZodDefault<z.ZodEnum<{
|
|
1204
|
+
custom: "custom";
|
|
1205
|
+
bar: "bar";
|
|
1206
|
+
underscore: "underscore";
|
|
1207
|
+
block: "block";
|
|
1208
|
+
}>>;
|
|
1209
|
+
customChar: z.ZodDefault<z.ZodString>;
|
|
1210
|
+
color: z.ZodOptional<z.ZodString>;
|
|
1211
|
+
blinkFrequency: z.ZodDefault<z.ZodNumber>;
|
|
1212
|
+
hideOnComplete: z.ZodDefault<z.ZodBoolean>;
|
|
1213
|
+
width: z.ZodDefault<z.ZodNumber>;
|
|
1214
|
+
spacing: z.ZodDefault<z.ZodNumber>;
|
|
1215
|
+
}, z.core.$strip>>;
|
|
1216
|
+
cadence: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1217
|
+
mode: z.ZodLiteral<"constant">;
|
|
1218
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1219
|
+
mode: z.ZodLiteral<"human">;
|
|
1220
|
+
jitter: z.ZodDefault<z.ZodNumber>;
|
|
1221
|
+
commaPauseMultiplier: z.ZodDefault<z.ZodNumber>;
|
|
1222
|
+
sentencePauseMultiplier: z.ZodDefault<z.ZodNumber>;
|
|
1223
|
+
paragraphPauseMultiplier: z.ZodDefault<z.ZodNumber>;
|
|
1224
|
+
}, z.core.$strip>], "mode">>;
|
|
1225
|
+
scramble: z.ZodDefault<z.ZodObject<{
|
|
1226
|
+
enabled: z.ZodDefault<z.ZodBoolean>;
|
|
1227
|
+
charset: z.ZodDefault<z.ZodEnum<{
|
|
1228
|
+
custom: "custom";
|
|
1229
|
+
ascii: "ascii";
|
|
1230
|
+
alphanumeric: "alphanumeric";
|
|
1231
|
+
matrix: "matrix";
|
|
1232
|
+
binary: "binary";
|
|
1233
|
+
hex: "hex";
|
|
1234
|
+
}>>;
|
|
1235
|
+
customCharset: z.ZodOptional<z.ZodString>;
|
|
1236
|
+
scrambleFramesPerChar: z.ZodDefault<z.ZodNumber>;
|
|
1237
|
+
highlightProbability: z.ZodDefault<z.ZodNumber>;
|
|
1238
|
+
scrambleColor: z.ZodOptional<z.ZodString>;
|
|
1239
|
+
}, z.core.$strip>>;
|
|
1240
|
+
soundSync: z.ZodDefault<z.ZodBoolean>;
|
|
1241
|
+
}, z.core.$strip>>;
|
|
1242
|
+
animators: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
1243
|
+
name: z.ZodDefault<z.ZodString>;
|
|
1244
|
+
selectors: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1245
|
+
type: z.ZodLiteral<"range">;
|
|
1246
|
+
start: z.ZodDefault<z.ZodNumber>;
|
|
1247
|
+
end: z.ZodDefault<z.ZodNumber>;
|
|
1248
|
+
offset: z.ZodDefault<z.ZodNumber>;
|
|
1249
|
+
units: z.ZodDefault<z.ZodEnum<{
|
|
1250
|
+
percentage: "percentage";
|
|
1251
|
+
index: "index";
|
|
1252
|
+
}>>;
|
|
1253
|
+
basedOn: z.ZodDefault<z.ZodEnum<{
|
|
1254
|
+
characters: "characters";
|
|
1255
|
+
characters_excluding_spaces: "characters_excluding_spaces";
|
|
1256
|
+
words: "words";
|
|
1257
|
+
lines: "lines";
|
|
1258
|
+
}>>;
|
|
1259
|
+
shape: z.ZodDefault<z.ZodEnum<{
|
|
1260
|
+
round: "round";
|
|
1261
|
+
square: "square";
|
|
1262
|
+
ramp_up: "ramp_up";
|
|
1263
|
+
ramp_down: "ramp_down";
|
|
1264
|
+
triangle: "triangle";
|
|
1265
|
+
smooth: "smooth";
|
|
1266
|
+
}>>;
|
|
1267
|
+
mode: z.ZodDefault<z.ZodEnum<{
|
|
1268
|
+
difference: "difference";
|
|
1269
|
+
add: "add";
|
|
1270
|
+
subtract: "subtract";
|
|
1271
|
+
intersect: "intersect";
|
|
1272
|
+
min: "min";
|
|
1273
|
+
max: "max";
|
|
1274
|
+
}>>;
|
|
1275
|
+
amount: z.ZodDefault<z.ZodNumber>;
|
|
1276
|
+
easeHigh: z.ZodDefault<z.ZodNumber>;
|
|
1277
|
+
easeLow: z.ZodDefault<z.ZodNumber>;
|
|
1278
|
+
randomizeOrder: z.ZodDefault<z.ZodBoolean>;
|
|
1279
|
+
randomSeed: z.ZodDefault<z.ZodNumber>;
|
|
1280
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1281
|
+
type: z.ZodLiteral<"wiggly">;
|
|
1282
|
+
wigglesPerSecond: z.ZodDefault<z.ZodNumber>;
|
|
1283
|
+
correlation: z.ZodDefault<z.ZodNumber>;
|
|
1284
|
+
temporalPhaseDeg: z.ZodDefault<z.ZodNumber>;
|
|
1285
|
+
spatialPhaseDeg: z.ZodDefault<z.ZodNumber>;
|
|
1286
|
+
minAmount: z.ZodDefault<z.ZodNumber>;
|
|
1287
|
+
maxAmount: z.ZodDefault<z.ZodNumber>;
|
|
1288
|
+
randomSeed: z.ZodDefault<z.ZodNumber>;
|
|
1289
|
+
basedOn: z.ZodDefault<z.ZodEnum<{
|
|
1290
|
+
characters: "characters";
|
|
1291
|
+
characters_excluding_spaces: "characters_excluding_spaces";
|
|
1292
|
+
words: "words";
|
|
1293
|
+
lines: "lines";
|
|
1294
|
+
}>>;
|
|
1295
|
+
mode: z.ZodDefault<z.ZodEnum<{
|
|
1296
|
+
difference: "difference";
|
|
1297
|
+
add: "add";
|
|
1298
|
+
subtract: "subtract";
|
|
1299
|
+
intersect: "intersect";
|
|
1300
|
+
min: "min";
|
|
1301
|
+
max: "max";
|
|
1302
|
+
}>>;
|
|
1303
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1304
|
+
type: z.ZodLiteral<"signal">;
|
|
1305
|
+
signalId: z.ZodString;
|
|
1306
|
+
multiplier: z.ZodDefault<z.ZodNumber>;
|
|
1307
|
+
offset: z.ZodDefault<z.ZodNumber>;
|
|
1308
|
+
phaseSpread: z.ZodDefault<z.ZodNumber>;
|
|
1309
|
+
basedOn: z.ZodDefault<z.ZodEnum<{
|
|
1310
|
+
characters: "characters";
|
|
1311
|
+
characters_excluding_spaces: "characters_excluding_spaces";
|
|
1312
|
+
words: "words";
|
|
1313
|
+
lines: "lines";
|
|
1314
|
+
}>>;
|
|
1315
|
+
mode: z.ZodDefault<z.ZodEnum<{
|
|
1316
|
+
difference: "difference";
|
|
1317
|
+
add: "add";
|
|
1318
|
+
subtract: "subtract";
|
|
1319
|
+
intersect: "intersect";
|
|
1320
|
+
min: "min";
|
|
1321
|
+
max: "max";
|
|
1322
|
+
}>>;
|
|
1323
|
+
}, z.core.$strip>], "type">>;
|
|
1324
|
+
props: z.ZodObject<{
|
|
1325
|
+
x: z.ZodOptional<z.ZodNumber>;
|
|
1326
|
+
y: z.ZodOptional<z.ZodNumber>;
|
|
1327
|
+
z: z.ZodOptional<z.ZodNumber>;
|
|
1328
|
+
scale: z.ZodOptional<z.ZodNumber>;
|
|
1329
|
+
scaleX: z.ZodOptional<z.ZodNumber>;
|
|
1330
|
+
scaleY: z.ZodOptional<z.ZodNumber>;
|
|
1331
|
+
rotation: z.ZodOptional<z.ZodNumber>;
|
|
1332
|
+
rotationX: z.ZodOptional<z.ZodNumber>;
|
|
1333
|
+
rotationY: z.ZodOptional<z.ZodNumber>;
|
|
1334
|
+
skew: z.ZodOptional<z.ZodNumber>;
|
|
1335
|
+
skewAxis: z.ZodOptional<z.ZodNumber>;
|
|
1336
|
+
tracking: z.ZodOptional<z.ZodNumber>;
|
|
1337
|
+
lineSpacing: z.ZodOptional<z.ZodNumber>;
|
|
1338
|
+
opacity: z.ZodOptional<z.ZodNumber>;
|
|
1339
|
+
fillColor: z.ZodOptional<z.ZodString>;
|
|
1340
|
+
strokeColor: z.ZodOptional<z.ZodString>;
|
|
1341
|
+
strokeWidth: z.ZodOptional<z.ZodNumber>;
|
|
1342
|
+
blur: z.ZodOptional<z.ZodNumber>;
|
|
1343
|
+
characterOffset: z.ZodOptional<z.ZodNumber>;
|
|
1344
|
+
}, z.core.$strip>;
|
|
1345
|
+
anchor: z.ZodDefault<z.ZodObject<{
|
|
1346
|
+
grouping: z.ZodDefault<z.ZodEnum<{
|
|
1347
|
+
character: "character";
|
|
1348
|
+
word: "word";
|
|
1349
|
+
line: "line";
|
|
1350
|
+
all: "all";
|
|
1351
|
+
}>>;
|
|
1352
|
+
anchorX: z.ZodDefault<z.ZodNumber>;
|
|
1353
|
+
anchorY: z.ZodDefault<z.ZodNumber>;
|
|
1354
|
+
}, z.core.$strip>>;
|
|
1355
|
+
}, z.core.$strip>>>;
|
|
1356
|
+
}, z.core.$strip>;
|
|
1357
|
+
type EnhancedTextNode = z.infer<typeof EnhancedTextNodeSchema>;
|
|
1358
|
+
//#endregion
|
|
1359
|
+
//#region src/program/text-animations/builder.d.ts
|
|
1360
|
+
/**
|
|
1361
|
+
* Fluent builder for creating Path-Following Text configurations.
|
|
1362
|
+
*/
|
|
1363
|
+
declare class TextPathBuilder {
|
|
1364
|
+
private options;
|
|
1365
|
+
static fromSvg(svgPath: string): TextPathBuilder;
|
|
1366
|
+
static fromBezier(segments: CubicBezierSegment[]): TextPathBuilder;
|
|
1367
|
+
static fromCurve(curve: CubicBezierSegment): TextPathBuilder;
|
|
1368
|
+
static circularBadge(cx: number, cy: number, radius: number): TextPathBuilder;
|
|
1369
|
+
static ellipse(cx: number, cy: number, rx: number, ry: number, startAngleDeg?: number, endAngleDeg?: number): TextPathBuilder;
|
|
1370
|
+
static wave(startX: number, startY: number, length: number, amplitude: number, frequency: number, phaseDeg?: number): TextPathBuilder;
|
|
1371
|
+
firstMargin(margin: number): this;
|
|
1372
|
+
lastMargin(margin: number): this;
|
|
1373
|
+
reversePath(reverse: boolean): this;
|
|
1374
|
+
perpendicularToPath(perpendicular: boolean): this;
|
|
1375
|
+
forceAlignment(force: boolean): this;
|
|
1376
|
+
loop(isLoop: boolean): this;
|
|
1377
|
+
baselineOffset(offset: "baseline" | "center" | "ascender" | "descender"): this;
|
|
1378
|
+
baselineShift(shiftPixels: number): this;
|
|
1379
|
+
build(): TextPathOptions;
|
|
1380
|
+
}
|
|
1381
|
+
/**
|
|
1382
|
+
* Fluent builder for After Effects Range, Wiggly, and Signal Animators.
|
|
1383
|
+
*/
|
|
1384
|
+
declare class TextAnimatorBuilder {
|
|
1385
|
+
private name;
|
|
1386
|
+
private selectors;
|
|
1387
|
+
private props;
|
|
1388
|
+
private anchor;
|
|
1389
|
+
static create(name: string): TextAnimatorBuilder;
|
|
1390
|
+
/** Adds an After Effects Range Selector */
|
|
1391
|
+
addRangeSelector(config: {
|
|
1392
|
+
start?: number;
|
|
1393
|
+
end?: number;
|
|
1394
|
+
offset?: number;
|
|
1395
|
+
shape?: SelectorShape;
|
|
1396
|
+
basedOn?: SelectorBasedOn;
|
|
1397
|
+
mode?: SelectorMode;
|
|
1398
|
+
easeHigh?: number;
|
|
1399
|
+
easeLow?: number;
|
|
1400
|
+
randomizeOrder?: boolean;
|
|
1401
|
+
randomSeed?: number;
|
|
1402
|
+
}): this;
|
|
1403
|
+
/** Adds an After Effects Wiggly Selector for procedural organic flutter */
|
|
1404
|
+
addWigglySelector(config: {
|
|
1405
|
+
wigglesPerSecond?: number;
|
|
1406
|
+
correlation?: number;
|
|
1407
|
+
minAmount?: number;
|
|
1408
|
+
maxAmount?: number;
|
|
1409
|
+
randomSeed?: number;
|
|
1410
|
+
mode?: SelectorMode;
|
|
1411
|
+
}): this;
|
|
1412
|
+
/** Adds a reactive signal selector */
|
|
1413
|
+
addSignalSelector(signalId: string, multiplier?: number, phaseSpread?: number, offset?: number, mode?: SelectorMode): this;
|
|
1414
|
+
x(pixels: number): this;
|
|
1415
|
+
y(pixels: number): this;
|
|
1416
|
+
z(pixels: number): this;
|
|
1417
|
+
scale(scaleValue: number): this;
|
|
1418
|
+
scaleX(scaleValue: number): this;
|
|
1419
|
+
scaleY(scaleValue: number): this;
|
|
1420
|
+
rotation(degrees: number): this;
|
|
1421
|
+
rotationX(degrees: number): this;
|
|
1422
|
+
rotationY(degrees: number): this;
|
|
1423
|
+
skew(degrees: number): this;
|
|
1424
|
+
skewAxis(degrees: number): this;
|
|
1425
|
+
opacity(value: number): this;
|
|
1426
|
+
blur(pixels: number): this;
|
|
1427
|
+
fill(colorHex: string): this;
|
|
1428
|
+
fillColor(colorHex: string): this;
|
|
1429
|
+
strokeColor(colorHex: string): this;
|
|
1430
|
+
strokeWidth(pixels: number): this;
|
|
1431
|
+
tracking(spacingPixels: number): this;
|
|
1432
|
+
lineSpacing(spacingPixels: number): this;
|
|
1433
|
+
characterOffset(offset: number): this;
|
|
1434
|
+
anchorGrouping(grouping: GlyphAnchorGrouping, anchorX?: number, anchorY?: number): this;
|
|
1435
|
+
build(): AETextAnimator;
|
|
1436
|
+
}
|
|
1437
|
+
//#endregion
|
|
1438
|
+
//#region src/program/text-animations/math.d.ts
|
|
1439
|
+
/**
|
|
1440
|
+
* Evaluates closed-form underdamped harmonic oscillator for spring physics:
|
|
1441
|
+
*
|
|
1442
|
+
* x(t) = target + (x0 - target) * exp(-zeta * omega_n * t) *
|
|
1443
|
+
* [ cos(omega_d * t) + (zeta / sqrt(1 - zeta^2)) * sin(omega_d * t) ]
|
|
1444
|
+
*
|
|
1445
|
+
* @param t Time in seconds since excitation
|
|
1446
|
+
* @param stiffness Spring stiffness (k)
|
|
1447
|
+
* @param damping Damping coefficient (c)
|
|
1448
|
+
* @param mass Mass of glyph (m)
|
|
1449
|
+
* @param initialVelocity Initial velocity (v0)
|
|
1450
|
+
* @returns Settled scalar progress in [0, 1] with overshoot
|
|
1451
|
+
*/
|
|
1452
|
+
declare function evaluateSpringProgress(t: number, stiffness?: number, damping?: number, mass?: number, initialVelocity?: number): number;
|
|
1453
|
+
/**
|
|
1454
|
+
* Evaluates 2D Directional Skew matrix components:
|
|
1455
|
+
*
|
|
1456
|
+
* S(theta, phi) = R(phi) * [ 1 tan(theta) ] * R(-phi)
|
|
1457
|
+
* [ 0 1 ]
|
|
1458
|
+
*
|
|
1459
|
+
* @param skewDeg Skew angle in degrees
|
|
1460
|
+
* @param skewAxisDeg Skew axis in degrees
|
|
1461
|
+
* @returns 2x2 affine shear matrix components [m00, m01, m10, m11]
|
|
1462
|
+
*/
|
|
1463
|
+
declare function evaluateSkewMatrix(skewDeg: number, skewAxisDeg?: number): [number, number, number, number];
|
|
1464
|
+
/**
|
|
1465
|
+
* Computes anchor pivot coordinates relative to glyph bounding box:
|
|
1466
|
+
*
|
|
1467
|
+
* @param bbox Glyph bounding box { width, height, ascender, descender }
|
|
1468
|
+
* @param config Text anchor configuration
|
|
1469
|
+
* @returns Pivot offset (px, py) relative to glyph quad center
|
|
1470
|
+
*/
|
|
1471
|
+
declare function computeAnchorPivotOffset(bbox: {
|
|
1472
|
+
width: number;
|
|
1473
|
+
height: number;
|
|
1474
|
+
ascender: number;
|
|
1475
|
+
descender: number;
|
|
1476
|
+
}, config: TextAnchorConfig): {
|
|
1477
|
+
px: number;
|
|
1478
|
+
py: number;
|
|
1479
|
+
};
|
|
1480
|
+
/**
|
|
1481
|
+
* Computes leading displacement per line based on lineAnchor:
|
|
1482
|
+
*
|
|
1483
|
+
* @param lineIndex 0-based index of current line
|
|
1484
|
+
* @param lineCount Total lines in paragraph
|
|
1485
|
+
* @param lineSpacing Additional leading in pixels
|
|
1486
|
+
* @param lineAnchor Pivot line anchor in [0, 1]
|
|
1487
|
+
* @returns Y displacement in pixels
|
|
1488
|
+
*/
|
|
1489
|
+
declare function computeLineLeadingDisplacement(lineIndex: number, lineCount: number, lineSpacing: number, lineAnchor?: number): number;
|
|
1490
|
+
/**
|
|
1491
|
+
* Evaluates an Expression Selector formula safely in a sandboxed numeric scope.
|
|
1492
|
+
*
|
|
1493
|
+
* @param expression Formula string (e.g. "Math.sin(time * 4 + textIndex * 0.2)")
|
|
1494
|
+
* @param ctx Glyph evaluation context
|
|
1495
|
+
* @returns Numeric selector weight clamped to [-1, 1]
|
|
1496
|
+
*/
|
|
1497
|
+
declare function evaluateExpressionSelector(expression: string, ctx: ExpressionEvaluationContext): number;
|
|
1498
|
+
/**
|
|
1499
|
+
* 3D Volumetric arrangement transformation output.
|
|
1500
|
+
*/
|
|
1501
|
+
interface Volumetric3DTransform {
|
|
1502
|
+
x: number;
|
|
1503
|
+
y: number;
|
|
1504
|
+
z: number;
|
|
1505
|
+
rotX: number;
|
|
1506
|
+
rotY: number;
|
|
1507
|
+
rotZ: number;
|
|
1508
|
+
scaleMult: number;
|
|
1509
|
+
depthOpacity?: number;
|
|
1510
|
+
}
|
|
1511
|
+
/**
|
|
1512
|
+
* Evaluates 3D Volumetric Formation parametric coordinates.
|
|
1513
|
+
*/
|
|
1514
|
+
declare function evaluateVolumetricFormation(glyphIndex: number, totalGlyphs: number, config: VolumetricFormationConfig): Volumetric3DTransform;
|
|
1515
|
+
/**
|
|
1516
|
+
* Evaluates infinite kinetic marquee translation and snapping.
|
|
1517
|
+
*/
|
|
1518
|
+
declare function evaluateMarqueeOffset(baseX: number, containerWidth: number, contentWidth: number, config: KineticMarqueeConfig, elapsedSec: number): number;
|
|
1519
|
+
/**
|
|
1520
|
+
* Samples audio FFT frequency bin and computes scale factor for Audio Spectrum Typography.
|
|
1521
|
+
*/
|
|
1522
|
+
declare function sampleAudioSpectrumScale(glyphIndex: number, totalGlyphs: number, config: AudioSpectrumTypography, signals: Record<string, unknown> | undefined, frame: number, fps: number): number;
|
|
1523
|
+
//#endregion
|
|
1524
|
+
//#region src/program/text-animations/path.d.ts
|
|
1525
|
+
interface ArcLengthLUTEntry {
|
|
1526
|
+
distance: number;
|
|
1527
|
+
t: number;
|
|
1528
|
+
}
|
|
1529
|
+
interface PathChainLUTEntry {
|
|
1530
|
+
distance: number;
|
|
1531
|
+
segmentIndex: number;
|
|
1532
|
+
t: number;
|
|
1533
|
+
}
|
|
1534
|
+
interface PathSegmentLUT {
|
|
1535
|
+
segmentIndex: number;
|
|
1536
|
+
startDistance: number;
|
|
1537
|
+
length: number;
|
|
1538
|
+
lut: ArcLengthLUTEntry[];
|
|
1539
|
+
}
|
|
1540
|
+
interface PathChainLUT {
|
|
1541
|
+
totalLength: number;
|
|
1542
|
+
entries: PathChainLUTEntry[];
|
|
1543
|
+
segments?: PathSegmentLUT[];
|
|
1544
|
+
}
|
|
1545
|
+
/**
|
|
1546
|
+
* Evaluates a point on a cubic Bezier curve at parameter t in [0, 1].
|
|
1547
|
+
*/
|
|
1548
|
+
declare function evaluateCubicBezier(segment: CubicBezierSegment, t: number): Vec2;
|
|
1549
|
+
/**
|
|
1550
|
+
* Evaluates the first derivative (tangent velocity vector) of a cubic Bezier curve at parameter t.
|
|
1551
|
+
*/
|
|
1552
|
+
declare function evaluateCubicBezierDerivative(segment: CubicBezierSegment, t: number): Vec2;
|
|
1553
|
+
/**
|
|
1554
|
+
* Generates an arc-length parameterization lookup table (LUT) for a cubic Bezier segment.
|
|
1555
|
+
* Ensures glyphs travel with uniform speed and do not bunch up on tight curve bends.
|
|
1556
|
+
*/
|
|
1557
|
+
declare function generateArcLengthLUT(segment: CubicBezierSegment, samples?: number): {
|
|
1558
|
+
lut: ArcLengthLUTEntry[];
|
|
1559
|
+
totalLength: number;
|
|
1560
|
+
};
|
|
1561
|
+
/**
|
|
1562
|
+
* Maps a distance along the curve (in pixels) to normalized curve parameter t via binary search on the LUT.
|
|
1563
|
+
*/
|
|
1564
|
+
declare function distanceToCurveParameter(lut: ArcLengthLUTEntry[], distance: number, totalLength: number): number;
|
|
1565
|
+
/**
|
|
1566
|
+
* Samples position and baseline tangent orientation angle along a curve at distance `dist`.
|
|
1567
|
+
*/
|
|
1568
|
+
declare function sampleCurveGeometry(segment: CubicBezierSegment, lut: ArcLengthLUTEntry[], totalLength: number, distance: number): {
|
|
1569
|
+
position: Vec2;
|
|
1570
|
+
tangentAngleDeg: number;
|
|
1571
|
+
normal: Vec2;
|
|
1572
|
+
};
|
|
1573
|
+
/**
|
|
1574
|
+
* Builds a cumulative Arc-Length LUT across a chain of Cubic Bezier segments.
|
|
1575
|
+
*/
|
|
1576
|
+
declare function buildPathLUT(segments: CubicBezierSegment[], samplesPerSegment?: number): PathChainLUT;
|
|
1577
|
+
/**
|
|
1578
|
+
* Samples position, tangent angle, and normal across a chain of Cubic Bezier segments.
|
|
1579
|
+
*/
|
|
1580
|
+
declare function samplePathChainGeometry(segments: CubicBezierSegment[], chainLUT: PathChainLUT, distance: number): {
|
|
1581
|
+
position: Vec2;
|
|
1582
|
+
tangentAngleDeg: number;
|
|
1583
|
+
normal: Vec2;
|
|
1584
|
+
};
|
|
1585
|
+
/**
|
|
1586
|
+
* Converts an ellipse arc into cubic Bezier segments (up to 90 degrees per segment).
|
|
1587
|
+
*/
|
|
1588
|
+
declare function ellipseToCubicBeziers(cx: number, cy: number, rx: number, ry: number, startAngleDeg?: number, endAngleDeg?: number): CubicBezierSegment[];
|
|
1589
|
+
/**
|
|
1590
|
+
* Converts a sinusoidal wave into cubic Bezier segments per half-cycle.
|
|
1591
|
+
*/
|
|
1592
|
+
declare function waveToCubicBeziers(startX: number, startY: number, length: number, amplitude: number, frequency: number, phaseDeg?: number): CubicBezierSegment[];
|
|
1593
|
+
/**
|
|
1594
|
+
* An SVG elliptical arc (endpoint form, SVG 1.1 F.6.5) as cubic Bezier
|
|
1595
|
+
* segments of at most 90° each.
|
|
1596
|
+
*/
|
|
1597
|
+
declare function svgArcToCubicBeziers(x1: number, y1: number, rxIn: number, ryIn: number, rotationDeg: number, largeArc: boolean, sweep: boolean, x2: number, y2: number): CubicBezierSegment[];
|
|
1598
|
+
/**
|
|
1599
|
+
* Converts SVG path data string into a chain of Cubic Bezier segments.
|
|
1600
|
+
*/
|
|
1601
|
+
declare function parseSvgPathToCubicBeziers(d: string): CubicBezierSegment[];
|
|
1602
|
+
/**
|
|
1603
|
+
* Universal path source converter to Cubic Bezier segments.
|
|
1604
|
+
*/
|
|
1605
|
+
declare function generatePathSegments(source: TextPathSource): CubicBezierSegment[];
|
|
1606
|
+
//#endregion
|
|
1607
|
+
//#region src/program/text-animations/selectors.d.ts
|
|
1608
|
+
/**
|
|
1609
|
+
* Computes After Effects Range Selector weight for a single glyph index.
|
|
1610
|
+
*
|
|
1611
|
+
* @param index Normalized position of the glyph in the string (0.0 to 1.0)
|
|
1612
|
+
* @param start Start boundary (0.0 to 1.0)
|
|
1613
|
+
* @param end End boundary (0.0 to 1.0)
|
|
1614
|
+
* @param offset Window shift (-1.0 to 1.0)
|
|
1615
|
+
* @param shape Falloff curve
|
|
1616
|
+
* @param easeHigh Non-linear easing for high values
|
|
1617
|
+
* @param easeLow Non-linear easing for low values
|
|
1618
|
+
* @returns Weight in [0.0, 1.0]
|
|
1619
|
+
*/
|
|
1620
|
+
declare function computeRangeSelectorWeight(index: number, start: number, end: number, offset: number, shape: SelectorShape, easeHigh?: number, easeLow?: number): number;
|
|
1621
|
+
/**
|
|
1622
|
+
* 1D Gradient deterministic hash noise for Wiggly Selectors.
|
|
1623
|
+
*/
|
|
1624
|
+
declare function deterministicWigglyNoise(seed: number, glyphIndex: number, phase: number, correlation: number): number;
|
|
1625
|
+
/**
|
|
1626
|
+
* Deterministic pseudo-random number generator for seeded order shuffling.
|
|
1627
|
+
*/
|
|
1628
|
+
declare function getShuffledOrder(count: number, seed: number): number[];
|
|
1629
|
+
/**
|
|
1630
|
+
* Combines consecutive selector weights using After Effects Selector Mode logic.
|
|
1631
|
+
*/
|
|
1632
|
+
declare function evaluateSelectorCombination(prevWeight: number, currWeight: number, mode: SelectorMode): number;
|
|
1633
|
+
//#endregion
|
|
1634
|
+
//#region src/program/text-animations/typewriter.d.ts
|
|
1635
|
+
declare function getScramblePool(charset: string, customCharset?: string): string;
|
|
1636
|
+
/**
|
|
1637
|
+
* Evaluates typewriter visible character count and scramble state for frame `currentFrame`.
|
|
1638
|
+
*/
|
|
1639
|
+
declare function evaluateTypewriterState(fullText: string, currentFrame: number, startFrame: number, durationFrames: number, cadence?: TypingCadence, scramble?: TextScrambleConfig, blinkFrequency?: number, granularity?: "character" | "word" | "line", progressOverride?: number): {
|
|
1640
|
+
visibleChars: number;
|
|
1641
|
+
currentDisplayString: string;
|
|
1642
|
+
isCursorVisible: boolean;
|
|
1643
|
+
};
|
|
1644
|
+
//#endregion
|
|
1645
|
+
//#region src/program/schema.d.ts
|
|
1646
|
+
/** number px | "auto" (intrinsic) | "fit" (shrink-wrap) | "fill" (parent extent). */
|
|
1647
|
+
declare const SizeSpecSchema: z.ZodUnion<readonly [z.ZodNumber, z.ZodEnum<{
|
|
1648
|
+
fill: "fill";
|
|
1649
|
+
auto: "auto";
|
|
1650
|
+
fit: "fit";
|
|
1651
|
+
}>, z.ZodCustom<unknown, unknown>]>;
|
|
1652
|
+
type SizeSpec = z.infer<typeof SizeSpecSchema>;
|
|
1653
|
+
declare const ShapeTypeSchema: z.ZodEnum<{
|
|
1654
|
+
path: "path";
|
|
1655
|
+
rect: "rect";
|
|
1656
|
+
circle: "circle";
|
|
1657
|
+
ellipse: "ellipse";
|
|
1658
|
+
polygon: "polygon";
|
|
1659
|
+
star: "star";
|
|
1660
|
+
arrow: "arrow";
|
|
1661
|
+
}>;
|
|
1662
|
+
type ShapeType = z.infer<typeof ShapeTypeSchema>;
|
|
1663
|
+
declare const AnimatablePropSchema: z.ZodEnum<{
|
|
1664
|
+
x: "x";
|
|
1665
|
+
y: "y";
|
|
1666
|
+
width: "width";
|
|
1667
|
+
height: "height";
|
|
1668
|
+
rotation: "rotation";
|
|
1669
|
+
scale: "scale";
|
|
1670
|
+
opacity: "opacity";
|
|
1671
|
+
trimStart: "trimStart";
|
|
1672
|
+
trimEnd: "trimEnd";
|
|
1673
|
+
text: "text";
|
|
1674
|
+
fontSize: "fontSize";
|
|
1675
|
+
fill: "fill";
|
|
1676
|
+
letterSpacing: "letterSpacing";
|
|
1677
|
+
padding: "padding";
|
|
1678
|
+
strokeWidth: "strokeWidth";
|
|
1679
|
+
borderColor: "borderColor";
|
|
1680
|
+
borderWidth: "borderWidth";
|
|
1681
|
+
volume: "volume";
|
|
1682
|
+
color: "color";
|
|
1683
|
+
offset: "offset";
|
|
1684
|
+
hidden: "hidden";
|
|
1685
|
+
muted: "muted";
|
|
1686
|
+
gap: "gap";
|
|
1687
|
+
borderRadius: "borderRadius";
|
|
1688
|
+
trimOffset: "trimOffset";
|
|
1689
|
+
strokeDashOffset: "strokeDashOffset";
|
|
1690
|
+
cornerRadius: "cornerRadius";
|
|
1691
|
+
starInnerRadiusRatio: "starInnerRadiusRatio";
|
|
1692
|
+
fillColor: "fillColor";
|
|
1693
|
+
strokeColor: "strokeColor";
|
|
1694
|
+
motionBlurShutter: "motionBlurShutter";
|
|
1695
|
+
rangeStart: "rangeStart";
|
|
1696
|
+
rangeEnd: "rangeEnd";
|
|
1697
|
+
animatorRangeStart: "animatorRangeStart";
|
|
1698
|
+
animatorRangeEnd: "animatorRangeEnd";
|
|
1699
|
+
animatorOffset: "animatorOffset";
|
|
1700
|
+
firstMargin: "firstMargin";
|
|
1701
|
+
lastMargin: "lastMargin";
|
|
1702
|
+
baselineShift: "baselineShift";
|
|
1703
|
+
rotateX: "rotateX";
|
|
1704
|
+
rotateY: "rotateY";
|
|
1705
|
+
rotateZ: "rotateZ";
|
|
1706
|
+
perspective: "perspective";
|
|
1707
|
+
translateZ: "translateZ";
|
|
1708
|
+
perspectiveOriginX: "perspectiveOriginX";
|
|
1709
|
+
perspectiveOriginY: "perspectiveOriginY";
|
|
1710
|
+
cameraX: "cameraX";
|
|
1711
|
+
cameraY: "cameraY";
|
|
1712
|
+
cameraZ: "cameraZ";
|
|
1713
|
+
targetX: "targetX";
|
|
1714
|
+
targetY: "targetY";
|
|
1715
|
+
targetZ: "targetZ";
|
|
1716
|
+
cameraPitch: "cameraPitch";
|
|
1717
|
+
cameraYaw: "cameraYaw";
|
|
1718
|
+
cameraRoll: "cameraRoll";
|
|
1719
|
+
cameraFov: "cameraFov";
|
|
1720
|
+
cameraZoom: "cameraZoom";
|
|
1721
|
+
focalLength: "focalLength";
|
|
1722
|
+
focusDistance: "focusDistance";
|
|
1723
|
+
fStop: "fStop";
|
|
1724
|
+
maxBlurRadius: "maxBlurRadius";
|
|
1725
|
+
shakeTranslation: "shakeTranslation";
|
|
1726
|
+
shakeRotation: "shakeRotation";
|
|
1727
|
+
orbitRadius: "orbitRadius";
|
|
1728
|
+
orbitAzimuth: "orbitAzimuth";
|
|
1729
|
+
orbitElevation: "orbitElevation";
|
|
1730
|
+
z: "z";
|
|
1731
|
+
scaleZ: "scaleZ";
|
|
1732
|
+
intensity: "intensity";
|
|
1733
|
+
angle: "angle";
|
|
1734
|
+
radius: "radius";
|
|
1735
|
+
penumbra: "penumbra";
|
|
1736
|
+
decay: "decay";
|
|
1737
|
+
shininess: "shininess";
|
|
1738
|
+
roughness: "roughness";
|
|
1739
|
+
specularIntensity: "specularIntensity";
|
|
1740
|
+
ambientIntensity: "ambientIntensity";
|
|
1741
|
+
metallic: "metallic";
|
|
1742
|
+
ior: "ior";
|
|
1743
|
+
dispersion: "dispersion";
|
|
1744
|
+
transmission: "transmission";
|
|
1745
|
+
fresnelPower: "fresnelPower";
|
|
1746
|
+
envIntensity: "envIntensity";
|
|
1747
|
+
animationProgress: "animationProgress";
|
|
1748
|
+
animationTime: "animationTime";
|
|
1749
|
+
animationSpeed: "animationSpeed";
|
|
1750
|
+
wireframe: "wireframe";
|
|
1751
|
+
scaleX: "scaleX";
|
|
1752
|
+
scaleY: "scaleY";
|
|
1753
|
+
}>;
|
|
1754
|
+
type AnimatableProp = z.infer<typeof AnimatablePropSchema>;
|
|
1755
|
+
declare const MaterialTypeSchema: z.ZodEnum<{
|
|
1756
|
+
metallic: "metallic";
|
|
1757
|
+
lit: "lit";
|
|
1758
|
+
unlit: "unlit";
|
|
1759
|
+
toon: "toon";
|
|
1760
|
+
glass: "glass";
|
|
1761
|
+
acrylic: "acrylic";
|
|
1762
|
+
frosted: "frosted";
|
|
1763
|
+
}>;
|
|
1764
|
+
type MaterialType = z.infer<typeof MaterialTypeSchema>;
|
|
1765
|
+
declare const EXTENDED_3D_ANIMATABLE_PROPS: readonly ["rotateX", "rotateY", "rotateZ", "perspective", "translateZ", "perspectiveOriginX", "perspectiveOriginY", "cameraX", "cameraY", "cameraZ", "targetX", "targetY", "targetZ", "cameraPitch", "cameraYaw", "cameraRoll", "cameraFov", "cameraZoom", "focalLength", "focusDistance", "fStop", "maxBlurRadius", "shakeTranslation", "shakeRotation", "orbitRadius", "orbitAzimuth", "orbitElevation", "z", "scaleZ", "intensity", "angle", "radius", "penumbra", "decay", "shininess", "roughness", "specularIntensity", "ambientIntensity", "metallic"];
|
|
1766
|
+
type Extended3DAnimatableProp = (typeof EXTENDED_3D_ANIMATABLE_PROPS)[number];
|
|
1767
|
+
declare const SignalColorModeSchema: z.ZodEnum<{
|
|
1768
|
+
interpolate: "interpolate";
|
|
1769
|
+
hueRotate: "hueRotate";
|
|
1770
|
+
threshold: "threshold";
|
|
1771
|
+
}>;
|
|
1772
|
+
type SignalColorMode = z.infer<typeof SignalColorModeSchema>;
|
|
1773
|
+
declare const EaseRefSchema: z.ZodObject<{
|
|
1774
|
+
name: z.ZodEnum<{
|
|
1775
|
+
bounce: "bounce";
|
|
1776
|
+
none: "none";
|
|
1777
|
+
power1: "power1";
|
|
1778
|
+
power2: "power2";
|
|
1779
|
+
power3: "power3";
|
|
1780
|
+
sine: "sine";
|
|
1781
|
+
circ: "circ";
|
|
1782
|
+
expo: "expo";
|
|
1783
|
+
back: "back";
|
|
1784
|
+
elastic: "elastic";
|
|
1785
|
+
spring: "spring";
|
|
1786
|
+
cubic: "cubic";
|
|
1787
|
+
hold: "hold";
|
|
1788
|
+
}>;
|
|
1789
|
+
dir: z.ZodEnum<{
|
|
1790
|
+
out: "out";
|
|
1791
|
+
in: "in";
|
|
1792
|
+
inOut: "inOut";
|
|
1793
|
+
}>;
|
|
1794
|
+
params: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
|
|
1795
|
+
}, z.core.$strict>;
|
|
1796
|
+
type EaseRef = z.infer<typeof EaseRefSchema>;
|
|
1797
|
+
declare const KeyframeSchema: z.ZodObject<{
|
|
1798
|
+
id: z.ZodString;
|
|
1799
|
+
frame: z.ZodNumber;
|
|
1800
|
+
value: z.ZodUnion<readonly [z.ZodNumber, z.ZodBoolean, z.ZodString]>;
|
|
1801
|
+
ease: z.ZodOptional<z.ZodObject<{
|
|
1802
|
+
name: z.ZodEnum<{
|
|
1803
|
+
bounce: "bounce";
|
|
1804
|
+
none: "none";
|
|
1805
|
+
power1: "power1";
|
|
1806
|
+
power2: "power2";
|
|
1807
|
+
power3: "power3";
|
|
1808
|
+
sine: "sine";
|
|
1809
|
+
circ: "circ";
|
|
1810
|
+
expo: "expo";
|
|
1811
|
+
back: "back";
|
|
1812
|
+
elastic: "elastic";
|
|
1813
|
+
spring: "spring";
|
|
1814
|
+
cubic: "cubic";
|
|
1815
|
+
hold: "hold";
|
|
1816
|
+
}>;
|
|
1817
|
+
dir: z.ZodEnum<{
|
|
1818
|
+
out: "out";
|
|
1819
|
+
in: "in";
|
|
1820
|
+
inOut: "inOut";
|
|
1821
|
+
}>;
|
|
1822
|
+
params: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
|
|
1823
|
+
}, z.core.$strict>>;
|
|
1824
|
+
presetGroupId: z.ZodOptional<z.ZodString>;
|
|
1825
|
+
presetType: z.ZodOptional<z.ZodString>;
|
|
1826
|
+
spatialTangentIn: z.ZodOptional<z.ZodObject<{
|
|
1827
|
+
x: z.ZodNumber;
|
|
1828
|
+
y: z.ZodNumber;
|
|
1829
|
+
}, z.core.$strip>>;
|
|
1830
|
+
spatialTangentOut: z.ZodOptional<z.ZodObject<{
|
|
1831
|
+
x: z.ZodNumber;
|
|
1832
|
+
y: z.ZodNumber;
|
|
1833
|
+
}, z.core.$strip>>;
|
|
1834
|
+
}, z.core.$strict>;
|
|
1835
|
+
type Keyframe = z.infer<typeof KeyframeSchema>;
|
|
1836
|
+
declare const SignalModeSchema: z.ZodEnum<{
|
|
1837
|
+
continuous: "continuous";
|
|
1838
|
+
accumulate: "accumulate";
|
|
1839
|
+
}>;
|
|
1840
|
+
type SignalMode = z.infer<typeof SignalModeSchema>;
|
|
1841
|
+
declare const RawTrackSourceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1842
|
+
type: z.ZodLiteral<"keyframe">;
|
|
1843
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1844
|
+
type: z.ZodLiteral<"signal">;
|
|
1845
|
+
inputHandleId: z.ZodString;
|
|
1846
|
+
multiplier: z.ZodDefault<z.ZodNumber>;
|
|
1847
|
+
offset: z.ZodDefault<z.ZodNumber>;
|
|
1848
|
+
smoothingWindowFrames: z.ZodDefault<z.ZodNumber>;
|
|
1849
|
+
colorMode: z.ZodOptional<z.ZodEnum<{
|
|
1850
|
+
interpolate: "interpolate";
|
|
1851
|
+
hueRotate: "hueRotate";
|
|
1852
|
+
threshold: "threshold";
|
|
1853
|
+
}>>;
|
|
1854
|
+
colorA: z.ZodOptional<z.ZodString>;
|
|
1855
|
+
colorB: z.ZodOptional<z.ZodString>;
|
|
1856
|
+
colorThreshold: z.ZodOptional<z.ZodNumber>;
|
|
1857
|
+
signalMode: z.ZodOptional<z.ZodEnum<{
|
|
1858
|
+
continuous: "continuous";
|
|
1859
|
+
accumulate: "accumulate";
|
|
1860
|
+
}>>;
|
|
1861
|
+
threshold: z.ZodOptional<z.ZodNumber>;
|
|
1862
|
+
accumulateThreshold: z.ZodOptional<z.ZodNumber>;
|
|
1863
|
+
debounceFrames: z.ZodOptional<z.ZodNumber>;
|
|
1864
|
+
channel: z.ZodOptional<z.ZodString>;
|
|
1865
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1866
|
+
type: z.ZodLiteral<"wiggle">;
|
|
1867
|
+
frequency: z.ZodDefault<z.ZodNumber>;
|
|
1868
|
+
amplitude: z.ZodDefault<z.ZodNumber>;
|
|
1869
|
+
octaves: z.ZodDefault<z.ZodNumber>;
|
|
1870
|
+
seed: z.ZodDefault<z.ZodNumber>;
|
|
1871
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1872
|
+
type: z.ZodLiteral<"springOvershoot">;
|
|
1873
|
+
damping: z.ZodDefault<z.ZodNumber>;
|
|
1874
|
+
stiffness: z.ZodDefault<z.ZodNumber>;
|
|
1875
|
+
mass: z.ZodDefault<z.ZodNumber>;
|
|
1876
|
+
}, z.core.$strip>], "type">;
|
|
1877
|
+
declare const TrackSourceSchema: typeof RawTrackSourceSchema;
|
|
1878
|
+
type TrackSource = z.infer<typeof RawTrackSourceSchema>;
|
|
1879
|
+
type SignalTrackSource = Extract<TrackSource, {
|
|
1880
|
+
type: "signal";
|
|
1881
|
+
}>;
|
|
1882
|
+
declare const AnimationTrackSchema: z.ZodObject<{
|
|
1883
|
+
id: z.ZodString;
|
|
1884
|
+
prop: z.ZodEnum<{
|
|
1885
|
+
x: "x";
|
|
1886
|
+
y: "y";
|
|
1887
|
+
width: "width";
|
|
1888
|
+
height: "height";
|
|
1889
|
+
rotation: "rotation";
|
|
1890
|
+
scale: "scale";
|
|
1891
|
+
opacity: "opacity";
|
|
1892
|
+
trimStart: "trimStart";
|
|
1893
|
+
trimEnd: "trimEnd";
|
|
1894
|
+
text: "text";
|
|
1895
|
+
fontSize: "fontSize";
|
|
1896
|
+
fill: "fill";
|
|
1897
|
+
letterSpacing: "letterSpacing";
|
|
1898
|
+
padding: "padding";
|
|
1899
|
+
strokeWidth: "strokeWidth";
|
|
1900
|
+
borderColor: "borderColor";
|
|
1901
|
+
borderWidth: "borderWidth";
|
|
1902
|
+
volume: "volume";
|
|
1903
|
+
color: "color";
|
|
1904
|
+
offset: "offset";
|
|
1905
|
+
hidden: "hidden";
|
|
1906
|
+
muted: "muted";
|
|
1907
|
+
gap: "gap";
|
|
1908
|
+
borderRadius: "borderRadius";
|
|
1909
|
+
trimOffset: "trimOffset";
|
|
1910
|
+
strokeDashOffset: "strokeDashOffset";
|
|
1911
|
+
cornerRadius: "cornerRadius";
|
|
1912
|
+
starInnerRadiusRatio: "starInnerRadiusRatio";
|
|
1913
|
+
fillColor: "fillColor";
|
|
1914
|
+
strokeColor: "strokeColor";
|
|
1915
|
+
motionBlurShutter: "motionBlurShutter";
|
|
1916
|
+
rangeStart: "rangeStart";
|
|
1917
|
+
rangeEnd: "rangeEnd";
|
|
1918
|
+
animatorRangeStart: "animatorRangeStart";
|
|
1919
|
+
animatorRangeEnd: "animatorRangeEnd";
|
|
1920
|
+
animatorOffset: "animatorOffset";
|
|
1921
|
+
firstMargin: "firstMargin";
|
|
1922
|
+
lastMargin: "lastMargin";
|
|
1923
|
+
baselineShift: "baselineShift";
|
|
1924
|
+
rotateX: "rotateX";
|
|
1925
|
+
rotateY: "rotateY";
|
|
1926
|
+
rotateZ: "rotateZ";
|
|
1927
|
+
perspective: "perspective";
|
|
1928
|
+
translateZ: "translateZ";
|
|
1929
|
+
perspectiveOriginX: "perspectiveOriginX";
|
|
1930
|
+
perspectiveOriginY: "perspectiveOriginY";
|
|
1931
|
+
cameraX: "cameraX";
|
|
1932
|
+
cameraY: "cameraY";
|
|
1933
|
+
cameraZ: "cameraZ";
|
|
1934
|
+
targetX: "targetX";
|
|
1935
|
+
targetY: "targetY";
|
|
1936
|
+
targetZ: "targetZ";
|
|
1937
|
+
cameraPitch: "cameraPitch";
|
|
1938
|
+
cameraYaw: "cameraYaw";
|
|
1939
|
+
cameraRoll: "cameraRoll";
|
|
1940
|
+
cameraFov: "cameraFov";
|
|
1941
|
+
cameraZoom: "cameraZoom";
|
|
1942
|
+
focalLength: "focalLength";
|
|
1943
|
+
focusDistance: "focusDistance";
|
|
1944
|
+
fStop: "fStop";
|
|
1945
|
+
maxBlurRadius: "maxBlurRadius";
|
|
1946
|
+
shakeTranslation: "shakeTranslation";
|
|
1947
|
+
shakeRotation: "shakeRotation";
|
|
1948
|
+
orbitRadius: "orbitRadius";
|
|
1949
|
+
orbitAzimuth: "orbitAzimuth";
|
|
1950
|
+
orbitElevation: "orbitElevation";
|
|
1951
|
+
z: "z";
|
|
1952
|
+
scaleZ: "scaleZ";
|
|
1953
|
+
intensity: "intensity";
|
|
1954
|
+
angle: "angle";
|
|
1955
|
+
radius: "radius";
|
|
1956
|
+
penumbra: "penumbra";
|
|
1957
|
+
decay: "decay";
|
|
1958
|
+
shininess: "shininess";
|
|
1959
|
+
roughness: "roughness";
|
|
1960
|
+
specularIntensity: "specularIntensity";
|
|
1961
|
+
ambientIntensity: "ambientIntensity";
|
|
1962
|
+
metallic: "metallic";
|
|
1963
|
+
ior: "ior";
|
|
1964
|
+
dispersion: "dispersion";
|
|
1965
|
+
transmission: "transmission";
|
|
1966
|
+
fresnelPower: "fresnelPower";
|
|
1967
|
+
envIntensity: "envIntensity";
|
|
1968
|
+
animationProgress: "animationProgress";
|
|
1969
|
+
animationTime: "animationTime";
|
|
1970
|
+
animationSpeed: "animationSpeed";
|
|
1971
|
+
wireframe: "wireframe";
|
|
1972
|
+
scaleX: "scaleX";
|
|
1973
|
+
scaleY: "scaleY";
|
|
1974
|
+
}>;
|
|
1975
|
+
source: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1976
|
+
type: z.ZodLiteral<"keyframe">;
|
|
1977
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1978
|
+
type: z.ZodLiteral<"signal">;
|
|
1979
|
+
inputHandleId: z.ZodString;
|
|
1980
|
+
multiplier: z.ZodDefault<z.ZodNumber>;
|
|
1981
|
+
offset: z.ZodDefault<z.ZodNumber>;
|
|
1982
|
+
smoothingWindowFrames: z.ZodDefault<z.ZodNumber>;
|
|
1983
|
+
colorMode: z.ZodOptional<z.ZodEnum<{
|
|
1984
|
+
interpolate: "interpolate";
|
|
1985
|
+
hueRotate: "hueRotate";
|
|
1986
|
+
threshold: "threshold";
|
|
1987
|
+
}>>;
|
|
1988
|
+
colorA: z.ZodOptional<z.ZodString>;
|
|
1989
|
+
colorB: z.ZodOptional<z.ZodString>;
|
|
1990
|
+
colorThreshold: z.ZodOptional<z.ZodNumber>;
|
|
1991
|
+
signalMode: z.ZodOptional<z.ZodEnum<{
|
|
1992
|
+
continuous: "continuous";
|
|
1993
|
+
accumulate: "accumulate";
|
|
1994
|
+
}>>;
|
|
1995
|
+
threshold: z.ZodOptional<z.ZodNumber>;
|
|
1996
|
+
accumulateThreshold: z.ZodOptional<z.ZodNumber>;
|
|
1997
|
+
debounceFrames: z.ZodOptional<z.ZodNumber>;
|
|
1998
|
+
channel: z.ZodOptional<z.ZodString>;
|
|
1999
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
2000
|
+
type: z.ZodLiteral<"wiggle">;
|
|
2001
|
+
frequency: z.ZodDefault<z.ZodNumber>;
|
|
2002
|
+
amplitude: z.ZodDefault<z.ZodNumber>;
|
|
2003
|
+
octaves: z.ZodDefault<z.ZodNumber>;
|
|
2004
|
+
seed: z.ZodDefault<z.ZodNumber>;
|
|
2005
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
2006
|
+
type: z.ZodLiteral<"springOvershoot">;
|
|
2007
|
+
damping: z.ZodDefault<z.ZodNumber>;
|
|
2008
|
+
stiffness: z.ZodDefault<z.ZodNumber>;
|
|
2009
|
+
mass: z.ZodDefault<z.ZodNumber>;
|
|
2010
|
+
}, z.core.$strip>], "type">>;
|
|
2011
|
+
keyframes: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
2012
|
+
id: z.ZodString;
|
|
2013
|
+
frame: z.ZodNumber;
|
|
2014
|
+
value: z.ZodUnion<readonly [z.ZodNumber, z.ZodBoolean, z.ZodString]>;
|
|
2015
|
+
ease: z.ZodOptional<z.ZodObject<{
|
|
2016
|
+
name: z.ZodEnum<{
|
|
2017
|
+
bounce: "bounce";
|
|
2018
|
+
none: "none";
|
|
2019
|
+
power1: "power1";
|
|
2020
|
+
power2: "power2";
|
|
2021
|
+
power3: "power3";
|
|
2022
|
+
sine: "sine";
|
|
2023
|
+
circ: "circ";
|
|
2024
|
+
expo: "expo";
|
|
2025
|
+
back: "back";
|
|
2026
|
+
elastic: "elastic";
|
|
2027
|
+
spring: "spring";
|
|
2028
|
+
cubic: "cubic";
|
|
2029
|
+
hold: "hold";
|
|
2030
|
+
}>;
|
|
2031
|
+
dir: z.ZodEnum<{
|
|
2032
|
+
out: "out";
|
|
2033
|
+
in: "in";
|
|
2034
|
+
inOut: "inOut";
|
|
2035
|
+
}>;
|
|
2036
|
+
params: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
|
|
2037
|
+
}, z.core.$strict>>;
|
|
2038
|
+
presetGroupId: z.ZodOptional<z.ZodString>;
|
|
2039
|
+
presetType: z.ZodOptional<z.ZodString>;
|
|
2040
|
+
spatialTangentIn: z.ZodOptional<z.ZodObject<{
|
|
2041
|
+
x: z.ZodNumber;
|
|
2042
|
+
y: z.ZodNumber;
|
|
2043
|
+
}, z.core.$strip>>;
|
|
2044
|
+
spatialTangentOut: z.ZodOptional<z.ZodObject<{
|
|
2045
|
+
x: z.ZodNumber;
|
|
2046
|
+
y: z.ZodNumber;
|
|
2047
|
+
}, z.core.$strip>>;
|
|
2048
|
+
}, z.core.$strict>>>;
|
|
2049
|
+
repeat: z.ZodOptional<z.ZodNumber>;
|
|
2050
|
+
yoyo: z.ZodOptional<z.ZodBoolean>;
|
|
2051
|
+
durationFrames: z.ZodOptional<z.ZodNumber>;
|
|
2052
|
+
}, z.core.$strict>;
|
|
2053
|
+
type AnimationTrack = z.infer<typeof AnimationTrackSchema>;
|
|
2054
|
+
declare const LayerAnimationSchema: z.ZodObject<{
|
|
2055
|
+
tracks: z.ZodArray<z.ZodObject<{
|
|
2056
|
+
id: z.ZodString;
|
|
2057
|
+
prop: z.ZodEnum<{
|
|
2058
|
+
x: "x";
|
|
2059
|
+
y: "y";
|
|
2060
|
+
width: "width";
|
|
2061
|
+
height: "height";
|
|
2062
|
+
rotation: "rotation";
|
|
2063
|
+
scale: "scale";
|
|
2064
|
+
opacity: "opacity";
|
|
2065
|
+
trimStart: "trimStart";
|
|
2066
|
+
trimEnd: "trimEnd";
|
|
2067
|
+
text: "text";
|
|
2068
|
+
fontSize: "fontSize";
|
|
2069
|
+
fill: "fill";
|
|
2070
|
+
letterSpacing: "letterSpacing";
|
|
2071
|
+
padding: "padding";
|
|
2072
|
+
strokeWidth: "strokeWidth";
|
|
2073
|
+
borderColor: "borderColor";
|
|
2074
|
+
borderWidth: "borderWidth";
|
|
2075
|
+
volume: "volume";
|
|
2076
|
+
color: "color";
|
|
2077
|
+
offset: "offset";
|
|
2078
|
+
hidden: "hidden";
|
|
2079
|
+
muted: "muted";
|
|
2080
|
+
gap: "gap";
|
|
2081
|
+
borderRadius: "borderRadius";
|
|
2082
|
+
trimOffset: "trimOffset";
|
|
2083
|
+
strokeDashOffset: "strokeDashOffset";
|
|
2084
|
+
cornerRadius: "cornerRadius";
|
|
2085
|
+
starInnerRadiusRatio: "starInnerRadiusRatio";
|
|
2086
|
+
fillColor: "fillColor";
|
|
2087
|
+
strokeColor: "strokeColor";
|
|
2088
|
+
motionBlurShutter: "motionBlurShutter";
|
|
2089
|
+
rangeStart: "rangeStart";
|
|
2090
|
+
rangeEnd: "rangeEnd";
|
|
2091
|
+
animatorRangeStart: "animatorRangeStart";
|
|
2092
|
+
animatorRangeEnd: "animatorRangeEnd";
|
|
2093
|
+
animatorOffset: "animatorOffset";
|
|
2094
|
+
firstMargin: "firstMargin";
|
|
2095
|
+
lastMargin: "lastMargin";
|
|
2096
|
+
baselineShift: "baselineShift";
|
|
2097
|
+
rotateX: "rotateX";
|
|
2098
|
+
rotateY: "rotateY";
|
|
2099
|
+
rotateZ: "rotateZ";
|
|
2100
|
+
perspective: "perspective";
|
|
2101
|
+
translateZ: "translateZ";
|
|
2102
|
+
perspectiveOriginX: "perspectiveOriginX";
|
|
2103
|
+
perspectiveOriginY: "perspectiveOriginY";
|
|
2104
|
+
cameraX: "cameraX";
|
|
2105
|
+
cameraY: "cameraY";
|
|
2106
|
+
cameraZ: "cameraZ";
|
|
2107
|
+
targetX: "targetX";
|
|
2108
|
+
targetY: "targetY";
|
|
2109
|
+
targetZ: "targetZ";
|
|
2110
|
+
cameraPitch: "cameraPitch";
|
|
2111
|
+
cameraYaw: "cameraYaw";
|
|
2112
|
+
cameraRoll: "cameraRoll";
|
|
2113
|
+
cameraFov: "cameraFov";
|
|
2114
|
+
cameraZoom: "cameraZoom";
|
|
2115
|
+
focalLength: "focalLength";
|
|
2116
|
+
focusDistance: "focusDistance";
|
|
2117
|
+
fStop: "fStop";
|
|
2118
|
+
maxBlurRadius: "maxBlurRadius";
|
|
2119
|
+
shakeTranslation: "shakeTranslation";
|
|
2120
|
+
shakeRotation: "shakeRotation";
|
|
2121
|
+
orbitRadius: "orbitRadius";
|
|
2122
|
+
orbitAzimuth: "orbitAzimuth";
|
|
2123
|
+
orbitElevation: "orbitElevation";
|
|
2124
|
+
z: "z";
|
|
2125
|
+
scaleZ: "scaleZ";
|
|
2126
|
+
intensity: "intensity";
|
|
2127
|
+
angle: "angle";
|
|
2128
|
+
radius: "radius";
|
|
2129
|
+
penumbra: "penumbra";
|
|
2130
|
+
decay: "decay";
|
|
2131
|
+
shininess: "shininess";
|
|
2132
|
+
roughness: "roughness";
|
|
2133
|
+
specularIntensity: "specularIntensity";
|
|
2134
|
+
ambientIntensity: "ambientIntensity";
|
|
2135
|
+
metallic: "metallic";
|
|
2136
|
+
ior: "ior";
|
|
2137
|
+
dispersion: "dispersion";
|
|
2138
|
+
transmission: "transmission";
|
|
2139
|
+
fresnelPower: "fresnelPower";
|
|
2140
|
+
envIntensity: "envIntensity";
|
|
2141
|
+
animationProgress: "animationProgress";
|
|
2142
|
+
animationTime: "animationTime";
|
|
2143
|
+
animationSpeed: "animationSpeed";
|
|
2144
|
+
wireframe: "wireframe";
|
|
2145
|
+
scaleX: "scaleX";
|
|
2146
|
+
scaleY: "scaleY";
|
|
2147
|
+
}>;
|
|
2148
|
+
source: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
2149
|
+
type: z.ZodLiteral<"keyframe">;
|
|
2150
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
2151
|
+
type: z.ZodLiteral<"signal">;
|
|
2152
|
+
inputHandleId: z.ZodString;
|
|
2153
|
+
multiplier: z.ZodDefault<z.ZodNumber>;
|
|
2154
|
+
offset: z.ZodDefault<z.ZodNumber>;
|
|
2155
|
+
smoothingWindowFrames: z.ZodDefault<z.ZodNumber>;
|
|
2156
|
+
colorMode: z.ZodOptional<z.ZodEnum<{
|
|
2157
|
+
interpolate: "interpolate";
|
|
2158
|
+
hueRotate: "hueRotate";
|
|
2159
|
+
threshold: "threshold";
|
|
2160
|
+
}>>;
|
|
2161
|
+
colorA: z.ZodOptional<z.ZodString>;
|
|
2162
|
+
colorB: z.ZodOptional<z.ZodString>;
|
|
2163
|
+
colorThreshold: z.ZodOptional<z.ZodNumber>;
|
|
2164
|
+
signalMode: z.ZodOptional<z.ZodEnum<{
|
|
2165
|
+
continuous: "continuous";
|
|
2166
|
+
accumulate: "accumulate";
|
|
2167
|
+
}>>;
|
|
2168
|
+
threshold: z.ZodOptional<z.ZodNumber>;
|
|
2169
|
+
accumulateThreshold: z.ZodOptional<z.ZodNumber>;
|
|
2170
|
+
debounceFrames: z.ZodOptional<z.ZodNumber>;
|
|
2171
|
+
channel: z.ZodOptional<z.ZodString>;
|
|
2172
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
2173
|
+
type: z.ZodLiteral<"wiggle">;
|
|
2174
|
+
frequency: z.ZodDefault<z.ZodNumber>;
|
|
2175
|
+
amplitude: z.ZodDefault<z.ZodNumber>;
|
|
2176
|
+
octaves: z.ZodDefault<z.ZodNumber>;
|
|
2177
|
+
seed: z.ZodDefault<z.ZodNumber>;
|
|
2178
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
2179
|
+
type: z.ZodLiteral<"springOvershoot">;
|
|
2180
|
+
damping: z.ZodDefault<z.ZodNumber>;
|
|
2181
|
+
stiffness: z.ZodDefault<z.ZodNumber>;
|
|
2182
|
+
mass: z.ZodDefault<z.ZodNumber>;
|
|
2183
|
+
}, z.core.$strip>], "type">>;
|
|
2184
|
+
keyframes: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
2185
|
+
id: z.ZodString;
|
|
2186
|
+
frame: z.ZodNumber;
|
|
2187
|
+
value: z.ZodUnion<readonly [z.ZodNumber, z.ZodBoolean, z.ZodString]>;
|
|
2188
|
+
ease: z.ZodOptional<z.ZodObject<{
|
|
2189
|
+
name: z.ZodEnum<{
|
|
2190
|
+
bounce: "bounce";
|
|
2191
|
+
none: "none";
|
|
2192
|
+
power1: "power1";
|
|
2193
|
+
power2: "power2";
|
|
2194
|
+
power3: "power3";
|
|
2195
|
+
sine: "sine";
|
|
2196
|
+
circ: "circ";
|
|
2197
|
+
expo: "expo";
|
|
2198
|
+
back: "back";
|
|
2199
|
+
elastic: "elastic";
|
|
2200
|
+
spring: "spring";
|
|
2201
|
+
cubic: "cubic";
|
|
2202
|
+
hold: "hold";
|
|
2203
|
+
}>;
|
|
2204
|
+
dir: z.ZodEnum<{
|
|
2205
|
+
out: "out";
|
|
2206
|
+
in: "in";
|
|
2207
|
+
inOut: "inOut";
|
|
2208
|
+
}>;
|
|
2209
|
+
params: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
|
|
2210
|
+
}, z.core.$strict>>;
|
|
2211
|
+
presetGroupId: z.ZodOptional<z.ZodString>;
|
|
2212
|
+
presetType: z.ZodOptional<z.ZodString>;
|
|
2213
|
+
spatialTangentIn: z.ZodOptional<z.ZodObject<{
|
|
2214
|
+
x: z.ZodNumber;
|
|
2215
|
+
y: z.ZodNumber;
|
|
2216
|
+
}, z.core.$strip>>;
|
|
2217
|
+
spatialTangentOut: z.ZodOptional<z.ZodObject<{
|
|
2218
|
+
x: z.ZodNumber;
|
|
2219
|
+
y: z.ZodNumber;
|
|
2220
|
+
}, z.core.$strip>>;
|
|
2221
|
+
}, z.core.$strict>>>;
|
|
2222
|
+
repeat: z.ZodOptional<z.ZodNumber>;
|
|
2223
|
+
yoyo: z.ZodOptional<z.ZodBoolean>;
|
|
2224
|
+
durationFrames: z.ZodOptional<z.ZodNumber>;
|
|
2225
|
+
}, z.core.$strict>>;
|
|
2226
|
+
}, z.core.$strict>;
|
|
2227
|
+
type LayerAnimationSpec = z.infer<typeof LayerAnimationSchema>;
|
|
2228
|
+
interface CompositionNodeBase {
|
|
2229
|
+
id: string;
|
|
2230
|
+
inputHandleId?: string;
|
|
2231
|
+
position?: "relative" | "absolute";
|
|
2232
|
+
x?: number | unknown;
|
|
2233
|
+
y?: number | unknown;
|
|
2234
|
+
width?: SizeSpec;
|
|
2235
|
+
height?: SizeSpec;
|
|
2236
|
+
grow?: number;
|
|
2237
|
+
flexShrink?: number;
|
|
2238
|
+
flexBasis?: number;
|
|
2239
|
+
alignSelf?: "auto" | "start" | "center" | "end" | "stretch" | "baseline";
|
|
2240
|
+
aspectRatio?: number;
|
|
2241
|
+
zIndex?: number;
|
|
2242
|
+
hidden?: boolean;
|
|
2243
|
+
opacity?: number;
|
|
2244
|
+
blendMode?: string;
|
|
2245
|
+
rotation?: number;
|
|
2246
|
+
scale?: number;
|
|
2247
|
+
anchorX?: number;
|
|
2248
|
+
anchorY?: number;
|
|
2249
|
+
rotateX?: number;
|
|
2250
|
+
rotateY?: number;
|
|
2251
|
+
rotateZ?: number;
|
|
2252
|
+
perspective?: number;
|
|
2253
|
+
perspectiveOriginX?: number;
|
|
2254
|
+
perspectiveOriginY?: number;
|
|
2255
|
+
translateZ?: number;
|
|
2256
|
+
backfaceVisibility?: "visible" | "hidden";
|
|
2257
|
+
transformStyle?: "flat" | "preserve-3d";
|
|
2258
|
+
is3D?: boolean;
|
|
2259
|
+
z?: number | unknown;
|
|
2260
|
+
scaleZ?: number;
|
|
2261
|
+
twoSided?: boolean;
|
|
2262
|
+
material?: MaterialType;
|
|
2263
|
+
shininess?: number;
|
|
2264
|
+
roughness?: number;
|
|
2265
|
+
specularIntensity?: number;
|
|
2266
|
+
metallic?: number;
|
|
2267
|
+
ambientIntensity?: number;
|
|
2268
|
+
ior?: number;
|
|
2269
|
+
transmission?: number;
|
|
2270
|
+
dispersion?: number;
|
|
2271
|
+
fresnelPower?: number;
|
|
2272
|
+
envIntensity?: number;
|
|
2273
|
+
startFrame?: number;
|
|
2274
|
+
durationFrames?: number;
|
|
2275
|
+
motionBlurShutter?: number;
|
|
2276
|
+
animation?: LayerAnimationSpec;
|
|
2277
|
+
vision?: unknown;
|
|
2278
|
+
relighting?: unknown;
|
|
2279
|
+
}
|
|
2280
|
+
interface FlexNode extends CompositionNodeBase {
|
|
2281
|
+
kind: "flex";
|
|
2282
|
+
dir?: "row" | "column";
|
|
2283
|
+
gap?: number;
|
|
2284
|
+
padding?: number;
|
|
2285
|
+
justify?: "start" | "center" | "end" | "space-between" | "space-around";
|
|
2286
|
+
align?: "start" | "center" | "end" | "stretch";
|
|
2287
|
+
wrap?: boolean;
|
|
2288
|
+
staggerFrames?: number;
|
|
2289
|
+
staggerDirection?: "forward" | "reverse" | "center-out";
|
|
2290
|
+
overflow?: "visible" | "hidden";
|
|
2291
|
+
background?: string;
|
|
2292
|
+
borderRadius?: number;
|
|
2293
|
+
borderColor?: string;
|
|
2294
|
+
borderWidth?: number;
|
|
2295
|
+
strokeAlign?: "inside" | "center" | "outside";
|
|
2296
|
+
strokeRadius?: number;
|
|
2297
|
+
children?: LayoutNode[];
|
|
2298
|
+
}
|
|
2299
|
+
interface BlockNode extends CompositionNodeBase {
|
|
2300
|
+
kind: "block";
|
|
2301
|
+
gap?: number;
|
|
2302
|
+
padding?: number;
|
|
2303
|
+
align?: "start" | "center" | "end" | "stretch";
|
|
2304
|
+
staggerFrames?: number;
|
|
2305
|
+
staggerDirection?: "forward" | "reverse" | "center-out";
|
|
2306
|
+
overflow?: "visible" | "hidden";
|
|
2307
|
+
background?: string;
|
|
2308
|
+
borderRadius?: number;
|
|
2309
|
+
borderColor?: string;
|
|
2310
|
+
borderWidth?: number;
|
|
2311
|
+
strokeAlign?: "inside" | "center" | "outside";
|
|
2312
|
+
strokeRadius?: number;
|
|
2313
|
+
children?: LayoutNode[];
|
|
2314
|
+
}
|
|
2315
|
+
interface BoxNode extends CompositionNodeBase {
|
|
2316
|
+
kind: "box";
|
|
2317
|
+
background?: string;
|
|
2318
|
+
borderRadius?: number;
|
|
2319
|
+
padding?: number;
|
|
2320
|
+
staggerFrames?: number;
|
|
2321
|
+
staggerDirection?: "forward" | "reverse" | "center-out";
|
|
2322
|
+
overflow?: "visible" | "hidden";
|
|
2323
|
+
borderColor?: string;
|
|
2324
|
+
borderWidth?: number;
|
|
2325
|
+
strokeAlign?: "inside" | "center" | "outside";
|
|
2326
|
+
strokeRadius?: number;
|
|
2327
|
+
children?: LayoutNode[];
|
|
2328
|
+
}
|
|
2329
|
+
declare const TextShadowSchema: z.ZodObject<{
|
|
2330
|
+
color: z.ZodOptional<z.ZodString>;
|
|
2331
|
+
offset: z.ZodOptional<z.ZodObject<{
|
|
2332
|
+
x: z.ZodNumber;
|
|
2333
|
+
y: z.ZodNumber;
|
|
2334
|
+
}, z.core.$strip>>;
|
|
2335
|
+
blurRadius: z.ZodOptional<z.ZodNumber>;
|
|
2336
|
+
}, z.core.$strict>;
|
|
2337
|
+
type TextShadow = z.infer<typeof TextShadowSchema>;
|
|
2338
|
+
declare const TextAnimatorTransformSchema: z.ZodObject<{
|
|
2339
|
+
x: z.ZodOptional<z.ZodNumber>;
|
|
2340
|
+
y: z.ZodOptional<z.ZodNumber>;
|
|
2341
|
+
scale: z.ZodOptional<z.ZodNumber>;
|
|
2342
|
+
scaleX: z.ZodOptional<z.ZodNumber>;
|
|
2343
|
+
scaleY: z.ZodOptional<z.ZodNumber>;
|
|
2344
|
+
rotation: z.ZodOptional<z.ZodNumber>;
|
|
2345
|
+
rotationX: z.ZodOptional<z.ZodNumber>;
|
|
2346
|
+
rotationY: z.ZodOptional<z.ZodNumber>;
|
|
2347
|
+
opacity: z.ZodOptional<z.ZodNumber>;
|
|
2348
|
+
blur: z.ZodOptional<z.ZodNumber>;
|
|
2349
|
+
color: z.ZodOptional<z.ZodString>;
|
|
2350
|
+
}, z.core.$strict>;
|
|
2351
|
+
type TextAnimatorTransform = z.infer<typeof TextAnimatorTransformSchema>;
|
|
2352
|
+
declare const TextAnimatorSchema: z.ZodObject<{
|
|
2353
|
+
id: z.ZodString;
|
|
2354
|
+
unit: z.ZodDefault<z.ZodEnum<{
|
|
2355
|
+
character: "character";
|
|
2356
|
+
word: "word";
|
|
2357
|
+
line: "line";
|
|
2358
|
+
}>>;
|
|
2359
|
+
rangeStart: z.ZodDefault<z.ZodNumber>;
|
|
2360
|
+
rangeEnd: z.ZodDefault<z.ZodNumber>;
|
|
2361
|
+
offset: z.ZodDefault<z.ZodNumber>;
|
|
2362
|
+
easing: z.ZodDefault<z.ZodString>;
|
|
2363
|
+
transform: z.ZodOptional<z.ZodObject<{
|
|
2364
|
+
x: z.ZodOptional<z.ZodNumber>;
|
|
2365
|
+
y: z.ZodOptional<z.ZodNumber>;
|
|
2366
|
+
scale: z.ZodOptional<z.ZodNumber>;
|
|
2367
|
+
scaleX: z.ZodOptional<z.ZodNumber>;
|
|
2368
|
+
scaleY: z.ZodOptional<z.ZodNumber>;
|
|
2369
|
+
rotation: z.ZodOptional<z.ZodNumber>;
|
|
2370
|
+
rotationX: z.ZodOptional<z.ZodNumber>;
|
|
2371
|
+
rotationY: z.ZodOptional<z.ZodNumber>;
|
|
2372
|
+
opacity: z.ZodOptional<z.ZodNumber>;
|
|
2373
|
+
blur: z.ZodOptional<z.ZodNumber>;
|
|
2374
|
+
color: z.ZodOptional<z.ZodString>;
|
|
2375
|
+
}, z.core.$strict>>;
|
|
2376
|
+
}, z.core.$strip>;
|
|
2377
|
+
type TextAnimator = z.infer<typeof TextAnimatorSchema>;
|
|
2378
|
+
declare const TextAnimator: {
|
|
2379
|
+
/**
|
|
2380
|
+
* Per-character staggered wave rise with baseline tilt and fade.
|
|
2381
|
+
*/
|
|
2382
|
+
waveRise(options?: {
|
|
2383
|
+
id?: string;
|
|
2384
|
+
unit?: "character" | "word" | "line";
|
|
2385
|
+
y?: number;
|
|
2386
|
+
rotationX?: number;
|
|
2387
|
+
opacity?: number;
|
|
2388
|
+
blur?: number;
|
|
2389
|
+
easing?: string;
|
|
2390
|
+
rangeStart?: number;
|
|
2391
|
+
rangeEnd?: number;
|
|
2392
|
+
offset?: number;
|
|
2393
|
+
}): TextAnimator;
|
|
2394
|
+
/**
|
|
2395
|
+
* Per-word or per-character pop / scale bounce.
|
|
2396
|
+
*/
|
|
2397
|
+
wordPop(options?: {
|
|
2398
|
+
id?: string;
|
|
2399
|
+
scale?: number;
|
|
2400
|
+
y?: number;
|
|
2401
|
+
easing?: string;
|
|
2402
|
+
}): TextAnimator;
|
|
2403
|
+
/**
|
|
2404
|
+
* Per-character cinematic optical blur to crisp reveal.
|
|
2405
|
+
*/
|
|
2406
|
+
blurIn(options?: {
|
|
2407
|
+
id?: string;
|
|
2408
|
+
unit?: "character" | "word";
|
|
2409
|
+
blur?: number;
|
|
2410
|
+
y?: number;
|
|
2411
|
+
opacity?: number;
|
|
2412
|
+
easing?: string;
|
|
2413
|
+
}): TextAnimator;
|
|
2414
|
+
/**
|
|
2415
|
+
* 3D letter flip (like airport split-flap display or 3D letter roll).
|
|
2416
|
+
*/
|
|
2417
|
+
flip3D(options?: {
|
|
2418
|
+
id?: string;
|
|
2419
|
+
unit?: "character" | "word";
|
|
2420
|
+
rotationX?: number;
|
|
2421
|
+
easing?: string;
|
|
2422
|
+
}): TextAnimator;
|
|
2423
|
+
/**
|
|
2424
|
+
* Color sweep passing across glyphs/words.
|
|
2425
|
+
*/
|
|
2426
|
+
colorSweep(options: {
|
|
2427
|
+
id?: string;
|
|
2428
|
+
color: string;
|
|
2429
|
+
unit?: "character" | "word";
|
|
2430
|
+
easing?: string;
|
|
2431
|
+
}): TextAnimator;
|
|
2432
|
+
};
|
|
2433
|
+
interface TextNode extends CompositionNodeBase {
|
|
2434
|
+
kind: "text";
|
|
2435
|
+
text?: string;
|
|
2436
|
+
spans?: TextSpan[];
|
|
2437
|
+
fontFamily?: string;
|
|
2438
|
+
fontSize?: number;
|
|
2439
|
+
fontWeight?: number | string;
|
|
2440
|
+
fontStyle?: string;
|
|
2441
|
+
fill?: string;
|
|
2442
|
+
align?: "start" | "center" | "end";
|
|
2443
|
+
verticalAlign?: "top" | "middle" | "bottom";
|
|
2444
|
+
lineHeight?: number;
|
|
2445
|
+
letterSpacing?: number;
|
|
2446
|
+
background?: string;
|
|
2447
|
+
borderRadius?: number;
|
|
2448
|
+
padding?: number;
|
|
2449
|
+
stroke?: string;
|
|
2450
|
+
strokeWidth?: number;
|
|
2451
|
+
strokeAlign?: "inside" | "center" | "outside";
|
|
2452
|
+
textShadow?: string;
|
|
2453
|
+
shadows?: TextShadow[];
|
|
2454
|
+
pathOptions?: TextPathOptions;
|
|
2455
|
+
typewriter?: TypewriterAnimator;
|
|
2456
|
+
marquee?: KineticMarqueeConfig;
|
|
2457
|
+
animators?: (TextAnimator | AETextAnimator | AdvancedTextAnimator)[];
|
|
2458
|
+
}
|
|
2459
|
+
interface MediaNode extends CompositionNodeBase {
|
|
2460
|
+
kind: "media";
|
|
2461
|
+
inputHandleId: string;
|
|
2462
|
+
dataType?: string;
|
|
2463
|
+
fit?: "cover" | "contain" | "fill" | "none";
|
|
2464
|
+
borderRadius?: number;
|
|
2465
|
+
borderColor?: string;
|
|
2466
|
+
borderWidth?: number;
|
|
2467
|
+
strokeAlign?: "inside" | "center" | "outside";
|
|
2468
|
+
strokeRadius?: number;
|
|
2469
|
+
volume?: number;
|
|
2470
|
+
muted?: boolean;
|
|
2471
|
+
/** Source in-point: seconds into the clip that play at the layer's startFrame. */
|
|
2472
|
+
trimStartSec?: number;
|
|
2473
|
+
fontFamily?: string;
|
|
2474
|
+
fontSize?: number;
|
|
2475
|
+
fontWeight?: number | string;
|
|
2476
|
+
fontStyle?: string;
|
|
2477
|
+
fill?: string;
|
|
2478
|
+
align?: "start" | "center" | "end";
|
|
2479
|
+
verticalAlign?: "top" | "middle" | "bottom";
|
|
2480
|
+
lineHeight?: number;
|
|
2481
|
+
letterSpacing?: number;
|
|
2482
|
+
background?: string;
|
|
2483
|
+
padding?: number;
|
|
2484
|
+
stroke?: string;
|
|
2485
|
+
strokeWidth?: number;
|
|
2486
|
+
textShadow?: string;
|
|
2487
|
+
shadows?: TextShadow[];
|
|
2488
|
+
maxWidth?: number;
|
|
2489
|
+
}
|
|
2490
|
+
interface ShapeNode extends CompositionNodeBase {
|
|
2491
|
+
kind: "shape";
|
|
2492
|
+
shapeType?: ShapeType;
|
|
2493
|
+
borderRadius?: number;
|
|
2494
|
+
radiusTL?: number;
|
|
2495
|
+
radiusTR?: number;
|
|
2496
|
+
radiusBR?: number;
|
|
2497
|
+
radiusBL?: number;
|
|
2498
|
+
polygonSides?: number;
|
|
2499
|
+
starPoints?: number;
|
|
2500
|
+
starInnerRadiusRatio?: number;
|
|
2501
|
+
arrowHeadWidth?: number;
|
|
2502
|
+
arrowHeadLength?: number;
|
|
2503
|
+
arrowShaftWidth?: number;
|
|
2504
|
+
d?: string;
|
|
2505
|
+
fillType?: "solid" | "linear" | "radial" | "none";
|
|
2506
|
+
fillColor?: string;
|
|
2507
|
+
gradientEndColor?: string;
|
|
2508
|
+
gradientAngle?: number;
|
|
2509
|
+
strokeColor?: string;
|
|
2510
|
+
strokeWidth?: number;
|
|
2511
|
+
strokeDashArray?: string;
|
|
2512
|
+
strokeDashOffset?: number;
|
|
2513
|
+
strokeLineCap?: "butt" | "round" | "square";
|
|
2514
|
+
strokeLineJoin?: "miter" | "round" | "bevel";
|
|
2515
|
+
strokeAlign?: "inside" | "center" | "outside";
|
|
2516
|
+
trimStart?: number;
|
|
2517
|
+
trimEnd?: number;
|
|
2518
|
+
trimOffset?: number;
|
|
2519
|
+
}
|
|
2520
|
+
declare const CameraLensSchema: z.ZodObject<{
|
|
2521
|
+
focalLength: z.ZodDefault<z.ZodNumber>;
|
|
2522
|
+
fov: z.ZodOptional<z.ZodNumber>;
|
|
2523
|
+
sensorWidth: z.ZodDefault<z.ZodNumber>;
|
|
2524
|
+
near: z.ZodDefault<z.ZodNumber>;
|
|
2525
|
+
far: z.ZodDefault<z.ZodNumber>;
|
|
2526
|
+
zoom: z.ZodDefault<z.ZodNumber>;
|
|
2527
|
+
}, z.core.$strict>;
|
|
2528
|
+
type CameraLens = z.infer<typeof CameraLensSchema>;
|
|
2529
|
+
declare const CameraDoFSchema: z.ZodObject<{
|
|
2530
|
+
enabled: z.ZodDefault<z.ZodBoolean>;
|
|
2531
|
+
focusDistance: z.ZodDefault<z.ZodNumber>;
|
|
2532
|
+
fStop: z.ZodDefault<z.ZodNumber>;
|
|
2533
|
+
maxBlurRadius: z.ZodDefault<z.ZodNumber>;
|
|
2534
|
+
apertureBlades: z.ZodDefault<z.ZodNumber>;
|
|
2535
|
+
anamorphicRatio: z.ZodDefault<z.ZodNumber>;
|
|
2536
|
+
}, z.core.$strict>;
|
|
2537
|
+
/** Depth of field as authored: fields with schema defaults may be left out. */
|
|
2538
|
+
type CameraDoF = z.input<typeof CameraDoFSchema>;
|
|
2539
|
+
declare const CameraShakeSchema: z.ZodObject<{
|
|
2540
|
+
translationAmplitude: z.ZodDefault<z.ZodNumber>;
|
|
2541
|
+
rotationAmplitude: z.ZodDefault<z.ZodNumber>;
|
|
2542
|
+
frequency: z.ZodDefault<z.ZodNumber>;
|
|
2543
|
+
octaves: z.ZodDefault<z.ZodNumber>;
|
|
2544
|
+
seed: z.ZodDefault<z.ZodNumber>;
|
|
2545
|
+
}, z.core.$strict>;
|
|
2546
|
+
type CameraShake = z.infer<typeof CameraShakeSchema>;
|
|
2547
|
+
interface CameraNode {
|
|
2548
|
+
id: string;
|
|
2549
|
+
kind: "camera";
|
|
2550
|
+
mode?: "lookAt" | "free" | "orbit";
|
|
2551
|
+
x?: number;
|
|
2552
|
+
y?: number;
|
|
2553
|
+
z?: number;
|
|
2554
|
+
targetX?: number;
|
|
2555
|
+
targetY?: number;
|
|
2556
|
+
targetZ?: number;
|
|
2557
|
+
pitch?: number;
|
|
2558
|
+
yaw?: number;
|
|
2559
|
+
roll?: number;
|
|
2560
|
+
lens?: CameraLens;
|
|
2561
|
+
dof?: CameraDoF;
|
|
2562
|
+
shake?: CameraShake;
|
|
2563
|
+
startFrame?: number;
|
|
2564
|
+
durationFrames?: number;
|
|
2565
|
+
animation?: LayerAnimationSpec;
|
|
2566
|
+
}
|
|
2567
|
+
declare const CameraNodeSchema: z.ZodType<CameraNode>;
|
|
2568
|
+
type LightType = "ambient" | "directional" | "point" | "spot";
|
|
2569
|
+
declare const LightTypeSchema: z.ZodEnum<{
|
|
2570
|
+
ambient: "ambient";
|
|
2571
|
+
directional: "directional";
|
|
2572
|
+
point: "point";
|
|
2573
|
+
spot: "spot";
|
|
2574
|
+
}>;
|
|
2575
|
+
interface LightNode {
|
|
2576
|
+
id: string;
|
|
2577
|
+
kind: "light";
|
|
2578
|
+
lightType?: LightType;
|
|
2579
|
+
color?: string;
|
|
2580
|
+
intensity?: number;
|
|
2581
|
+
x?: number;
|
|
2582
|
+
y?: number;
|
|
2583
|
+
z?: number;
|
|
2584
|
+
targetX?: number;
|
|
2585
|
+
targetY?: number;
|
|
2586
|
+
targetZ?: number;
|
|
2587
|
+
direction?: [number, number, number];
|
|
2588
|
+
radius?: number;
|
|
2589
|
+
decay?: number;
|
|
2590
|
+
angle?: number;
|
|
2591
|
+
penumbra?: number;
|
|
2592
|
+
startFrame?: number;
|
|
2593
|
+
durationFrames?: number;
|
|
2594
|
+
animation?: LayerAnimationSpec;
|
|
2595
|
+
}
|
|
2596
|
+
declare const LightNodeSchema: z.ZodType<LightNode>;
|
|
2597
|
+
interface Model3DNode {
|
|
2598
|
+
id: string;
|
|
2599
|
+
kind: "model3d";
|
|
2600
|
+
src?: string;
|
|
2601
|
+
modelFormat?: "obj" | "fbx" | "gltf" | "glb" | "stl" | "ply" | "vox" | "3ds" | "off" | "auto";
|
|
2602
|
+
modelData?: unknown;
|
|
2603
|
+
animationName?: string;
|
|
2604
|
+
animationProgress?: number;
|
|
2605
|
+
animationTime?: number;
|
|
2606
|
+
animationSpeed?: number;
|
|
2607
|
+
loop?: boolean;
|
|
2608
|
+
x?: number;
|
|
2609
|
+
y?: number;
|
|
2610
|
+
z?: number;
|
|
2611
|
+
rotateX?: number;
|
|
2612
|
+
rotateY?: number;
|
|
2613
|
+
rotateZ?: number;
|
|
2614
|
+
scale?: number;
|
|
2615
|
+
scaleX?: number;
|
|
2616
|
+
scaleY?: number;
|
|
2617
|
+
scaleZ?: number;
|
|
2618
|
+
material?: MaterialType;
|
|
2619
|
+
shininess?: number;
|
|
2620
|
+
roughness?: number;
|
|
2621
|
+
specularIntensity?: number;
|
|
2622
|
+
ambientIntensity?: number;
|
|
2623
|
+
metallic?: number;
|
|
2624
|
+
color?: string;
|
|
2625
|
+
colorTint?: string;
|
|
2626
|
+
opacity?: number;
|
|
2627
|
+
twoSided?: boolean;
|
|
2628
|
+
wireframe?: boolean;
|
|
2629
|
+
is3D?: boolean;
|
|
2630
|
+
texture?: string;
|
|
2631
|
+
center?: boolean;
|
|
2632
|
+
normalizeSize?: number;
|
|
2633
|
+
startFrame?: number;
|
|
2634
|
+
durationFrames?: number;
|
|
2635
|
+
animation?: LayerAnimationSpec;
|
|
2636
|
+
audioDeform?: MeshAudioDeformConfig;
|
|
2637
|
+
text3dOptions?: unknown;
|
|
2638
|
+
}
|
|
2639
|
+
type LayoutNode = FlexNode | BlockNode | BoxNode | TextNode | MediaNode | ShapeNode | CameraNode | LightNode | Model3DNode;
|
|
2640
|
+
declare const containerChildren: () => z.ZodType<LayoutNode[]>;
|
|
2641
|
+
declare const FlexNodeSchema: z.ZodType<FlexNode>;
|
|
2642
|
+
declare const BlockNodeSchema: z.ZodType<BlockNode>;
|
|
2643
|
+
declare const BoxNodeSchema: z.ZodType<BoxNode>;
|
|
2644
|
+
declare const TextSpanMarkSchema: z.ZodObject<{
|
|
2645
|
+
background: z.ZodOptional<z.ZodString>;
|
|
2646
|
+
borderRadius: z.ZodOptional<z.ZodNumber>;
|
|
2647
|
+
paddingX: z.ZodOptional<z.ZodNumber>;
|
|
2648
|
+
paddingY: z.ZodOptional<z.ZodNumber>;
|
|
2649
|
+
}, z.core.$strict>;
|
|
2650
|
+
declare const TextSpanSchema: z.ZodObject<{
|
|
2651
|
+
text: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<{
|
|
2652
|
+
get: (ctx?: unknown) => string;
|
|
2653
|
+
}, {
|
|
2654
|
+
get: (ctx?: unknown) => string;
|
|
2655
|
+
}>]>;
|
|
2656
|
+
fontFamily: z.ZodOptional<z.ZodString>;
|
|
2657
|
+
fontSize: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodCustom<{
|
|
2658
|
+
get: (ctx?: unknown) => number;
|
|
2659
|
+
}, {
|
|
2660
|
+
get: (ctx?: unknown) => number;
|
|
2661
|
+
}>]>>;
|
|
2662
|
+
fontWeight: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
|
|
2663
|
+
fontStyle: z.ZodOptional<z.ZodEnum<{
|
|
2664
|
+
normal: "normal";
|
|
2665
|
+
italic: "italic";
|
|
2666
|
+
}>>;
|
|
2667
|
+
fill: z.ZodOptional<z.ZodUnion<readonly [z.ZodOptional<z.ZodString>, z.ZodCustom<{
|
|
2668
|
+
get: (ctx?: unknown) => string;
|
|
2669
|
+
}, {
|
|
2670
|
+
get: (ctx?: unknown) => string;
|
|
2671
|
+
}>]>>;
|
|
2672
|
+
letterSpacing: z.ZodOptional<z.ZodNumber>;
|
|
2673
|
+
baselineShift: z.ZodOptional<z.ZodNumber>;
|
|
2674
|
+
opacity: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodCustom<{
|
|
2675
|
+
get: (ctx?: unknown) => number;
|
|
2676
|
+
}, {
|
|
2677
|
+
get: (ctx?: unknown) => number;
|
|
2678
|
+
}>]>>;
|
|
2679
|
+
mark: z.ZodOptional<z.ZodObject<{
|
|
2680
|
+
background: z.ZodOptional<z.ZodString>;
|
|
2681
|
+
borderRadius: z.ZodOptional<z.ZodNumber>;
|
|
2682
|
+
paddingX: z.ZodOptional<z.ZodNumber>;
|
|
2683
|
+
paddingY: z.ZodOptional<z.ZodNumber>;
|
|
2684
|
+
}, z.core.$strict>>;
|
|
2685
|
+
}, z.core.$strict>;
|
|
2686
|
+
declare const TextNodeSchema: z.ZodType<TextNode>;
|
|
2687
|
+
declare const MediaNodeSchema: z.ZodType<MediaNode>;
|
|
2688
|
+
declare const ShapeFields: {
|
|
2689
|
+
readonly shapeType: z.ZodDefault<z.ZodEnum<{
|
|
2690
|
+
path: "path";
|
|
2691
|
+
rect: "rect";
|
|
2692
|
+
circle: "circle";
|
|
2693
|
+
ellipse: "ellipse";
|
|
2694
|
+
polygon: "polygon";
|
|
2695
|
+
star: "star";
|
|
2696
|
+
arrow: "arrow";
|
|
2697
|
+
}>>;
|
|
2698
|
+
readonly borderRadius: z.ZodOptional<z.ZodNumber>;
|
|
2699
|
+
readonly radiusTL: z.ZodOptional<z.ZodNumber>;
|
|
2700
|
+
readonly radiusTR: z.ZodOptional<z.ZodNumber>;
|
|
2701
|
+
readonly radiusBR: z.ZodOptional<z.ZodNumber>;
|
|
2702
|
+
readonly radiusBL: z.ZodOptional<z.ZodNumber>;
|
|
2703
|
+
readonly polygonSides: z.ZodOptional<z.ZodNumber>;
|
|
2704
|
+
readonly starPoints: z.ZodOptional<z.ZodNumber>;
|
|
2705
|
+
readonly starInnerRadiusRatio: z.ZodOptional<z.ZodNumber>;
|
|
2706
|
+
readonly arrowHeadWidth: z.ZodOptional<z.ZodNumber>;
|
|
2707
|
+
readonly arrowHeadLength: z.ZodOptional<z.ZodNumber>;
|
|
2708
|
+
readonly arrowShaftWidth: z.ZodOptional<z.ZodNumber>;
|
|
2709
|
+
readonly d: z.ZodOptional<z.ZodString>;
|
|
2710
|
+
readonly fillType: z.ZodDefault<z.ZodEnum<{
|
|
2711
|
+
none: "none";
|
|
2712
|
+
solid: "solid";
|
|
2713
|
+
linear: "linear";
|
|
2714
|
+
radial: "radial";
|
|
2715
|
+
}>>;
|
|
2716
|
+
readonly fillColor: z.ZodDefault<z.ZodOptional<z.ZodString>>;
|
|
2717
|
+
readonly gradientEndColor: z.ZodOptional<z.ZodOptional<z.ZodString>>;
|
|
2718
|
+
readonly gradientAngle: z.ZodDefault<z.ZodNumber>;
|
|
2719
|
+
readonly strokeColor: z.ZodDefault<z.ZodOptional<z.ZodString>>;
|
|
2720
|
+
readonly strokeWidth: z.ZodDefault<z.ZodNumber>;
|
|
2721
|
+
readonly strokeDashArray: z.ZodOptional<z.ZodString>;
|
|
2722
|
+
readonly strokeDashOffset: z.ZodDefault<z.ZodNumber>;
|
|
2723
|
+
readonly strokeLineCap: z.ZodDefault<z.ZodEnum<{
|
|
2724
|
+
butt: "butt";
|
|
2725
|
+
round: "round";
|
|
2726
|
+
square: "square";
|
|
2727
|
+
}>>;
|
|
2728
|
+
readonly strokeLineJoin: z.ZodDefault<z.ZodEnum<{
|
|
2729
|
+
round: "round";
|
|
2730
|
+
miter: "miter";
|
|
2731
|
+
bevel: "bevel";
|
|
2732
|
+
}>>;
|
|
2733
|
+
readonly strokeAlign: z.ZodOptional<z.ZodEnum<{
|
|
2734
|
+
inside: "inside";
|
|
2735
|
+
center: "center";
|
|
2736
|
+
outside: "outside";
|
|
2737
|
+
}>>;
|
|
2738
|
+
readonly trimStart: z.ZodDefault<z.ZodNumber>;
|
|
2739
|
+
readonly trimEnd: z.ZodDefault<z.ZodNumber>;
|
|
2740
|
+
readonly trimOffset: z.ZodDefault<z.ZodNumber>;
|
|
2741
|
+
};
|
|
2742
|
+
declare const ShapeNodeSchema: z.ZodType<ShapeNode>;
|
|
2743
|
+
declare const ColorStopSchema: z.ZodObject<{
|
|
2744
|
+
offset: z.ZodNumber;
|
|
2745
|
+
color: z.ZodString;
|
|
2746
|
+
}, z.core.$strip>;
|
|
2747
|
+
type ColorStop = z.infer<typeof ColorStopSchema>;
|
|
2748
|
+
declare const Model3DNodeSchema: z.ZodType<Model3DNode>;
|
|
2749
|
+
declare const LayoutNodeSchema: z.ZodType<LayoutNode>;
|
|
2750
|
+
declare const CompositorProgramSchema: z.ZodObject<{
|
|
2751
|
+
width: z.ZodNumber;
|
|
2752
|
+
height: z.ZodNumber;
|
|
2753
|
+
backgroundColor: z.ZodOptional<z.ZodString>;
|
|
2754
|
+
volume: z.ZodDefault<z.ZodNumber>;
|
|
2755
|
+
fps: z.ZodDefault<z.ZodNumber>;
|
|
2756
|
+
mode: z.ZodDefault<z.ZodEnum<{
|
|
2757
|
+
Image: "Image";
|
|
2758
|
+
Video: "Video";
|
|
2759
|
+
}>>;
|
|
2760
|
+
antialias3d: z.ZodOptional<z.ZodBoolean>;
|
|
2761
|
+
layout: z.ZodDefault<z.ZodArray<z.ZodType<LayoutNode, unknown, z.core.$ZodTypeInternals<LayoutNode, unknown>>>>;
|
|
2762
|
+
fonts: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
2763
|
+
signals: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
2764
|
+
effects: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
|
|
2765
|
+
vision: z.ZodOptional<z.ZodUnknown>;
|
|
2766
|
+
onRequestFrame: z.ZodOptional<z.ZodCustom<unknown, unknown>>;
|
|
2767
|
+
}, z.core.$strict>;
|
|
2768
|
+
type CompositorProgramConfig = z.infer<typeof CompositorProgramSchema>;
|
|
2769
|
+
//#endregion
|
|
2770
|
+
//#region src/utils/layout/resolve-layout.d.ts
|
|
2771
|
+
interface Rect {
|
|
2772
|
+
x: number;
|
|
2773
|
+
y: number;
|
|
2774
|
+
width: number;
|
|
2775
|
+
height: number;
|
|
2776
|
+
}
|
|
2777
|
+
interface LayoutResult {
|
|
2778
|
+
/** Final rect per node id (post-layout, pre-affine-transform). */
|
|
2779
|
+
rects: Record<string, Rect>;
|
|
2780
|
+
/** Resolved outer size per node id. */
|
|
2781
|
+
sizes: Record<string, {
|
|
2782
|
+
width: number;
|
|
2783
|
+
height: number;
|
|
2784
|
+
}>;
|
|
2785
|
+
}
|
|
2786
|
+
/**
|
|
2787
|
+
* Intrinsic ("auto"/"fit") size for a leaf node. Return null when the node
|
|
2788
|
+
* has no measurable content. In the compositor this is backed by text
|
|
2789
|
+
* measurement / media metadata — the layout pass never measures itself.
|
|
2790
|
+
*/
|
|
2791
|
+
type MeasureFn = (node: LayoutNode, constraintWidth?: number) => {
|
|
2792
|
+
width: number;
|
|
2793
|
+
height: number;
|
|
2794
|
+
} | null;
|
|
2795
|
+
interface LayoutInput {
|
|
2796
|
+
/** Document roots — the only structural input. Size comes from `viewport`. */
|
|
2797
|
+
layout: LayoutNode[];
|
|
2798
|
+
viewport: {
|
|
2799
|
+
width: number;
|
|
2800
|
+
height: number;
|
|
2801
|
+
};
|
|
2802
|
+
measure?: MeasureFn;
|
|
2803
|
+
}
|
|
2804
|
+
/**
|
|
2805
|
+
* Ensure the Yoga WASM module is loaded. Safe to call multiple times —
|
|
2806
|
+
* subsequent calls return the cached instance immediately.
|
|
2807
|
+
*/
|
|
2808
|
+
declare function initLayout(): Promise<Yoga>;
|
|
2809
|
+
/** Deterministic layout (synchronous): document + viewport (+ measure) → rects. */
|
|
2810
|
+
declare function computeLayoutSync(yoga: Yoga, input: LayoutInput): LayoutResult;
|
|
2811
|
+
/** Deterministic layout: document + viewport (+ measure) → rects. */
|
|
2812
|
+
declare function computeLayout(input: LayoutInput): Promise<LayoutResult>;
|
|
2813
|
+
//#endregion
|
|
2814
|
+
//#region src/program/animation.d.ts
|
|
2815
|
+
/**
|
|
2816
|
+
* One keyframe as a tuple: `[frame, value]` or `[frame, value, ease]`. The
|
|
2817
|
+
* ease shapes the motion arriving at this keyframe from the one before.
|
|
2818
|
+
*/
|
|
2819
|
+
type KeyframeTuple = readonly [frame: number, value: number | string | boolean, ease?: string | EaseRef];
|
|
2820
|
+
interface FromToOptions {
|
|
2821
|
+
from?: number;
|
|
2822
|
+
to?: number;
|
|
2823
|
+
start?: number;
|
|
2824
|
+
end?: number;
|
|
2825
|
+
fromFrame?: number;
|
|
2826
|
+
toFrame?: number;
|
|
2827
|
+
durationFrames?: number;
|
|
2828
|
+
ease?: string | EaseRef;
|
|
2829
|
+
}
|
|
2830
|
+
interface Tilt3DOptions {
|
|
2831
|
+
from?: {
|
|
2832
|
+
rotateX?: number;
|
|
2833
|
+
rotateY?: number;
|
|
2834
|
+
rotateZ?: number;
|
|
2835
|
+
translateZ?: number;
|
|
2836
|
+
perspective?: number;
|
|
2837
|
+
};
|
|
2838
|
+
to: {
|
|
2839
|
+
rotateX?: number;
|
|
2840
|
+
rotateY?: number;
|
|
2841
|
+
rotateZ?: number;
|
|
2842
|
+
translateZ?: number;
|
|
2843
|
+
perspective?: number;
|
|
2844
|
+
};
|
|
2845
|
+
start?: number;
|
|
2846
|
+
end?: number;
|
|
2847
|
+
fromFrame?: number;
|
|
2848
|
+
toFrame?: number;
|
|
2849
|
+
ease?: string | EaseRef;
|
|
2850
|
+
}
|
|
2851
|
+
interface SignalTrackOptions {
|
|
2852
|
+
multiplier?: number;
|
|
2853
|
+
offset?: number;
|
|
2854
|
+
smoothing?: number;
|
|
2855
|
+
channel?: string;
|
|
2856
|
+
mode?: "continuous" | "accumulate";
|
|
2857
|
+
threshold?: number;
|
|
2858
|
+
debounceFrames?: number;
|
|
2859
|
+
}
|
|
2860
|
+
interface ColorSignalOptions {
|
|
2861
|
+
colorA: string;
|
|
2862
|
+
colorB: string;
|
|
2863
|
+
colorMode?: "interpolate" | "hueRotate" | "threshold";
|
|
2864
|
+
threshold?: number;
|
|
2865
|
+
smoothing?: number;
|
|
2866
|
+
}
|
|
2867
|
+
interface WiggleOptions {
|
|
2868
|
+
frequency?: number;
|
|
2869
|
+
amplitude?: number;
|
|
2870
|
+
octaves?: number;
|
|
2871
|
+
seed?: number;
|
|
2872
|
+
}
|
|
2873
|
+
interface SpringOptions {
|
|
2874
|
+
damping?: number;
|
|
2875
|
+
stiffness?: number;
|
|
2876
|
+
mass?: number;
|
|
2877
|
+
}
|
|
2878
|
+
interface PathLike3D {
|
|
2879
|
+
getPointAt(u: number): {
|
|
2880
|
+
position: [number, number, number];
|
|
2881
|
+
tangent?: [number, number, number];
|
|
2882
|
+
};
|
|
2883
|
+
getFrameAt?(u: number): {
|
|
2884
|
+
position: [number, number, number];
|
|
2885
|
+
tangent: [number, number, number];
|
|
2886
|
+
normal?: [number, number, number];
|
|
2887
|
+
binormal?: [number, number, number];
|
|
2888
|
+
rotation?: [number, number, number];
|
|
2889
|
+
};
|
|
2890
|
+
totalLength?: number;
|
|
2891
|
+
}
|
|
2892
|
+
interface FollowPathOptions {
|
|
2893
|
+
fromDistance?: number;
|
|
2894
|
+
toDistance?: number;
|
|
2895
|
+
fromProgress?: number;
|
|
2896
|
+
toProgress?: number;
|
|
2897
|
+
start?: number;
|
|
2898
|
+
end?: number;
|
|
2899
|
+
fromFrame?: number;
|
|
2900
|
+
toFrame?: number;
|
|
2901
|
+
autoOrient?: boolean;
|
|
2902
|
+
banking?: number;
|
|
2903
|
+
pitchOffset?: number;
|
|
2904
|
+
yawOffset?: number;
|
|
2905
|
+
rollOffset?: number;
|
|
2906
|
+
samples?: number;
|
|
2907
|
+
ease?: string | EaseRef;
|
|
2908
|
+
}
|
|
2909
|
+
interface CameraFollowPathOptions {
|
|
2910
|
+
fromProgress?: number;
|
|
2911
|
+
toProgress?: number;
|
|
2912
|
+
start?: number;
|
|
2913
|
+
end?: number;
|
|
2914
|
+
fromFrame?: number;
|
|
2915
|
+
toFrame?: number;
|
|
2916
|
+
mode?: "orientAlongPath" | "lookAtTarget" | "leadTarget";
|
|
2917
|
+
target?: [number, number, number];
|
|
2918
|
+
lookAhead?: number;
|
|
2919
|
+
samples?: number;
|
|
2920
|
+
ease?: string | EaseRef;
|
|
2921
|
+
}
|
|
2922
|
+
/**
|
|
2923
|
+
* Fluent builder and runtime representation for layer animations.
|
|
2924
|
+
* Supports chainable keyframes, reactive signal binding, Perlin wiggles, and springs.
|
|
2925
|
+
*/
|
|
2926
|
+
declare class LayerAnimation implements LayerAnimationSpec {
|
|
2927
|
+
tracks: AnimationTrack[];
|
|
2928
|
+
constructor(tracks?: AnimationTrack[]);
|
|
2929
|
+
static create(): LayerAnimation;
|
|
2930
|
+
static fromTo(prop: AnimatableProp, fromValue: number | string | boolean, toValue: number | string | boolean, options?: FromToOptions): LayerAnimation;
|
|
2931
|
+
/** A track from a list of `[frame, value, ease?]` keyframes; see {@link LayerAnimation.keys}. */
|
|
2932
|
+
static keys(prop: AnimatableProp, keyframes: readonly KeyframeTuple[]): LayerAnimation;
|
|
2933
|
+
static signal(prop: AnimatableProp, signalOrHandleId: unknown, options?: SignalTrackOptions): LayerAnimation;
|
|
2934
|
+
static colorSignal(prop: AnimatableProp, signalOrHandleId: unknown, options: ColorSignalOptions): LayerAnimation;
|
|
2935
|
+
static kineticSweep(fromOffset?: number, toOffset?: number, startFrame?: number, endFrame?: number, ease?: string | EaseRef): LayerAnimation;
|
|
2936
|
+
static typewriter(startFrame?: number, endFrame?: number, ease?: string | EaseRef): LayerAnimation;
|
|
2937
|
+
static letterSpacing(fromSpacing: number, toSpacing: number, startFrame?: number, endFrame?: number, ease?: string | EaseRef): LayerAnimation;
|
|
2938
|
+
static wiggle(prop: AnimatableProp, options?: WiggleOptions): LayerAnimation;
|
|
2939
|
+
static spring(prop: AnimatableProp, options?: SpringOptions): LayerAnimation;
|
|
2940
|
+
static firstMargin(fromMargin: number, toMargin: number, options?: FromToOptions): LayerAnimation;
|
|
2941
|
+
static strokeWidth(fromWidth: number, toWidth: number, options?: FromToOptions): LayerAnimation;
|
|
2942
|
+
static rotateX(fromAngle: number, toAngle: number, options?: FromToOptions): LayerAnimation;
|
|
2943
|
+
static rotateY(fromAngle: number, toAngle: number, options?: FromToOptions): LayerAnimation;
|
|
2944
|
+
static rotateZ(fromAngle: number, toAngle: number, options?: FromToOptions): LayerAnimation;
|
|
2945
|
+
static rotation(fromAngle: number, toAngle: number, options?: FromToOptions): LayerAnimation;
|
|
2946
|
+
addTrack(track: AnimationTrack): this;
|
|
2947
|
+
/**
|
|
2948
|
+
* Creates a keyframed track animating from fromValue to toValue.
|
|
2949
|
+
*/
|
|
2950
|
+
fromTo(prop: AnimatableProp, fromValue: number | string | boolean, toValue: number | string | boolean, options?: FromToOptions): this;
|
|
2951
|
+
/**
|
|
2952
|
+
* Appends a keyframe to an existing track for prop, or creates a new track.
|
|
2953
|
+
*/
|
|
2954
|
+
keyframe(prop: AnimatableProp, frame: number, value: number | string | boolean, ease?: string | EaseRef): this;
|
|
2955
|
+
/**
|
|
2956
|
+
* Adds several keyframes to prop's track at once:
|
|
2957
|
+
* `.keys("scale", [[0, 0], [12, 1.1, "back.out"], [20, 1]])`.
|
|
2958
|
+
* Frames are rounded to whole frames, so beat math can be passed straight in.
|
|
2959
|
+
*/
|
|
2960
|
+
keys(prop: AnimatableProp, keyframes: readonly KeyframeTuple[]): this;
|
|
2961
|
+
/**
|
|
2962
|
+
* Animates opacity from 0 to 1 between startFrame and endFrame.
|
|
2963
|
+
*/
|
|
2964
|
+
fadeIn(startFrame?: number, endFrame?: number, ease?: string | EaseRef): this;
|
|
2965
|
+
/**
|
|
2966
|
+
* Animates opacity from 1 to 0 between startFrame and endFrame.
|
|
2967
|
+
*/
|
|
2968
|
+
fadeOut(startFrame: number, endFrame: number, ease?: string | EaseRef): this;
|
|
2969
|
+
/**
|
|
2970
|
+
* Slides in Y coordinate from fromY to toY.
|
|
2971
|
+
*/
|
|
2972
|
+
slideInY(fromY: number, toY: number, startFrame?: number, endFrame?: number, ease?: string | EaseRef): this;
|
|
2973
|
+
/**
|
|
2974
|
+
* Slides in X coordinate from fromX to toX.
|
|
2975
|
+
*/
|
|
2976
|
+
slideInX(fromX: number, toX: number, startFrame?: number, endFrame?: number, ease?: string | EaseRef): this;
|
|
2977
|
+
/**
|
|
2978
|
+
* Sweeps kinetic typography animator offset from fromOffset to toOffset.
|
|
2979
|
+
* Cascades per-glyph or per-word transforms across the text.
|
|
2980
|
+
*/
|
|
2981
|
+
kineticSweep(fromOffset?: number, toOffset?: number, startFrame?: number, endFrame?: number, ease?: string | EaseRef): this;
|
|
2982
|
+
/**
|
|
2983
|
+
* Progressive character write-on / typewriter text reveal.
|
|
2984
|
+
*/
|
|
2985
|
+
typewriter(startFrame?: number, endFrame?: number, ease?: string | EaseRef): this;
|
|
2986
|
+
/**
|
|
2987
|
+
* Animates letter-spacing (tracking expansion or compression).
|
|
2988
|
+
*/
|
|
2989
|
+
letterSpacing(fromSpacing: number, toSpacing: number, startFrame?: number, endFrame?: number, ease?: string | EaseRef): this;
|
|
2990
|
+
/**
|
|
2991
|
+
* Animates text position along a path via First Margin.
|
|
2992
|
+
*/
|
|
2993
|
+
firstMargin(fromMargin: number, toMargin: number, options?: FromToOptions): this;
|
|
2994
|
+
/**
|
|
2995
|
+
* Animates Last Margin spatial limit along a path.
|
|
2996
|
+
*/
|
|
2997
|
+
lastMargin(fromMargin: number, toMargin: number, options?: FromToOptions): this;
|
|
2998
|
+
/**
|
|
2999
|
+
* Animates baseline shift perpendicular to curve tangent.
|
|
3000
|
+
*/
|
|
3001
|
+
baselineShift(fromShift: number, toShift: number, options?: FromToOptions): this;
|
|
3002
|
+
/**
|
|
3003
|
+
* Animate rotateX from fromAngle to toAngle.
|
|
3004
|
+
*/
|
|
3005
|
+
rotateX(fromAngle: number, toAngle: number, options?: FromToOptions): this;
|
|
3006
|
+
/**
|
|
3007
|
+
* Animate rotateY from fromAngle to toAngle.
|
|
3008
|
+
*/
|
|
3009
|
+
rotateY(fromAngle: number, toAngle: number, options?: FromToOptions): this;
|
|
3010
|
+
/**
|
|
3011
|
+
* Animate rotateZ from fromAngle to toAngle.
|
|
3012
|
+
*/
|
|
3013
|
+
rotateZ(fromAngle: number, toAngle: number, options?: FromToOptions): this;
|
|
3014
|
+
/**
|
|
3015
|
+
* Animate perspective camera distance in pixels.
|
|
3016
|
+
*/
|
|
3017
|
+
perspective(fromDist: number, toDist: number, options?: FromToOptions): this;
|
|
3018
|
+
/**
|
|
3019
|
+
* Animate depth translation (translateZ) in pixels.
|
|
3020
|
+
*/
|
|
3021
|
+
translateZ(fromZ: number, toZ: number, options?: FromToOptions): this;
|
|
3022
|
+
/**
|
|
3023
|
+
* Composite helper to tilt a container across multiple 3D axes simultaneously.
|
|
3024
|
+
*/
|
|
3025
|
+
tilt3D(options: Tilt3DOptions): this;
|
|
3026
|
+
/**
|
|
3027
|
+
* Binds an animatable property to a reactive continuous Signal (e.g. LFO, speech energy, audio pitch).
|
|
3028
|
+
*
|
|
3029
|
+
* `signalOrHandleId` is either a signal object (`Signal.fromArray`,
|
|
3030
|
+
* `Signal.builder`, an audio channel …) — carried on the track and
|
|
3031
|
+
* registered with the program automatically — or the name of a signal
|
|
3032
|
+
* registered with `comp.addSignal(name, signal)`.
|
|
3033
|
+
*/
|
|
3034
|
+
signal(prop: AnimatableProp, signalOrHandleId: unknown, options?: SignalTrackOptions): this;
|
|
3035
|
+
/**
|
|
3036
|
+
* Modulates color interpolation based on an active signal (object or
|
|
3037
|
+
* registered name, as in {@link LayerAnimation.signal}).
|
|
3038
|
+
*/
|
|
3039
|
+
colorSignal(prop: AnimatableProp, signalOrHandleId: unknown, options: ColorSignalOptions): this;
|
|
3040
|
+
/**
|
|
3041
|
+
* Adds organic Perlin noise wiggling to a property.
|
|
3042
|
+
*/
|
|
3043
|
+
wiggle(prop: AnimatableProp, options?: WiggleOptions): this;
|
|
3044
|
+
/**
|
|
3045
|
+
* Adds physical harmonic spring overshoot behavior to a property transition.
|
|
3046
|
+
*/
|
|
3047
|
+
spring(prop: AnimatableProp, options?: SpringOptions): this;
|
|
3048
|
+
/**
|
|
3049
|
+
* Follows a 2D or 3D path with constant arc-length velocity, automatic orientation,
|
|
3050
|
+
* banking into turns, and optional easing.
|
|
3051
|
+
*/
|
|
3052
|
+
followPath(path: PathLike3D, options?: FollowPathOptions): this;
|
|
3053
|
+
/**
|
|
3054
|
+
* Attaches this animation to a target LayoutNode and returns the node.
|
|
3055
|
+
*/
|
|
3056
|
+
applyTo<T extends {
|
|
3057
|
+
animation?: LayerAnimationSpec;
|
|
3058
|
+
}>(node: T): T;
|
|
3059
|
+
/**
|
|
3060
|
+
* Returns the validated LayerAnimation specification object.
|
|
3061
|
+
*/
|
|
3062
|
+
toSpec(): LayerAnimationSpec;
|
|
3063
|
+
toJSON(): LayerAnimationSpec;
|
|
3064
|
+
}
|
|
3065
|
+
interface DollyOptions {
|
|
3066
|
+
fromDistance: number;
|
|
3067
|
+
toDistance: number;
|
|
3068
|
+
start?: number;
|
|
3069
|
+
end?: number;
|
|
3070
|
+
fromFrame?: number;
|
|
3071
|
+
toFrame?: number;
|
|
3072
|
+
ease?: string;
|
|
3073
|
+
}
|
|
3074
|
+
interface OrbitOptions {
|
|
3075
|
+
radius?: {
|
|
3076
|
+
from?: number;
|
|
3077
|
+
to: number;
|
|
3078
|
+
};
|
|
3079
|
+
azimuth?: {
|
|
3080
|
+
from?: number;
|
|
3081
|
+
to: number;
|
|
3082
|
+
};
|
|
3083
|
+
elevation?: {
|
|
3084
|
+
from?: number;
|
|
3085
|
+
to: number;
|
|
3086
|
+
};
|
|
3087
|
+
start?: number;
|
|
3088
|
+
end?: number;
|
|
3089
|
+
fromFrame?: number;
|
|
3090
|
+
toFrame?: number;
|
|
3091
|
+
ease?: string;
|
|
3092
|
+
}
|
|
3093
|
+
interface RackFocusOptions {
|
|
3094
|
+
fromDistance: number;
|
|
3095
|
+
toDistance: number;
|
|
3096
|
+
fromFStop?: number;
|
|
3097
|
+
toFStop?: number;
|
|
3098
|
+
start?: number;
|
|
3099
|
+
end?: number;
|
|
3100
|
+
fromFrame?: number;
|
|
3101
|
+
toFrame?: number;
|
|
3102
|
+
ease?: string;
|
|
3103
|
+
}
|
|
3104
|
+
interface HandheldOptions {
|
|
3105
|
+
translationAmplitude: number;
|
|
3106
|
+
rotationAmplitude: number;
|
|
3107
|
+
start?: number;
|
|
3108
|
+
end?: number;
|
|
3109
|
+
fromFrame?: number;
|
|
3110
|
+
toFrame?: number;
|
|
3111
|
+
}
|
|
3112
|
+
declare class CameraAnimation extends LayerAnimation {
|
|
3113
|
+
static camera(): CameraAnimation;
|
|
3114
|
+
dolly(fromDistanceOrOptions: number | DollyOptions, toDistance?: number, options?: FromToOptions): this;
|
|
3115
|
+
orbit(options: OrbitOptions): this;
|
|
3116
|
+
truck(fromX: number, toX: number, options?: FromToOptions): this;
|
|
3117
|
+
pedestal(fromY: number, toY: number, options?: FromToOptions): this;
|
|
3118
|
+
pan(fromAngleDeg: number, toAngleDeg: number, options?: FromToOptions): this;
|
|
3119
|
+
tilt(fromAngleDeg: number, toAngleDeg: number, options?: FromToOptions): this;
|
|
3120
|
+
roll(fromAngleDeg: number, toAngleDeg: number, options?: FromToOptions): this;
|
|
3121
|
+
rackFocus(options: RackFocusOptions): this;
|
|
3122
|
+
handheld(options: HandheldOptions): this;
|
|
3123
|
+
/**
|
|
3124
|
+
* Animates camera eye and lookAt target along a 3D path with constant velocity,
|
|
3125
|
+
* leading target look-ahead, or path tangent orientation.
|
|
3126
|
+
*/
|
|
3127
|
+
followPath3D(path: PathLike3D, options?: CameraFollowPathOptions): this;
|
|
3128
|
+
}
|
|
3129
|
+
//#endregion
|
|
3130
|
+
//#region src/program/evaluator.d.ts
|
|
3131
|
+
type SignalDataSource = unknown;
|
|
3132
|
+
interface TrackEvaluationContext {
|
|
3133
|
+
/** Root frame (timeline frame). */
|
|
3134
|
+
rootFrame?: number;
|
|
3135
|
+
/** Layer start frame offset. */
|
|
3136
|
+
startFrame?: number;
|
|
3137
|
+
/** Base layer property fallback values. */
|
|
3138
|
+
baseValues?: Record<string, unknown>;
|
|
3139
|
+
/** Connected signal providers indexed by inputHandleId. */
|
|
3140
|
+
signals?: Record<string, SignalDataSource>;
|
|
3141
|
+
}
|
|
3142
|
+
/**
|
|
3143
|
+
* Procedural wiggle generator using multi-octave coherent 1D gradient noise.
|
|
3144
|
+
*/
|
|
3145
|
+
declare function evaluateWiggle(source: {
|
|
3146
|
+
frequency?: number;
|
|
3147
|
+
amplitude?: number;
|
|
3148
|
+
octaves?: number;
|
|
3149
|
+
seed?: number;
|
|
3150
|
+
}, tSec: number, baseValue?: number): number;
|
|
3151
|
+
/**
|
|
3152
|
+
* Analytical solution to the second-order damped harmonic oscillator ODE:
|
|
3153
|
+
* m*x'' + c*x' + k*x = 0
|
|
3154
|
+
*/
|
|
3155
|
+
declare function evaluateSpringOvershoot(source: {
|
|
3156
|
+
damping?: number;
|
|
3157
|
+
stiffness?: number;
|
|
3158
|
+
mass?: number;
|
|
3159
|
+
}, tSec: number, v0: number, v1: number): number;
|
|
3160
|
+
/**
|
|
3161
|
+
* Evaluates an external Signal as an event accumulator / integrator.
|
|
3162
|
+
* On each rising edge above `threshold` (with `debounceFrames` guard),
|
|
3163
|
+
* the accumulator increments by 1.
|
|
3164
|
+
*/
|
|
3165
|
+
declare function evaluateSignalAccumulator(rawSource: unknown, currentFrame: number, fps: number, threshold?: number, debounceFrames?: number): number;
|
|
3166
|
+
/**
|
|
3167
|
+
* Evaluates an external Signal with smoothing window and linear remapping,
|
|
3168
|
+
* or as a discrete event accumulator.
|
|
3169
|
+
*/
|
|
3170
|
+
declare function evaluateSignal(source: {
|
|
3171
|
+
inputHandleId: string;
|
|
3172
|
+
multiplier?: number;
|
|
3173
|
+
offset?: number;
|
|
3174
|
+
smoothingWindowFrames?: number;
|
|
3175
|
+
signalMode?: "continuous" | "accumulate";
|
|
3176
|
+
threshold?: number;
|
|
3177
|
+
accumulateThreshold?: number;
|
|
3178
|
+
debounceFrames?: number;
|
|
3179
|
+
channel?: string;
|
|
3180
|
+
}, frame: number, fps: number, signals?: Record<string, SignalDataSource>): number;
|
|
3181
|
+
declare function rotateHue(hex: string, delta: number): string;
|
|
3182
|
+
/**
|
|
3183
|
+
* Standard keyframe track evaluation.
|
|
3184
|
+
*/
|
|
3185
|
+
declare function evaluateKeyframes(track: AnimationTrack, localFrame: number): number | boolean | string;
|
|
3186
|
+
/**
|
|
3187
|
+
* Evaluates an AnimationTrack at a given global or local frame.
|
|
3188
|
+
*/
|
|
3189
|
+
declare function evaluateTrackAtFrame(track: AnimationTrack, frame: number, fps?: number, context?: TrackEvaluationContext): number | boolean | string;
|
|
3190
|
+
/**
|
|
3191
|
+
* Evaluates all animation tracks for a layer at `frame`.
|
|
3192
|
+
*/
|
|
3193
|
+
declare function evaluateAnimationAtFrame(animation: LayerAnimationSpec | undefined, frame: number, fps?: number, context?: TrackEvaluationContext): Record<string, number | boolean | string>;
|
|
3194
|
+
//#endregion
|
|
3195
|
+
//#region src/program/sequence.d.ts
|
|
3196
|
+
/**
|
|
3197
|
+
* Camera Transition Type across scene boundaries.
|
|
3198
|
+
*/
|
|
3199
|
+
declare const SceneTransitionTypeSchema: z.ZodEnum<{
|
|
3200
|
+
cut: "cut";
|
|
3201
|
+
carrierMatchCut: "carrierMatchCut";
|
|
3202
|
+
cameraWhip: "cameraWhip";
|
|
3203
|
+
focusPullDissolve: "focusPullDissolve";
|
|
3204
|
+
irisAperture: "irisAperture";
|
|
3205
|
+
pushDirectional: "pushDirectional";
|
|
3206
|
+
}>;
|
|
3207
|
+
type SceneTransitionType = z.infer<typeof SceneTransitionTypeSchema>;
|
|
3208
|
+
/**
|
|
3209
|
+
* Carrier Object Handoff Configuration Schema.
|
|
3210
|
+
*/
|
|
3211
|
+
declare const CarrierHandoffConfigSchema: z.ZodObject<{
|
|
3212
|
+
sourceLayerId: z.ZodString;
|
|
3213
|
+
targetLayerId: z.ZodString;
|
|
3214
|
+
mode: z.ZodDefault<z.ZodEnum<{
|
|
3215
|
+
exact: "exact";
|
|
3216
|
+
preserveVelocity: "preserveVelocity";
|
|
3217
|
+
morph: "morph";
|
|
3218
|
+
}>>;
|
|
3219
|
+
blendFrames: z.ZodDefault<z.ZodNumber>;
|
|
3220
|
+
}, z.core.$strict>;
|
|
3221
|
+
type CarrierHandoffConfig = z.infer<typeof CarrierHandoffConfigSchema>;
|
|
3222
|
+
/**
|
|
3223
|
+
* Individual Scene Definition Schema.
|
|
3224
|
+
*/
|
|
3225
|
+
declare const SceneDefinitionSchema: z.ZodObject<{
|
|
3226
|
+
id: z.ZodString;
|
|
3227
|
+
chapter: z.ZodDefault<z.ZodEnum<{
|
|
3228
|
+
custom: "custom";
|
|
3229
|
+
hook: "hook";
|
|
3230
|
+
tension: "tension";
|
|
3231
|
+
solution: "solution";
|
|
3232
|
+
feature_spotlight: "feature_spotlight";
|
|
3233
|
+
outro: "outro";
|
|
3234
|
+
}>>;
|
|
3235
|
+
durationMs: z.ZodOptional<z.ZodNumber>;
|
|
3236
|
+
durationFrames: z.ZodOptional<z.ZodNumber>;
|
|
3237
|
+
transitionOut: z.ZodDefault<z.ZodObject<{
|
|
3238
|
+
type: z.ZodDefault<z.ZodEnum<{
|
|
3239
|
+
cut: "cut";
|
|
3240
|
+
carrierMatchCut: "carrierMatchCut";
|
|
3241
|
+
cameraWhip: "cameraWhip";
|
|
3242
|
+
focusPullDissolve: "focusPullDissolve";
|
|
3243
|
+
irisAperture: "irisAperture";
|
|
3244
|
+
pushDirectional: "pushDirectional";
|
|
3245
|
+
}>>;
|
|
3246
|
+
durationFrames: z.ZodDefault<z.ZodNumber>;
|
|
3247
|
+
carrier: z.ZodOptional<z.ZodObject<{
|
|
3248
|
+
sourceLayerId: z.ZodString;
|
|
3249
|
+
targetLayerId: z.ZodString;
|
|
3250
|
+
mode: z.ZodDefault<z.ZodEnum<{
|
|
3251
|
+
exact: "exact";
|
|
3252
|
+
preserveVelocity: "preserveVelocity";
|
|
3253
|
+
morph: "morph";
|
|
3254
|
+
}>>;
|
|
3255
|
+
blendFrames: z.ZodDefault<z.ZodNumber>;
|
|
3256
|
+
}, z.core.$strict>>;
|
|
3257
|
+
whipDirection: z.ZodDefault<z.ZodEnum<{
|
|
3258
|
+
left: "left";
|
|
3259
|
+
right: "right";
|
|
3260
|
+
up: "up";
|
|
3261
|
+
down: "down";
|
|
3262
|
+
}>>;
|
|
3263
|
+
}, z.core.$strip>>;
|
|
3264
|
+
}, z.core.$loose>;
|
|
3265
|
+
type SceneDefinition = z.infer<typeof SceneDefinitionSchema>;
|
|
3266
|
+
interface CarrierState {
|
|
3267
|
+
x: number;
|
|
3268
|
+
y: number;
|
|
3269
|
+
scale: number;
|
|
3270
|
+
vx: number;
|
|
3271
|
+
vy: number;
|
|
3272
|
+
}
|
|
3273
|
+
declare function computeCarrierContinuity(stateAtCut: CarrierState, targetInitialState: Partial<CarrierState>): CarrierState;
|
|
3274
|
+
interface SequenceTimelineResult {
|
|
3275
|
+
totalFrames: number;
|
|
3276
|
+
totalDurationMs: number;
|
|
3277
|
+
sceneOffsets: Array<{
|
|
3278
|
+
sceneId: string;
|
|
3279
|
+
startFrame: number;
|
|
3280
|
+
durationFrames: number;
|
|
3281
|
+
}>;
|
|
3282
|
+
}
|
|
3283
|
+
/**
|
|
3284
|
+
* Calculates global scene offsets and handoff frames across a sequence.
|
|
3285
|
+
*/
|
|
3286
|
+
declare function calculateSequenceTimeline(scenes: Array<{
|
|
3287
|
+
id: string;
|
|
3288
|
+
durationFrames?: number;
|
|
3289
|
+
durationMs?: number;
|
|
3290
|
+
transitionOverlap?: number;
|
|
3291
|
+
transitionOut?: {
|
|
3292
|
+
durationFrames?: number;
|
|
3293
|
+
};
|
|
3294
|
+
}>, fps?: number): SequenceTimelineResult;
|
|
3295
|
+
interface SceneOptions {
|
|
3296
|
+
id: string;
|
|
3297
|
+
chapter?: "hook" | "tension" | "solution" | "feature_spotlight" | "outro" | "custom";
|
|
3298
|
+
durationMs?: number;
|
|
3299
|
+
durationFrames?: number;
|
|
3300
|
+
transitionOut?: {
|
|
3301
|
+
type?: SceneTransitionType;
|
|
3302
|
+
durationFrames?: number;
|
|
3303
|
+
carrier?: CarrierHandoffConfig;
|
|
3304
|
+
whipDirection?: "left" | "right" | "up" | "down";
|
|
3305
|
+
};
|
|
3306
|
+
layout?: LayoutNode[];
|
|
3307
|
+
}
|
|
3308
|
+
declare class Scene {
|
|
3309
|
+
id: string;
|
|
3310
|
+
chapter: "hook" | "tension" | "solution" | "feature_spotlight" | "outro" | "custom";
|
|
3311
|
+
durationMs?: number;
|
|
3312
|
+
durationFrames?: number;
|
|
3313
|
+
transitionOut: {
|
|
3314
|
+
type: SceneTransitionType;
|
|
3315
|
+
durationFrames: number;
|
|
3316
|
+
carrier?: CarrierHandoffConfig;
|
|
3317
|
+
whipDirection: "left" | "right" | "up" | "down";
|
|
3318
|
+
};
|
|
3319
|
+
layout: LayoutNode[];
|
|
3320
|
+
constructor(options: SceneOptions);
|
|
3321
|
+
static create(options: SceneOptions): Scene;
|
|
3322
|
+
}
|
|
3323
|
+
interface SequenceOptions {
|
|
3324
|
+
fps?: number;
|
|
3325
|
+
width?: number;
|
|
3326
|
+
height?: number;
|
|
3327
|
+
backgroundColor?: string;
|
|
3328
|
+
fonts?: string[];
|
|
3329
|
+
signals?: Record<string, unknown>;
|
|
3330
|
+
scenes?: Scene[];
|
|
3331
|
+
}
|
|
3332
|
+
declare class Sequence {
|
|
3333
|
+
fps: number;
|
|
3334
|
+
width: number;
|
|
3335
|
+
height: number;
|
|
3336
|
+
backgroundColor: string;
|
|
3337
|
+
fonts?: string[];
|
|
3338
|
+
signals?: Record<string, unknown>;
|
|
3339
|
+
private scenes;
|
|
3340
|
+
constructor(options?: SequenceOptions);
|
|
3341
|
+
static create(options?: SequenceOptions): Sequence;
|
|
3342
|
+
addScene(scene: Scene | SceneOptions): this;
|
|
3343
|
+
getScenes(): readonly Scene[];
|
|
3344
|
+
calculateTimeline(): SequenceTimelineResult;
|
|
3345
|
+
toProgram(): CompositorProgramConfig;
|
|
3346
|
+
}
|
|
3347
|
+
//#endregion
|
|
3348
|
+
//#region src/program/stagger.d.ts
|
|
3349
|
+
type StaggerDirection = "forward" | "reverse" | "center-out";
|
|
3350
|
+
/**
|
|
3351
|
+
* Calculates the frame delay offset for a child at `index` in a container of `totalCount` items.
|
|
3352
|
+
*/
|
|
3353
|
+
declare function computeStaggerDelay(index: number, totalCount: number, staggerFrames: number, direction?: StaggerDirection): number;
|
|
3354
|
+
/**
|
|
3355
|
+
* Applies stagger timing offsets to child nodes, returning cloned objects with adjusted `startFrame`.
|
|
3356
|
+
*/
|
|
3357
|
+
declare function applyStaggerToChildren<T extends {
|
|
3358
|
+
startFrame?: number;
|
|
3359
|
+
}>(children: T[], staggerFrames: number, direction?: StaggerDirection, baseOffset?: number): T[];
|
|
3360
|
+
//#endregion
|
|
3361
|
+
//#region src/program/to-virtual-media.d.ts
|
|
3362
|
+
interface CompositorToProgramOptions {
|
|
3363
|
+
isVideoMode: boolean;
|
|
3364
|
+
fps: number;
|
|
3365
|
+
/** Comp duration in ms (metadata only; derived upstream). */
|
|
3366
|
+
durationMs?: number;
|
|
3367
|
+
/** Bind a media node's `inputHandleId` to its graph source item. */
|
|
3368
|
+
resolveMedia?: (inputHandleId: string) => VirtualMediaData | undefined;
|
|
3369
|
+
/** External signals mapped by inputHandleId. */
|
|
3370
|
+
signals?: Record<string, any>;
|
|
3371
|
+
}
|
|
3372
|
+
declare function compositorToProgram(config: CompositorProgramConfig, options: CompositorToProgramOptions): VirtualMediaData;
|
|
3373
|
+
/** Recursively gather every node op from a render tree (in order). */
|
|
3374
|
+
declare function collectNodeOps(nodes: VirtualMediaData[]): VirtualMediaData[];
|
|
3375
|
+
//#endregion
|
|
3376
|
+
//#region src/program/validate.d.ts
|
|
3377
|
+
interface ProgramIssue {
|
|
3378
|
+
code: string;
|
|
3379
|
+
path: (string | number)[];
|
|
3380
|
+
message: string;
|
|
3381
|
+
}
|
|
3382
|
+
type ProgramValidationResult = {
|
|
3383
|
+
ok: true;
|
|
3384
|
+
} | {
|
|
3385
|
+
ok: false;
|
|
3386
|
+
issues: ProgramIssue[];
|
|
3387
|
+
};
|
|
3388
|
+
declare function validateLayoutProgram(raw: unknown): ProgramValidationResult;
|
|
3389
|
+
/** Fast-fail shape gate used by processors: validate raw config then parse. */
|
|
3390
|
+
declare function parseProgram(raw: unknown): {
|
|
3391
|
+
ok: boolean;
|
|
3392
|
+
issues?: ProgramIssue[];
|
|
3393
|
+
config?: CompositorProgramConfig;
|
|
3394
|
+
};
|
|
3395
|
+
/** Collect every node id in the tree (depth-first, in order). */
|
|
3396
|
+
declare function collectNodeIds(nodes: LayoutNode[]): string[];
|
|
3397
|
+
/** Collect media node bindings: inputHandleId -> node id. */
|
|
3398
|
+
declare function collectMediaBindings(nodes: LayoutNode[]): Map<string, string>;
|
|
3399
|
+
//#endregion
|
|
3400
|
+
export { AETextAnimator, AETextAnimatorSchema, AdvancedTextAnimator, AdvancedTextAnimatorBuilder, AdvancedTextAnimatorSchema, AnchorGrouping, AnchorGroupingSchema, AnchorPreset, AnchorPresetSchema, AnimatableGlyphProps, AnimatableGlyphPropsSchema, AnimatableProp, AnimatablePropSchema, AnimationTrack, AnimationTrackSchema, ArcLengthLUTEntry, AudioSpectrumTypography, AudioSpectrumTypographySchema, BlockNode, BlockNodeSchema, BoxNode, BoxNodeSchema, CameraAnimation, CameraDoF, CameraDoFSchema, CameraFollowPathOptions, CameraLens, CameraLensSchema, CameraNode, CameraNodeSchema, CameraShake, CameraShakeSchema, CarrierHandoffConfig, CarrierHandoffConfigSchema, CarrierState, ChromaticGlitchConfig, ChromaticGlitchConfigSchema, ColorSignalOptions, ColorStop, ColorStopSchema, CompositionNodeBase, CompositorProgramConfig, CompositorProgramSchema, CompositorToProgramOptions, CubicBezierSegment, CubicBezierSegmentSchema, DollyOptions, DynamicStrokeProperties, DynamicStrokePropertiesSchema, EXTENDED_3D_ANIMATABLE_PROPS, EaseRef, EaseRefSchema, EnhancedTextNode, EnhancedTextNodeSchema, ExpressionEvaluationContext, ExpressionSelector, ExpressionSelectorSchema, Extended3DAnimatableProp, ExtendedGlyphProperties, ExtendedGlyphPropertiesSchema, FlexNode, FlexNodeSchema, FollowPathOptions, FromToOptions, GlyphAnchorGrouping, GlyphAnchorGroupingSchema, GlyphAnchorPoint, GlyphAnchorPointSchema, HandheldOptions, Keyframe, KeyframeSchema, KeyframeTuple, KineticMarqueeConfig, KineticMarqueeConfigSchema, LayerAnimation, LayerAnimationSchema, LayerAnimationSpec, LayoutInput, LayoutNode, LayoutNodeSchema, LayoutResult, LightNode, LightNodeSchema, LightType, LightTypeSchema, LineSpacingDynamics, LineSpacingDynamicsSchema, LongShadowConfig, LongShadowConfigSchema, MaterialType, MaterialTypeSchema, MeasureFn, MediaNode, MediaNodeSchema, Model3DNode, Model3DNodeSchema, OrbitOptions, ParticleDissolveConfig, ParticleDissolveConfigSchema, PathChainLUT, PathChainLUTEntry, PathLike3D, PathSegmentLUT, ProgramIssue, ProgramValidationResult, RackFocusOptions, Rect, Scene, SceneDefinition, SceneDefinitionSchema, SceneOptions, SceneTransitionType, SceneTransitionTypeSchema, SelectorBasedOn, SelectorBasedOnSchema, SelectorMode, SelectorModeSchema, SelectorShape, SelectorShapeSchema, SelectorUnits, SelectorUnitsSchema, Sequence, SequenceOptions, SequenceTimelineResult, ShapeFields, ShapeNode, ShapeNodeSchema, ShapeType, ShapeTypeSchema, SignalColorMode, SignalColorModeSchema, SignalDataSource, SignalMode, SignalModeSchema, SignalTrackOptions, SignalTrackSource, SizeSpec, SizeSpecSchema, SkewProperties, SkewPropertiesSchema, Spatial3DProperties, Spatial3DPropertiesSchema, SpringOptions, SpringPhysics, SpringPhysicsSchema, StaggerDirection, TextAnchorConfig, TextAnchorConfigSchema, TextAnimator, TextAnimatorBuilder, TextAnimatorSchema, TextAnimatorTransform, TextAnimatorTransformSchema, TextCursorConfig, TextCursorConfigSchema, TextCursorStyle, TextCursorStyleSchema, TextNode, TextNodeSchema, TextPathBuilder, TextPathOptions, TextPathOptionsSchema, TextPathSource, TextPathSourceSchema, TextRangeSelector, TextRangeSelectorSchema, TextScrambleConfig, TextScrambleConfigSchema, TextSelector, TextSelectorSchema, TextShadow, TextShadowSchema, TextSignalSelector, TextSignalSelectorSchema, type TextSpan, type TextSpanMark, TextSpanMarkSchema, TextSpanSchema, TextWigglySelector, TextWigglySelectorSchema, Tilt3DOptions, TrackEvaluationContext, TrackSource, TrackSourceSchema, TypewriterAnimator, TypewriterAnimatorSchema, TypingCadence, TypingCadenceSchema, VariableFontAxes, VariableFontAxesSchema, Vec2, Vec2Schema, Volumetric3DTransform, VolumetricFormationConfig, VolumetricFormationConfigSchema, VolumetricFormationMode, VolumetricFormationModeSchema, WiggleOptions, type Yoga, applyStaggerToChildren, buildPathLUT, calculateSequenceTimeline, collectMediaBindings, collectNodeIds, collectNodeOps, compositorToProgram, computeAnchorPivotOffset, computeCarrierContinuity, computeLayout, computeLayoutSync, computeLineLeadingDisplacement, computeRangeSelectorWeight, computeStaggerDelay, containerChildren, deterministicWigglyNoise, distanceToCurveParameter, ellipseToCubicBeziers, evaluateAnimationAtFrame, evaluateCubicBezier, evaluateCubicBezierDerivative, evaluateExpressionSelector, evaluateKeyframes, evaluateMarqueeOffset, evaluateSelectorCombination, evaluateSignal, evaluateSignalAccumulator, evaluateSkewMatrix, evaluateSpringOvershoot, evaluateSpringProgress, evaluateTrackAtFrame, evaluateTypewriterState, evaluateVolumetricFormation, evaluateWiggle, generateArcLengthLUT, generatePathSegments, getScramblePool, getShuffledOrder, initLayout, parseProgram, parseSvgPathToCubicBeziers, rotateHue, sampleAudioSpectrumScale, sampleCurveGeometry, samplePathChainGeometry, svgArcToCubicBeziers, validateLayoutProgram, waveToCubicBeziers };
|
|
3401
|
+
//# sourceMappingURL=index.d.mts.map
|