@redwilly/anima 0.1.0 → 0.1.2

package/dist/core/animations/morph/MorphTo.d.ts

@@ -1,22 +0,0 @@
-import { TransformativeAnimation } from '../categories';
-import { VMobject } from '../../../mobjects/VMobject';
-/**
- * Animation that morphs a VMobject from its current shape to a target shape.
- * Uses BezierPath interpolation for smooth path transitions.
- *
- * This is a transformative animation - the source must already be in the scene.
- * The target VMobject is used only as a shape template and is NOT added to the scene.
- * Source paths are captured lazily when animation becomes active.
- *
- * @example
- * scene.add(circle);
- * scene.play(new MorphTo(circle, square));  // circle morphs into square's shape
- */
-export declare class MorphTo<T extends VMobject = VMobject> extends TransformativeAnimation<T> {
-    private sourcePaths;
-    private readonly targetPaths;
-    constructor(source: T, target: VMobject);
-    protected captureStartState(): void;
-    interpolate(progress: number): void;
-    private getEmptyPath;
-}

package/dist/core/animations/morph/MorphTo.js

@@ -1,42 +0,0 @@
-import { TransformativeAnimation } from '../categories';
-import { BezierPath } from '../../math/bezier/BezierPath';
-/**
- * Animation that morphs a VMobject from its current shape to a target shape.
- * Uses BezierPath interpolation for smooth path transitions.
- *
- * This is a transformative animation - the source must already be in the scene.
- * The target VMobject is used only as a shape template and is NOT added to the scene.
- * Source paths are captured lazily when animation becomes active.
- *
- * @example
- * scene.add(circle);
- * scene.play(new MorphTo(circle, square));  // circle morphs into square's shape
- */
-export class MorphTo extends TransformativeAnimation {
-    sourcePaths;
-    targetPaths;
-    constructor(source, target) {
-        super(source);
-        this.targetPaths = target.paths.map(p => p.clone());
-    }
-    captureStartState() {
-        this.sourcePaths = this.target.paths.map(p => p.clone());
-    }
-    interpolate(progress) {
-        this.ensureInitialized();
-        const maxPaths = Math.max(this.sourcePaths.length, this.targetPaths.length);
-        const newPaths = [];
-        for (let i = 0; i < maxPaths; i++) {
-            const sourcePath = this.sourcePaths[i] ?? this.getEmptyPath();
-            const targetPath = this.targetPaths[i] ?? this.getEmptyPath();
-            const interpolated = BezierPath.interpolate(sourcePath, targetPath, progress);
-            newPaths.push(interpolated);
-        }
-        this.target.paths = newPaths;
-    }
-    getEmptyPath() {
-        const path = new BezierPath();
-        path.moveTo(this.target.position);
-        return path;
-    }
-}

package/dist/core/animations/morph/index.d.ts

@@ -1 +0,0 @@
-export { MorphTo } from './MorphTo';

package/dist/core/animations/morph/index.js

@@ -1 +0,0 @@
-export { MorphTo } from './MorphTo';

package/dist/core/animations/transform/MoveTo.d.ts

@@ -1,24 +0,0 @@
-import { TransformativeAnimation } from '../categories';
-import { Mobject } from '../../../mobjects/Mobject';
-import { Vector2 } from '../../math/Vector2/Vector2';
-/**
- * Animation that moves a Mobject from its current position to a destination.
- * Uses linear interpolation between start and end positions.
- *
- * This is a transformative animation - the target must already be in the scene.
- * Start position is captured lazily when animation becomes active.
- *
- * @example
- * scene.add(circle);  // or use FadeIn first
- * scene.play(new MoveTo(circle, 2, 0));  // Move to (2, 0)
- */
-export declare class MoveTo<T extends Mobject = Mobject> extends TransformativeAnimation<T> {
-    private startPosition;
-    private readonly endPosition;
-    constructor(target: T, destination: Vector2);
-    constructor(target: T, x: number, y: number);
-    protected captureStartState(): void;
-    interpolate(progress: number): void;
-    /** Returns the target position of the move animation. */
-    getDestination(): Vector2;
-}

package/dist/core/animations/transform/MoveTo.js

@@ -1,38 +0,0 @@
-import { TransformativeAnimation } from '../categories';
-import { Vector2 } from '../../math/Vector2/Vector2';
-/**
- * Animation that moves a Mobject from its current position to a destination.
- * Uses linear interpolation between start and end positions.
- *
- * This is a transformative animation - the target must already be in the scene.
- * Start position is captured lazily when animation becomes active.
- *
- * @example
- * scene.add(circle);  // or use FadeIn first
- * scene.play(new MoveTo(circle, 2, 0));  // Move to (2, 0)
- */
-export class MoveTo extends TransformativeAnimation {
-    startPosition;
-    endPosition;
-    constructor(target, xOrDestination, y) {
-        super(target);
-        if (xOrDestination instanceof Vector2) {
-            this.endPosition = xOrDestination;
-        }
-        else {
-            this.endPosition = new Vector2(xOrDestination, y ?? 0);
-        }
-    }
-    captureStartState() {
-        this.startPosition = this.target.position;
-    }
-    interpolate(progress) {
-        this.ensureInitialized();
-        const newPosition = this.startPosition.lerp(this.endPosition, progress);
-        this.target.pos(newPosition.x, newPosition.y);
-    }
-    /** Returns the target position of the move animation. */
-    getDestination() {
-        return this.endPosition;
-    }
-}

package/dist/core/animations/transform/Rotate.d.ts

@@ -1,23 +0,0 @@
-import { TransformativeAnimation } from '../categories';
-import type { Mobject } from '../../../mobjects/Mobject';
-/**
- * Animation that rotates a Mobject by a specified angle.
- * Uses linear interpolation between start and end rotation.
- *
- * This is a transformative animation - the target must already be in the scene.
- * Start rotation is captured lazily when animation becomes active.
- *
- * @example
- * scene.add(square);
- * scene.play(new Rotate(square, Math.PI / 4));  // Rotate 45 degrees
- */
-export declare class Rotate<T extends Mobject = Mobject> extends TransformativeAnimation<T> {
-    private startRotation;
-    private endRotation;
-    private readonly angle;
-    constructor(target: T, angle: number);
-    protected captureStartState(): void;
-    interpolate(progress: number): void;
-    /** Returns the total rotation angle in radians. */
-    getAngle(): number;
-}

package/dist/core/animations/transform/Rotate.js

@@ -1,34 +0,0 @@
-import { TransformativeAnimation } from '../categories';
-/**
- * Animation that rotates a Mobject by a specified angle.
- * Uses linear interpolation between start and end rotation.
- *
- * This is a transformative animation - the target must already be in the scene.
- * Start rotation is captured lazily when animation becomes active.
- *
- * @example
- * scene.add(square);
- * scene.play(new Rotate(square, Math.PI / 4));  // Rotate 45 degrees
- */
-export class Rotate extends TransformativeAnimation {
-    startRotation;
-    endRotation;
-    angle;
-    constructor(target, angle) {
-        super(target);
-        this.angle = angle;
-    }
-    captureStartState() {
-        this.startRotation = this.target.rotation;
-        this.endRotation = this.startRotation + this.angle;
-    }
-    interpolate(progress) {
-        this.ensureInitialized();
-        const newRotation = this.startRotation + (this.endRotation - this.startRotation) * progress;
-        this.target.setRotation(newRotation);
-    }
-    /** Returns the total rotation angle in radians. */
-    getAngle() {
-        return this.angle;
-    }
-}

package/dist/core/animations/transform/Scale.d.ts

@@ -1,23 +0,0 @@
-import { TransformativeAnimation } from '../categories';
-import { Mobject } from '../../../mobjects/Mobject';
-/**
- * Animation that scales a Mobject to a target scale factor.
- * Uses linear interpolation between start and end scale.
- *
- * This is a transformative animation - the target must already be in the scene.
- * Start scale is captured lazily when animation becomes active.
- *
- * @example
- * scene.add(circle);
- * scene.play(new Scale(circle, 2));  // Scale to 2x
- */
-export declare class Scale<T extends Mobject = Mobject> extends TransformativeAnimation<T> {
-    private startScale;
-    private readonly endScale;
-    constructor(target: T, factor: number);
-    constructor(target: T, factorX: number, factorY: number);
-    protected captureStartState(): void;
-    interpolate(progress: number): void;
-    /** Returns the scale factor. */
-    getFactor(): number;
-}

package/dist/core/animations/transform/Scale.js

@@ -1,35 +0,0 @@
-import { TransformativeAnimation } from '../categories';
-import { Vector2 } from '../../math/Vector2/Vector2';
-/**
- * Animation that scales a Mobject to a target scale factor.
- * Uses linear interpolation between start and end scale.
- *
- * This is a transformative animation - the target must already be in the scene.
- * Start scale is captured lazily when animation becomes active.
- *
- * @example
- * scene.add(circle);
- * scene.play(new Scale(circle, 2));  // Scale to 2x
- */
-export class Scale extends TransformativeAnimation {
-    startScale;
-    endScale;
-    constructor(target, factorX, factorY) {
-        super(target);
-        const endX = factorX;
-        const endY = factorY ?? factorX;
-        this.endScale = new Vector2(endX, endY);
-    }
-    captureStartState() {
-        this.startScale = this.target.scale;
-    }
-    interpolate(progress) {
-        this.ensureInitialized();
-        const newScale = this.startScale.lerp(this.endScale, progress);
-        this.target.setScale(newScale.x, newScale.y);
-    }
-    /** Returns the scale factor. */
-    getFactor() {
-        return this.endScale.x;
-    }
-}

package/dist/core/animations/transform/index.d.ts

@@ -1,3 +0,0 @@
-export { MoveTo } from './MoveTo';
-export { Rotate } from './Rotate';
-export { Scale } from './Scale';

package/dist/core/animations/transform/index.js

@@ -1,3 +0,0 @@
-export { MoveTo } from './MoveTo';
-export { Rotate } from './Rotate';
-export { Scale } from './Scale';

package/dist/core/animations/types.d.ts

@@ -1,52 +0,0 @@
-import type { EasingFunction } from './easing';
-import type { Animation } from './Animation';
-import type { Mobject } from '../../mobjects/Mobject';
-/**
- * Configuration options for animations.
- */
-export interface AnimationConfig {
-    /** Duration of the animation in seconds. Default: 1 */
-    readonly durationSeconds: number;
-    /** Easing function to apply. Default: smooth */
-    readonly easing: EasingFunction;
-    /** Delay before animation starts in seconds. Default: 0 */
-    readonly delaySeconds: number;
-}
-/**
- * Animation lifecycle category determines how Scene.play() handles the target.
- * - 'introductory': Auto-registers target with scene (FadeIn, Create, Draw, Write)
- * - 'transformative': Requires target to already be in scene (MoveTo, Rotate, Scale)
- * - 'exit': Requires target in scene, may auto-remove after (FadeOut)
- */
-export type AnimationLifecycle = 'introductory' | 'transformative' | 'exit';
-/**
- * Configuration for a queued animation in the fluent API.
- */
-export interface FluentConfig {
-    durationSeconds: number;
-    easing?: EasingFunction;
-    delaySeconds?: number;
-}
-/**
- * Factory function that creates an Animation for a given target.
- */
-export type AnimationFactory = (target: Mobject) => Animation<Mobject>;
-/**
- * A queued animation descriptor storing the factory and configuration.
- */
-export interface QueuedAnimation {
-    factory: AnimationFactory;
-    config: FluentConfig;
-}
-/**
- * A pre-built animation that's already configured (e.g., from parallel()).
- */
-export interface QueuedPrebuilt {
-    animation: Animation<Mobject>;
-}
-/** Union type for queue entries */
-export type QueueEntry = QueuedAnimation | QueuedPrebuilt;
-/** Type guard to check if entry is a pre-built animation */
-export declare function isPrebuilt(entry: QueueEntry): entry is QueuedPrebuilt;
-/** Default animation duration in seconds. */
-export declare const DEFAULT_DURATION = 1;

package/dist/core/animations/types.js

@@ -1,6 +0,0 @@
-/** Type guard to check if entry is a pre-built animation */
-export function isPrebuilt(entry) {
-    return 'animation' in entry;
-}
-/** Default animation duration in seconds. */
-export const DEFAULT_DURATION = 1;

package/dist/core/camera/Camera.d.ts

@@ -1,87 +0,0 @@
-import { Vector2 } from '../math/Vector2/Vector2';
-import { Matrix3x3 } from '../math/matrix/Matrix3x3';
-import { CameraFrame } from './CameraFrame';
-import { type CameraConfig } from './types';
-/**
- * Camera manages the view into the scene.
- * Uses CameraFrame (a Mobject) to store transform state, enabling camera animations.
- *
- * The Camera provides both instant manipulation methods (panTo, zoomTo) and
- * access to the CameraFrame for fluent animation APIs.
- *
- * @example
- * // Instant camera manipulation
- * camera.zoomTo(2);
- * camera.panTo(new Vector2(5, 3));
- *
- * @example
- * // Animated camera movement via frame
- * this.play(this.frame.zoomIn(2).duration(1));
- * this.play(this.frame.centerOn(circle).duration(0.5));
- */
-export declare class Camera {
-    private readonly config;
-    /** The CameraFrame that stores the camera's transform state. Use this for animations. */
-    readonly frame: CameraFrame;
-    /**
-     * Creates a new Camera with the specified viewport dimensions.
-     *
-     * @param config - Configuration options
-     * @param config.pixelWidth - Width of the viewport in pixels (default: 1920)
-     * @param config.pixelHeight - Height of the viewport in pixels (default: 1080)
-     */
-    constructor(config?: CameraConfig);
-    get frameHeight(): number;
-    get frameWidth(): number;
-    get frameYRadius(): number;
-    get frameXRadius(): number;
-    get pixelWidth(): number;
-    get pixelHeight(): number;
-    get position(): Vector2;
-    get zoom(): number;
-    get rotation(): number;
-    pan(delta: Vector2): this;
-    panTo(position: Vector2): this;
-    zoomTo(level: number): this;
-    rotateTo(angle: number): this;
-    getViewMatrix(): Matrix3x3;
-    /**
-     * Transforms a world-space position to screen-space (pixel) coordinates.
-     *
-     * Screen coordinates have origin at top-left, with x increasing right
-     * and y increasing downward.
-     *
-     * @param pos - Position in world coordinates
-     * @returns Position in screen coordinates (pixels)
-     *
-     * @example
-     * const screenPos = camera.worldToScreen(circle.position);
-     * console.log(`Circle is at pixel (${screenPos.x}, ${screenPos.y})`);
-     */
-    worldToScreen(pos: Vector2): Vector2;
-    /**
-     * Transforms a screen-space (pixel) position to world coordinates.
-     * This is the inverse of worldToScreen.
-     *
-     * @param pos - Position in screen coordinates (pixels, origin at top-left)
-     * @returns Position in world coordinates
-     *
-     * @example
-     * // Convert a mouse click position to world coordinates
-     * const worldPos = camera.screenToWorld(new Vector2(mouseX, mouseY));
-     */
-    screenToWorld(pos: Vector2): Vector2;
-    /**
-     * Checks if a world-space position is currently visible within the camera frame.
-     *
-     * @param pos - Position in world coordinates to check
-     * @returns True if the position is within the visible frame bounds
-     *
-     * @example
-     * if (camera.isInView(object.position)) {
-     *   console.log('Object is visible');
-     * }
-     */
-    isInView(pos: Vector2): boolean;
-    reset(): this;
-}

package/dist/core/camera/Camera.js

@@ -1,175 +0,0 @@
-import { Vector2 } from '../math/Vector2/Vector2';
-import { Matrix3x3 } from '../math/matrix/Matrix3x3';
-import { CameraFrame } from './CameraFrame';
-import { MANIM_FRAME_HEIGHT } from './types';
-/**
- * Camera manages the view into the scene.
- * Uses CameraFrame (a Mobject) to store transform state, enabling camera animations.
- *
- * The Camera provides both instant manipulation methods (panTo, zoomTo) and
- * access to the CameraFrame for fluent animation APIs.
- *
- * @example
- * // Instant camera manipulation
- * camera.zoomTo(2);
- * camera.panTo(new Vector2(5, 3));
- *
- * @example
- * // Animated camera movement via frame
- * this.play(this.frame.zoomIn(2).duration(1));
- * this.play(this.frame.centerOn(circle).duration(0.5));
- */
-export class Camera {
-    config;
-    /** The CameraFrame that stores the camera's transform state. Use this for animations. */
-    frame;
-    /**
-     * Creates a new Camera with the specified viewport dimensions.
-     *
-     * @param config - Configuration options
-     * @param config.pixelWidth - Width of the viewport in pixels (default: 1920)
-     * @param config.pixelHeight - Height of the viewport in pixels (default: 1080)
-     */
-    constructor(config = {}) {
-        this.config = {
-            pixelWidth: config.pixelWidth ?? 1920,
-            pixelHeight: config.pixelHeight ?? 1080,
-        };
-        this.frame = new CameraFrame({
-            pixelWidth: this.config.pixelWidth,
-            pixelHeight: this.config.pixelHeight,
-        });
-    }
-    // ========== Frame Dimensions (Manim-compatible) ==========
-    get frameHeight() {
-        return MANIM_FRAME_HEIGHT;
-    }
-    get frameWidth() {
-        const aspectRatio = this.config.pixelWidth / this.config.pixelHeight;
-        return MANIM_FRAME_HEIGHT * aspectRatio;
-    }
-    get frameYRadius() {
-        return this.frameHeight / 2;
-    }
-    get frameXRadius() {
-        return this.frameWidth / 2;
-    }
-    // ========== Pixel Dimensions ==========
-    get pixelWidth() {
-        return this.config.pixelWidth;
-    }
-    get pixelHeight() {
-        return this.config.pixelHeight;
-    }
-    // ========== Camera Transform Properties (read from frame) ==========
-    get position() {
-        return this.frame.position;
-    }
-    get zoom() {
-        return 1 / this.frame.scale.x;
-    }
-    get rotation() {
-        return this.frame.rotation;
-    }
-    // ========== Pan Operations (proxy to frame) ==========
-    pan(delta) {
-        const current = this.frame.position;
-        this.frame.pos(current.x + delta.x, current.y + delta.y);
-        return this;
-    }
-    panTo(position) {
-        this.frame.pos(position.x, position.y);
-        return this;
-    }
-    // ========== Zoom Operations (proxy to frame) ==========
-    zoomTo(level) {
-        if (level <= 0) {
-            throw new Error('Zoom level must be positive');
-        }
-        const frameScale = 1 / level;
-        this.frame.setScale(frameScale, frameScale);
-        return this;
-    }
-    // ========== Rotation Operations (proxy to frame) ==========
-    rotateTo(angle) {
-        this.frame.setRotation(angle);
-        return this;
-    }
-    // ========== View Matrix ==========
-    getViewMatrix() {
-        const framePos = this.frame.position;
-        const frameScale = this.frame.scale;
-        const frameRotation = this.frame.rotation;
-        const zoomX = 1 / frameScale.x;
-        const zoomY = 1 / frameScale.y;
-        const translate = Matrix3x3.translation(-framePos.x, -framePos.y);
-        const rotate = Matrix3x3.rotation(-frameRotation);
-        const scale = Matrix3x3.scale(zoomX, zoomY);
-        return scale.multiply(rotate).multiply(translate);
-    }
-    // ========== Coordinate Transforms ==========
-    /**
-     * Transforms a world-space position to screen-space (pixel) coordinates.
-     *
-     * Screen coordinates have origin at top-left, with x increasing right
-     * and y increasing downward.
-     *
-     * @param pos - Position in world coordinates
-     * @returns Position in screen coordinates (pixels)
-     *
-     * @example
-     * const screenPos = camera.worldToScreen(circle.position);
-     * console.log(`Circle is at pixel (${screenPos.x}, ${screenPos.y})`);
-     */
-    worldToScreen(pos) {
-        const viewMatrix = this.getViewMatrix();
-        const transformed = viewMatrix.transformPoint(pos);
-        const screenX = (transformed.x + 1) * 0.5 * this.config.pixelWidth;
-        const screenY = (1 - transformed.y) * 0.5 * this.config.pixelHeight;
-        return new Vector2(screenX, screenY);
-    }
-    /**
-     * Transforms a screen-space (pixel) position to world coordinates.
-     * This is the inverse of worldToScreen.
-     *
-     * @param pos - Position in screen coordinates (pixels, origin at top-left)
-     * @returns Position in world coordinates
-     *
-     * @example
-     * // Convert a mouse click position to world coordinates
-     * const worldPos = camera.screenToWorld(new Vector2(mouseX, mouseY));
-     */
-    screenToWorld(pos) {
-        const ndcX = (pos.x / this.config.pixelWidth) * 2 - 1;
-        const ndcY = 1 - (pos.y / this.config.pixelHeight) * 2;
-        const viewMatrix = this.getViewMatrix();
-        const inverseView = viewMatrix.inverse();
-        return inverseView.transformPoint(new Vector2(ndcX, ndcY));
-    }
-    /**
-     * Checks if a world-space position is currently visible within the camera frame.
-     *
-     * @param pos - Position in world coordinates to check
-     * @returns True if the position is within the visible frame bounds
-     *
-     * @example
-     * if (camera.isInView(object.position)) {
-     *   console.log('Object is visible');
-     * }
-     */
-    isInView(pos) {
-        const framePos = this.frame.position;
-        const halfWidth = this.frame.width / 2;
-        const halfHeight = this.frame.height / 2;
-        return (pos.x >= framePos.x - halfWidth &&
-            pos.x <= framePos.x + halfWidth &&
-            pos.y >= framePos.y - halfHeight &&
-            pos.y <= framePos.y + halfHeight);
-    }
-    reset() {
-        this.frame.pos(0, 0);
-        this.frame.setScale(1, 1);
-        this.frame.setRotation(0);
-        return this;
-    }
-}