egaki 0.5.0 → 0.7.0

package/dist/vite/components.d.ts

@@ -0,0 +1,36 @@
+export interface BlurRevealProps {
+    text: string;
+    blur?: number;
+    fontSize?: number;
+    color?: string;
+    fontWeight?: number;
+    /** Duration of the reveal in frames (defaults to 60% of composition) */
+    revealFrames?: number;
+}
+export declare function BlurReveal({ text, blur, fontSize, color, fontWeight, revealFrames, }: BlurRevealProps): import("react").JSX.Element;
+export interface MaskedSlideRevealProps {
+    text: string;
+    staggerDelay?: number;
+    fontSize?: number;
+    color?: string;
+    fontWeight?: number;
+}
+export declare function MaskedSlideReveal({ text, staggerDelay, fontSize, color, fontWeight, }: MaskedSlideRevealProps): import("react").JSX.Element;
+export interface StaggeredFadeUpProps {
+    text: string;
+    staggerDelay?: number;
+    distance?: number;
+    fontSize?: number;
+    color?: string;
+    fontWeight?: number;
+}
+export declare function StaggeredFadeUp({ text, staggerDelay, distance, fontSize, color, fontWeight, }: StaggeredFadeUpProps): import("react").JSX.Element;
+export interface ShimmerSweepProps {
+    text: string;
+    baseColor?: string;
+    shineColor?: string;
+    fontSize?: number;
+    fontWeight?: number;
+}
+export declare function ShimmerSweep({ text, baseColor, shineColor, fontSize, fontWeight, }: ShimmerSweepProps): import("react").JSX.Element;
+//# sourceMappingURL=components.d.ts.map

package/dist/vite/components.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"components.d.ts","sourceRoot":"","sources":["../../src/vite/components.tsx"],"names":[],"mappings":"AA8BA,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,wEAAwE;IACxE,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB;AAED,wBAAgB,UAAU,CAAC,EACzB,IAAI,EACJ,IAAS,EACT,QAAa,EACb,KAAiB,EACjB,UAAgB,EAChB,YAAY,GACb,EAAE,eAAe,+BA+BjB;AAMD,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,MAAM,CAAA;IACZ,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED,wBAAgB,iBAAiB,CAAC,EAChC,IAAI,EACJ,YAAgB,EAChB,QAAa,EACb,KAAiB,EACjB,UAAgB,GACjB,EAAE,sBAAsB,+BAiDxB;AAMD,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAA;IACZ,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED,wBAAgB,eAAe,CAAC,EAC9B,IAAI,EACJ,YAAgB,EAChB,QAAa,EACb,QAAa,EACb,KAAiB,EACjB,UAAgB,GACjB,EAAE,oBAAoB,+BA4CtB;AAMD,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED,wBAAgB,YAAY,CAAC,EAC3B,IAAI,EACJ,SAAqB,EACrB,UAAsB,EACtB,QAAa,EACb,UAAgB,GACjB,EAAE,iBAAiB,+BA4CnB"}

package/dist/vite/components.js

@@ -0,0 +1,113 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Visual text effect components for egaki video.
+ *
+ * Must be 'use client' because they use Remotion hooks (useCurrentFrame,
+ * useVideoConfig, spring, interpolate) which only work inside the Player
+ * render context on the client.
+ */
+import { AbsoluteFill, interpolate, spring, useCurrentFrame, useVideoConfig, } from 'remotion';
+// ---------------------------------------------------------------------------
+// Shared constants
+// ---------------------------------------------------------------------------
+const FONT_SANS = '-apple-system, BlinkMacSystemFont, "SF Pro Display", "Segoe UI", sans-serif';
+export function BlurReveal({ text, blur = 20, fontSize = 96, color = '#fafafa', fontWeight = 700, revealFrames, }) {
+    const frame = useCurrentFrame();
+    const { durationInFrames } = useVideoConfig();
+    const dur = revealFrames ?? durationInFrames * 0.6;
+    const opacity = interpolate(frame, [0, dur], [0, 1], {
+        extrapolateRight: 'clamp',
+    });
+    const blurAmount = interpolate(frame, [0, dur], [blur, 0], {
+        extrapolateRight: 'clamp',
+    });
+    return (_jsx(AbsoluteFill, { style: { display: 'flex', alignItems: 'center', justifyContent: 'center' }, children: _jsx("span", { style: {
+                opacity,
+                filter: `blur(${blurAmount}px)`,
+                fontSize,
+                fontWeight,
+                color,
+                letterSpacing: '-0.04em',
+                fontFamily: FONT_SANS,
+            }, children: text }) }));
+}
+export function MaskedSlideReveal({ text, staggerDelay = 3, fontSize = 56, color = '#fafafa', fontWeight = 600, }) {
+    const frame = useCurrentFrame();
+    const { fps } = useVideoConfig();
+    const words = text.split(' ');
+    return (_jsx(AbsoluteFill, { style: { display: 'flex', alignItems: 'center', justifyContent: 'center' }, children: _jsx("span", { style: {
+                fontSize,
+                fontWeight,
+                color,
+                letterSpacing: '-0.03em',
+                fontFamily: FONT_SANS,
+            }, children: words.map((word, i) => {
+                const t = spring({
+                    frame: frame - i * staggerDelay,
+                    fps,
+                    config: { damping: 14 },
+                });
+                return (_jsx("span", { style: {
+                        display: 'inline-block',
+                        overflow: 'hidden',
+                        verticalAlign: 'bottom',
+                        lineHeight: 1.1,
+                        marginRight: '0.25em',
+                    }, children: _jsx("span", { style: {
+                            display: 'inline-block',
+                            transform: `translateY(${(1 - t) * 100}%)`,
+                        }, children: word }) }, i));
+            }) }) }));
+}
+export function StaggeredFadeUp({ text, staggerDelay = 4, distance = 24, fontSize = 48, color = '#a1a1aa', fontWeight = 400, }) {
+    const frame = useCurrentFrame();
+    const words = text.split(' ');
+    return (_jsx(AbsoluteFill, { style: { display: 'flex', alignItems: 'center', justifyContent: 'center' }, children: _jsx("span", { style: {
+                fontSize,
+                fontWeight,
+                color,
+                letterSpacing: '-0.02em',
+                fontFamily: FONT_SANS,
+            }, children: words.map((word, i) => {
+                const local = frame - i * staggerDelay;
+                const opacity = interpolate(local, [0, 14], [0, 1], {
+                    extrapolateLeft: 'clamp',
+                    extrapolateRight: 'clamp',
+                });
+                const y = interpolate(local, [0, 14], [distance, 0], {
+                    extrapolateLeft: 'clamp',
+                    extrapolateRight: 'clamp',
+                });
+                return (_jsx("span", { style: {
+                        display: 'inline-block',
+                        marginRight: '0.25em',
+                        opacity,
+                        transform: `translateY(${y}px)`,
+                    }, children: word }, i));
+            }) }) }));
+}
+export function ShimmerSweep({ text, baseColor = '#52525b', shineColor = '#fafafa', fontSize = 72, fontWeight = 700, }) {
+    const frame = useCurrentFrame();
+    const { durationInFrames } = useVideoConfig();
+    const position = interpolate(frame, [0, durationInFrames * 0.75], [200, -100], { extrapolateLeft: 'clamp', extrapolateRight: 'clamp' });
+    const textStyle = {
+        fontSize,
+        fontWeight,
+        letterSpacing: '-0.04em',
+        fontFamily: FONT_SANS,
+        margin: 0,
+        lineHeight: 1,
+    };
+    return (_jsx(AbsoluteFill, { style: { display: 'flex', alignItems: 'center', justifyContent: 'center' }, children: _jsxs("div", { style: { position: 'relative', display: 'inline-block' }, children: [_jsx("span", { style: { ...textStyle, color: baseColor }, children: text }), _jsx("span", { style: {
+                        ...textStyle,
+                        position: 'absolute',
+                        inset: 0,
+                        color: 'transparent',
+                        backgroundClip: 'text',
+                        WebkitBackgroundClip: 'text',
+                        backgroundImage: `linear-gradient(110deg, transparent 30%, ${shineColor} 50%, transparent 70%)`,
+                        backgroundSize: '200% 100%',
+                        backgroundPosition: `${position}% 50%`,
+                    }, children: text })] }) }));
+}

package/dist/vite/dispersion-rings-shader.d.ts

@@ -0,0 +1,44 @@
+/**
+ * DispersionRingsShader — chromatic dispersion through concentric ring lenses.
+ *
+ * Port of Framer's DispersionRings shader module for Remotion/egaki.
+ * Original source:
+ *   https://framerusercontent.com/modules/VMKsfJdfTvRVeIoDd5X9/fXq10iSPqH2cgEWzpK4N/DispersionRings.js
+ *
+ * An animated gradient of user-defined colors is distorted through concentric
+ * ring-shaped lenses radiating from the center. Each ring splits light into
+ * RGB channels at its edges (chromatic dispersion), producing rainbow fringing
+ * similar to light passing through concentric prisms. 8-sample temporal
+ * anti-aliasing with per-sample spectral weighting gives the effect a soft,
+ * photographic quality.
+ */
+import type { CSSProperties } from 'react';
+export interface DispersionRingsShaderProps {
+    /** Color palette for the gradient (max 8). Hex strings like "#91FFCC". */
+    colors?: string[];
+    /** Seed for gradient flow directions and frequencies. Different seeds = different patterns. */
+    seed?: number;
+    /** Animation speed multiplier. 0 = frozen, 0.5 = default, 2 = fast. */
+    speed?: number;
+    /** Wavy spatial jitter per sample. 0 = clean, higher = dreamy/melting distortion. */
+    ephemeralAmp?: number;
+    /** UV scale before the ring grid. Higher = more zoomed in, fewer visible rings. */
+    lensScale?: number;
+    /** Spacing between concentric rings. Smaller = tighter rings. */
+    ringSpacing?: number;
+    /** Radius of each ring lens. Controls magnification area vs flat area. */
+    ringRadius?: number;
+    /** How strongly the ring lens warps UVs. Higher = more magnification. */
+    ringWarpStrength?: number;
+    /** How much R and B channels diverge from G at ring edges. 0 = none, 1 = maximum. */
+    ringDispersion?: number;
+    /** Extra rainbow tint multiplier at ring edges. Pushes edge colors toward prismatic look. */
+    edgeDisp?: number;
+    style?: CSSProperties;
+}
+/**
+ * Property controls matching the original Framer DispersionRings module.
+ * Ranges, defaults, and step sizes are preserved from the original.
+ */
+export declare const DispersionRingsShader: React.FC<DispersionRingsShaderProps>;
+//# sourceMappingURL=dispersion-rings-shader.d.ts.map

package/dist/vite/dispersion-rings-shader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispersion-rings-shader.d.ts","sourceRoot":"","sources":["../../src/vite/dispersion-rings-shader.tsx"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAA;AAO1C,MAAM,WAAW,0BAA0B;IACzC,0EAA0E;IAC1E,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;IACjB,+FAA+F;IAC/F,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,uEAAuE;IACvE,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,qFAAqF;IACrF,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,mFAAmF;IACnF,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,iEAAiE;IACjE,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,0EAA0E;IAC1E,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,yEAAyE;IACzE,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,qFAAqF;IACrF,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,6FAA6F;IAC7F,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,KAAK,CAAC,EAAE,aAAa,CAAA;CACtB;AA6MD;;;GAGG;AACH,eAAO,MAAM,qBAAqB,EA2E5B,KAAK,CAAC,EAAE,CAAC,0BAA0B,CAAC,CAAA"}

package/dist/vite/dispersion-rings-shader.js

@@ -0,0 +1,282 @@
+'use client';
+import { defineShader } from "./shader-renderer.js";
+// ---------------------------------------------------------------------------
+// Fragment shader body
+// ---------------------------------------------------------------------------
+/**
+ * Raw GLSL fragment body from DispersionRings.js.
+ * The defineShader engine prepends #version, precision, v_uv, fragColor,
+ * uniform declarations, and built-in uniforms automatically.
+ *
+ * Algorithm overview:
+ *   1. Gradient flow: seed-derived sin/cos waves create an organic color field
+ *   2. Ring lens: distance from center is divided into repeating ring cells;
+ *      each ring has a spherical lens that warps UVs (magnification at center,
+ *      edge factor at rim)
+ *   3. Chromatic dispersion: lens applied 3x per sample (R, G, B) with different
+ *      index-of-refraction offsets, splitting color channels at ring edges
+ *   4. 8-sample TAA: per-pixel random offset + spectral tint weights, averaged
+ */
+const FRAGMENT_SOURCE = `
+const int SAMPLES = 8;
+const float EPHEMERAL_DRIP = 1.0;
+
+// === PCG hash - https://www.jcgt.org/published/0009/03/02/
+uvec3 hash3(uvec3 v) {
+    v = v * 1664525u + 1013904223u;
+    v.x += v.y * v.z;
+    v.y += v.z * v.x;
+    v.z += v.x * v.y;
+    v ^= v >> 16u;
+    v.x += v.y * v.z;
+    v.y += v.z * v.x;
+    v.z += v.x * v.y;
+    return v;
+}
+
+uvec3 seed;
+vec3 random3f() {
+    seed = hash3(seed);
+    return vec3(seed) / float(-1u);
+}
+
+vec3 seedRandom(float seedVal) {
+    uvec3 s = uvec3(
+        floatBitsToUint(seedVal),
+        floatBitsToUint(seedVal * 1.5 + 7.31),
+        floatBitsToUint(seedVal * 2.7 + 13.37)
+    );
+    s = hash3(s);
+    return vec3(s) / float(0xFFFFFFFFu);
+}
+
+// === PALETTE SAMPLING ===
+vec3 getColor(int idx) {
+    if (u_colors_length < 1) return vec3(0.0);
+    int safeIdx = clamp(idx, 0, u_colors_length - 1);
+    return u_colors[safeIdx].rgb;
+}
+
+vec3 paletteN(float t, int count) {
+    if (count < 1) return vec3(0.0);
+    if (count < 2) return getColor(0);
+    t = clamp(t, 0.0, 1.0) * float(count - 1);
+    int idx = min(int(floor(t)), count - 2);
+    float localT = fract(t);
+    localT = localT * localT * (3.0 - 2.0 * localT);
+    return mix(getColor(idx), getColor(idx + 1), localT);
+}
+
+// === Gradient Flow ===
+float getGradientT(vec2 uv, float t, vec2 dir1, vec2 dir2, vec3 freqs, vec2 dir3) {
+    vec2 suv = uv * 1.;
+
+    float flow = dot(suv, dir1) + sin(dot(suv, dir2) * freqs.x + t) * 0.3 + t * 0.2;
+    float flow2 = dot(suv, dir2.yx) + cos(dot(suv, dir1.yx) * freqs.y - t * 0.8) * 0.25;
+
+    float gradT = sin(flow * 1.5) * 0.5 + 0.5;
+    gradT += cos(flow2 * 1.2) * 1.3;
+    gradT += sin(dot(suv, dir3) * freqs.z + t * 3.5) * 1.2;
+
+    return smoothstep(0.0, 4.12, gradT);
+}
+
+// === RING LENS ===
+void applyRingLens(vec2 pp, vec2 fragCoord, vec2 r, float iorOffset, out vec2 warpedUV, out float edgeFactor) {
+    float radiusSq = u_ringRadius * u_ringRadius;
+
+    vec2 lensUV = (fragCoord - vec2(r.x * 0.5, 0.0)) / r.y * u_lensScale;
+    float dist = length(lensUV);
+
+    float fw = fwidth(dist / u_ringSpacing) * u_ringSpacing;
+
+    float ringDist = mod(dist, u_ringSpacing) / u_ringSpacing;
+    float ringShifted = ringDist - 0.5;
+    float localR = ringShifted * 2.0;
+
+    float sp = radiusSq - localR * localR;
+
+    float edgeSdf = abs(localR) - u_ringRadius;
+    float edgeAA = smoothstep(fw, -fw, edgeSdf);
+
+    float lensAmount = smoothstep(0., 0.3, sp);
+    edgeFactor = (1.0 - smoothstep(0.0, radiusSq, sp)) * lensAmount * edgeAA;
+
+    vec2 dir = lensUV / max(dist, 0.001);
+
+    warpedUV = pp;
+    if (sp > 0.0) {
+        float lens = sqrt(sp) / max(u_ringRadius, 0.001);
+        float baseWarp = mix(1.0, u_ringWarpStrength, lens);
+        float warpAmount = baseWarp * (1.0 + iorOffset);
+        float ringCenter = (floor(dist / u_ringSpacing) + 0.5) * u_ringSpacing;
+        vec2 offset = pp - dir * ringCenter;
+        warpedUV = dir * ringCenter + offset * warpAmount;
+    }
+}
+
+void main() {
+    vec2 fragCoord = v_uv * u_resolution;
+    seed = uvec3(uvec2(fragCoord), uint(fract(u_time) * 1000.0));
+
+    vec2 r = u_resolution;
+    vec2 p = (fragCoord * 2.0 - r) / r.y;
+    float t = u_time * u_speed;
+
+    int colorCount = u_colors_length;
+
+    // Early out: no colors -> black
+    if (colorCount < 1) {
+        fragColor = vec4(0.0, 0.0, 0.0, 1.0);
+        return;
+    }
+
+    // Seed-based flow directions (precomputed once)
+    vec3 seedOff1 = seedRandom(u_seed);
+    vec3 seedOff2 = seedRandom(u_seed + 100.0);
+
+    float angle1 = seedOff1.x * 6.28;
+    float angle2 = seedOff1.y * 6.28;
+    vec2 dir1 = vec2(cos(angle1), sin(angle1));
+    vec2 dir2 = vec2(cos(angle2), sin(angle2));
+    vec2 dir3 = dir1 + dir2;
+    vec3 freqs = vec3(
+        1.0 + seedOff1.z * 2.0,
+        1.0 + seedOff2.x * 1.5,
+        1.5 + seedOff2.y * 2.0
+    );
+
+    float dice = random3f().x;
+
+    vec3 ringIorOffsets = vec3(-1.0, 0.0, 1.0) * u_ringDispersion;
+
+    vec3 col = vec3(0.0);
+
+    for (int i = 0; i < SAMPLES; i++) {
+        float ephemeral = (float(i) + dice) / float(SAMPLES);
+        float sqEph = ephemeral * ephemeral;
+
+        vec2 pt = p;
+        pt.x += u_ephemeralAmp * sqEph * sin(p.y * 2.0 + t);
+        pt.y += u_ephemeralAmp * sqEph * cos(p.x * 1.5 - t) * 0.5;
+        pt.y -= (1.0 - exp(-EPHEMERAL_DRIP * sqEph)) * abs(pt.y) * sign(pt.y) * 0.3;
+
+        vec3 tint = smoothstep(1.0, 0.0, abs(3.0 * ephemeral - vec3(1.0, 1.5, 2.0)));
+
+        vec3 gradTs = vec3(0.0);
+        vec3 edgeFactors = vec3(0.0);
+
+        for (int c = 0; c < 3; c++) {
+            vec2 pp = pt * u_lensScale;
+            vec2 warpedUV;
+            float edgeFactor;
+            applyRingLens(pp, fragCoord, r, ringIorOffsets[c], warpedUV, edgeFactor);
+
+            vec2 gradUV = warpedUV / u_lensScale;
+            gradTs[c] = getGradientT(gradUV, t * 0.8, dir1, dir2, freqs, dir3);
+            edgeFactors[c] = edgeFactor;
+        }
+
+        vec3 convergentColor = paletteN(gradTs.g, colorCount);
+        float edgeMix = max(max(edgeFactors.r, edgeFactors.g), edgeFactors.b);
+
+        vec3 dispersedColor = vec3(
+            paletteN(gradTs.r, colorCount).r,
+            convergentColor.g,
+            paletteN(gradTs.b, colorCount).b
+        );
+
+        vec3 finalColor = mix(convergentColor, dispersedColor, edgeMix * 2.0);
+
+        vec3 rainbow = (gradTs - gradTs.g) * 3.0;
+        finalColor += rainbow * edgeMix * u_edgeDisp;
+
+        col += tint * finalColor * (3.0 / float(SAMPLES));
+    }
+
+    fragColor = vec4(col, 1.0);
+}
+`;
+// ---------------------------------------------------------------------------
+// Component
+// ---------------------------------------------------------------------------
+/**
+ * Property controls matching the original Framer DispersionRings module.
+ * Ranges, defaults, and step sizes are preserved from the original.
+ */
+export const DispersionRingsShader = defineShader({
+    title: 'DispersionRingsShader',
+    fragment: FRAGMENT_SOURCE,
+    propertyControls: {
+        colors: {
+            type: 'array',
+            control: { type: 'color' },
+            maxCount: 8,
+            maxVisible: 4,
+            defaultValue: ['#91FFCC', '#FFB938', '#FF4242'],
+        },
+        seed: {
+            type: 'number',
+            defaultValue: 47,
+            min: 0,
+            max: 1000,
+            step: 1,
+        },
+        speed: {
+            type: 'number',
+            defaultValue: 0.5,
+            min: 0,
+            max: 2,
+            step: 0.01,
+        },
+        ephemeralAmp: {
+            type: 'number',
+            defaultValue: 0.12,
+            min: 0,
+            max: 0.5,
+            step: 0.01,
+        },
+        lensScale: {
+            type: 'number',
+            defaultValue: 10,
+            min: 0.1,
+            max: 10,
+            step: 0.1,
+        },
+        ringSpacing: {
+            type: 'number',
+            defaultValue: 1.5,
+            min: 0.1,
+            max: 5,
+            step: 0.1,
+        },
+        ringRadius: {
+            type: 'number',
+            defaultValue: 1,
+            min: 0.1,
+            max: 2,
+            step: 0.01,
+        },
+        ringWarpStrength: {
+            type: 'number',
+            defaultValue: 4,
+            min: 0,
+            max: 5,
+            step: 0.1,
+        },
+        ringDispersion: {
+            type: 'number',
+            defaultValue: 0.4,
+            min: 0,
+            max: 1,
+            step: 0.01,
+        },
+        edgeDisp: {
+            type: 'number',
+            defaultValue: 1.3,
+            min: 0,
+            max: 5,
+            step: 0.1,
+        },
+    },
+});

package/dist/vite/easing-curves.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Easing curve engine for spring/bounce/overshoot presets.
+ *
+ * Ported from Jitter's easing engine (jitter.video webpack bundle,
+ * module 78102). The presets were previously stored as hardcoded sample
+ * arrays extracted from Jitter; they are now generated from the same
+ * three primitives Jitter uses:
+ *
+ *   1. Polybezier paths: control points with handles, linearly interpolated
+ *      between intensity configs (d3-interpolate semantics), each segment
+ *      evaluated with an analytic (Cardano) cubic-bezier y(x) solver.
+ *   2. Spring physics (elasticSnap): semi-implicit Euler, step 0.005,
+ *      settle epsilon 1e-10, timeline truncated at 34% of settle time.
+ *   3. Bounce physics: explicit Euler, step 1, gravity 9.8e-6, velocity
+ *      flipped and scaled by bounceFactor when crossing position 100,
+ *      capped at 16 bounces.
+ *
+ * Each `*Samples` export contains 51 evenly-spaced points (t=0 to t=1)
+ * per intensity level (0, 25, 50, 75, 100), rounded to 4 decimals exactly
+ * like Jitter does. The generated values are verified against the original
+ * extracted arrays in easing-curves.test.ts. Values can exceed the 0-1
+ * range for overshoot and bounce effects.
+ *
+ * Porting lessons (do not "simplify" these or the outputs change):
+ *   - Lerp must be `a * (1 - t) + b * t` (d3-interpolate form), not
+ *     `a + (b - a) * t`, to stay bit-identical with Jitter's output.
+ *   - The intensity pair search keeps the LOWER key on distance ties
+ *     (strict `<` in the reduce), so intensity 25 lerps configs 0..50.
+ *   - Spring acceleration must keep Jitter's exact expression order:
+ *     `(-tension * (pos - 100) + -friction * v) / mass`.
+ *   - Rounding is `Math.round((x + Number.EPSILON) * 1e4) / 1e4`.
+ */
+/** Symbol key for attaching bezier control points to easing functions. */
+export declare const BEZIER_POINTS: unique symbol;
+/**
+ * cubic-bezier(x1, y1, x2, y2) as a y(x) function. x1/x2 must be in [0, 1];
+ * y values may exceed [0, 1] for overshoot.
+ *
+ * The returned function has a `[BEZIER_POINTS]` property with the original
+ * `[x1, y1, x2, y2]` tuple so the tweakpane bezier blade can show and edit
+ * the exact curve.
+ */
+export declare function cubicBezier(x1: number, y1: number, x2: number, y2: number): (x: number) => number;
+/** Handle: x is a fraction toward the neighbor anchor, y is in value units. */
+export interface HandleXY {
+    x: number;
+    y: number;
+}
+/** A bare number is shorthand for `{ x: number, y: 0 }`. */
+export type Handle = number | HandleXY;
+export interface ControlPoint {
+    x: number;
+    y: number;
+    /** Handle toward the previous point (incoming). */
+    lower?: Handle;
+    /** Handle toward the next point (outgoing). */
+    upper?: Handle;
+}
+/** Build a y(x) easing function from polybezier control points. */
+export declare function polybezier(points: ControlPoint[]): (x: number) => number;
+/** An easing preset parameterized by intensity (0-100, continuous). */
+export type EasingPreset = (intensity: number) => (t: number) => number;
+/** Polybezier preset parameterized by intensity. */
+export declare function pathPreset(configs: Record<number, ControlPoint[]>): EasingPreset;
+export interface SpringPhysicsConfig {
+    mass: number;
+    tension: number;
+    friction: number;
+    v0: number;
+}
+/** Spring preset parameterized by intensity. */
+export declare function springPreset(configs: Record<number, SpringPhysicsConfig>): EasingPreset;
+export interface BouncePhysicsConfig {
+    mass: number;
+    /** Fraction of velocity kept (and flipped) at each bounce. */
+    bounceFactor: number;
+    friction: number;
+    v0: number;
+}
+/** Bounce preset parameterized by intensity. */
+export declare function bouncePreset(configs: Record<number, BouncePhysicsConfig>): EasingPreset;
+export type Intensity = 0 | 25 | 50 | 75 | 100;
+/** Sample a preset at 51 evenly spaced points for all 5 intensity levels. */
+export declare function samplePreset(preset: EasingPreset): Record<Intensity, number[]>;
+/** natural:throw:v1 — anticipate backward, fly past, settle */
+export declare const naturalThrow: EasingPreset;
+/** slowdown:overshoot:v1 — decelerate with a single overshoot */
+export declare const decelerateOvershoot: EasingPreset;
+/** slowdown:elasticOvershoot:v1 — decelerate with elastic overshoot */
+export declare const decelerateElastic: EasingPreset;
+/** accelerate:impulse:v1 — dip backward then accelerate away */
+export declare const accelerateImpulse: EasingPreset;
+/** accelerate:elastic:v1 — elastic windup then accelerate away */
+export declare const accelerateElastic: EasingPreset;
+/** elastic:standard:v1 — spring snap with ringing oscillation */
+export declare const elasticSnap: EasingPreset;
+/** bounce:standard:v1 — like a ball dropping */
+export declare const bounce: EasingPreset;
+/** bounce:anticipate:v1 — pull back first, then bounce into place */
+export declare const bounceAnticipate: EasingPreset;
+/** bounce:throw:v1 — thrown with initial velocity, bounces on landing */
+export declare const bounceThrow: EasingPreset;
+/** impulse:standard:v1 — slow dip then gradual release */
+export declare const impulseSlow: EasingPreset;
+/** impulseAndOvershoot:standard:v1 — dip backward, overshoot, settle */
+export declare const impulseOvershoot: EasingPreset;
+/** overshoot:standard:v1 — overshoot then settle back */
+export declare const overshoot: EasingPreset;
+/** overshoot:elastic:v1 — overshoot with elastic ringing */
+export declare const overshootElastic: EasingPreset;
+/** overshoot:bouncy:v1 — overshoot with a bouncy settle */
+export declare const overshootBouncy: EasingPreset;
+export declare const naturalThrowSamples: Record<Intensity, number[]>;
+export declare const decelerateOvershootSamples: Record<Intensity, number[]>;
+export declare const decelerateElasticSamples: Record<Intensity, number[]>;
+export declare const accelerateImpulseSamples: Record<Intensity, number[]>;
+export declare const accelerateElasticSamples: Record<Intensity, number[]>;
+export declare const elasticSnapSamples: Record<Intensity, number[]>;
+export declare const bounceSamples: Record<Intensity, number[]>;
+export declare const bounceAnticipateSamples: Record<Intensity, number[]>;
+export declare const bounceThrowSamples: Record<Intensity, number[]>;
+export declare const impulseSlowSamples: Record<Intensity, number[]>;
+export declare const impulseOvershootSamples: Record<Intensity, number[]>;
+export declare const overshootSamples: Record<Intensity, number[]>;
+export declare const overshootElasticSamples: Record<Intensity, number[]>;
+export declare const overshootBouncySamples: Record<Intensity, number[]>;
+/** Linearly interpolate a sampled curve at time t (0-1). */
+export declare function lerpSamples(samples: readonly number[], t: number): number;
+//# sourceMappingURL=easing-curves.d.ts.map

package/dist/vite/easing-curves.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"easing-curves.d.ts","sourceRoot":"","sources":["../../src/vite/easing-curves.ts"],"names":[],"mappings":"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"}