nexa-animation 0.7.0

package/dist/animatedSignal.d.ts

@@ -0,0 +1,22 @@
+type EasingFn = (t: number) => number;
+export interface TimingConfig {
+    to: number;
+    duration: number;
+    easing?: string | EasingFn;
+    onComplete?: () => void;
+}
+export interface SpringConfig {
+    to: number;
+    stiffness?: number;
+    damping?: number;
+    mass?: number;
+    onComplete?: () => void;
+}
+export interface AnimatedSignal {
+    value: number;
+    timing(config: TimingConfig): void;
+    spring(config: SpringConfig): void;
+    stop(): void;
+}
+export declare function animatedSignal(initial: number): AnimatedSignal;
+export {};

package/dist/animatedSignal.js

@@ -0,0 +1,101 @@
+import { signal } from 'nexa-reactivity';
+const easings = {
+    linear: (t) => t,
+    'ease-in': (t) => t * t,
+    'ease-out': (t) => t * (2 - t),
+    'ease-in-out': (t) => (t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t),
+};
+export function animatedSignal(initial) {
+    const _signal = signal(initial);
+    let _rafId = null;
+    let _timerId = null;
+    let _stopped = false;
+    const cancelCurrent = () => {
+        if (_rafId !== null) {
+            cancelAnimationFrame(_rafId);
+            _rafId = null;
+        }
+        if (_timerId !== null) {
+            clearTimeout(_timerId);
+            _timerId = null;
+        }
+        _stopped = true;
+    };
+    const now = () => typeof performance !== 'undefined' ? performance.now() : Date.now();
+    const scheduleFrame = (cb) => {
+        if (typeof requestAnimationFrame !== 'undefined') {
+            _rafId = requestAnimationFrame((time) => {
+                _rafId = null;
+                cb(time);
+            });
+        }
+        else {
+            _timerId = setTimeout(() => {
+                _timerId = null;
+                cb(now());
+            }, 16);
+        }
+    };
+    const obj = {
+        get value() {
+            return _signal.value;
+        },
+        set value(v) {
+            cancelCurrent();
+            _signal.value = v;
+        },
+        timing({ to, duration, easing = 'ease-out', onComplete }) {
+            cancelCurrent();
+            _stopped = false;
+            const from = _signal.peek();
+            const easeFn = typeof easing === 'function' ? easing : (easings[easing] ?? easings['ease-out']);
+            const startTime = now();
+            const tick = (time) => {
+                if (_stopped)
+                    return;
+                const elapsed = time - startTime;
+                const t = Math.min(Math.max(elapsed / duration, 0), 1);
+                _signal.value = from + (to - from) * easeFn(t);
+                if (t < 1) {
+                    scheduleFrame(tick);
+                }
+                else {
+                    _signal.value = to;
+                    onComplete?.();
+                }
+            };
+            scheduleFrame(tick);
+        },
+        spring({ to, stiffness = 170, damping = 26, mass = 1, onComplete }) {
+            cancelCurrent();
+            _stopped = false;
+            let pos = _signal.peek();
+            let vel = 0;
+            let lastTime = now();
+            const tick = (time) => {
+                if (_stopped)
+                    return;
+                // Prevent huge jumps if tab was inactive
+                const dt = Math.min((time - lastTime) / 1000, 0.064);
+                lastTime = time;
+                const force = -stiffness * (pos - to) - damping * vel;
+                vel += (force / mass) * dt;
+                pos += vel * dt;
+                _signal.value = pos;
+                const isSettled = Math.abs(pos - to) < 0.01 && Math.abs(vel) < 0.01;
+                if (isSettled) {
+                    _signal.value = to;
+                    onComplete?.();
+                }
+                else {
+                    scheduleFrame(tick);
+                }
+            };
+            scheduleFrame(tick);
+        },
+        stop() {
+            cancelCurrent();
+        },
+    };
+    return obj;
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { animatedSignal } from './animatedSignal.js';
+export { interpolate } from './interpolate.js';
+export { stagger } from './stagger.js';
+export type { TimingConfig, SpringConfig, AnimatedSignal } from './animatedSignal.js';
+export type { StaggerOptions } from './stagger.js';

package/dist/index.js

@@ -0,0 +1,3 @@
+export { animatedSignal } from './animatedSignal.js';
+export { interpolate } from './interpolate.js';
+export { stagger } from './stagger.js';

package/dist/interpolate.d.ts

@@ -0,0 +1 @@
+export declare function interpolate(input: number, inputRange: [number, number], outputRange: [number, number]): number;

package/dist/interpolate.js

@@ -0,0 +1,7 @@
+export function interpolate(input, inputRange, outputRange) {
+    const [inMin, inMax] = inputRange;
+    const [outMin, outMax] = outputRange;
+    const clamped = Math.max(inMin, Math.min(inMax, input));
+    const t = (clamped - inMin) / (inMax - inMin);
+    return outMin + t * (outMax - outMin);
+}

package/dist/stagger.d.ts

@@ -0,0 +1,5 @@
+export interface StaggerOptions {
+    delay: number;
+    initialDelay?: number;
+}
+export declare function stagger(callbacks: Array<() => void>, options: StaggerOptions): void;

package/dist/stagger.js

@@ -0,0 +1,12 @@
+export function stagger(callbacks, options) {
+    const { delay, initialDelay = 0 } = options;
+    callbacks.forEach((cb, i) => {
+        const ms = initialDelay + i * delay;
+        if (ms === 0) {
+            cb();
+        }
+        else {
+            setTimeout(cb, ms);
+        }
+    });
+}

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "nexa-animation",
+  "version": "0.7.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "nexa-reactivity": "0.7.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist"
+  }
+}