manim-web 0.3.5 → 0.3.7

package/dist/core/LinearTransformationScene.d.ts

@@ -0,0 +1,152 @@
+import { Scene, SceneOptions } from './Scene';
+import { Mobject, Vector3Tuple } from './Mobject';
+/**
+ * Options for configuring a LinearTransformationScene.
+ */
+export interface LinearTransformationSceneOptions extends SceneOptions {
+    /** X-axis range as [min, max, step]. Defaults to [-5, 5, 1]. */
+    xRange?: [number, number, number];
+    /** Y-axis range as [min, max, step]. Defaults to [-5, 5, 1]. */
+    yRange?: [number, number, number];
+    /** Visual length of the x-axis. Defaults to 10. */
+    xLength?: number;
+    /** Visual length of the y-axis. Defaults to 10. */
+    yLength?: number;
+    /** Color for the i basis vector. Defaults to green. */
+    iColor?: string;
+    /** Color for the j basis vector. Defaults to red. */
+    jColor?: string;
+    /** Whether to show basis vectors by default. Defaults to true. */
+    showBasisVectors?: boolean;
+    /** Color for background grid lines. Defaults to '#555555'. */
+    gridColor?: string;
+}
+/**
+ * Matrix type for 2D linear transformations.
+ * Represented as [[a, b], [c, d]] where the matrix is:
+ * | a  b |
+ * | c  d |
+ */
+export type Matrix2D = [[number, number], [number, number]];
+/**
+ * Scene for linear algebra visualizations.
+ * Shows basis vectors and a grid that transforms with matrices.
+ */
+export declare class LinearTransformationScene extends Scene {
+    private _xRange;
+    private _yRange;
+    private _xLength;
+    private _yLength;
+    private _iColor;
+    private _jColor;
+    private _gridColor;
+    private _grid;
+    private _iVector;
+    private _jVector;
+    private _transformableObjects;
+    private _currentMatrix;
+    private _showBasisVectors;
+    /**
+     * Create a new linear transformation scene.
+     * @param container - DOM element to render into
+     * @param options - Scene configuration options
+     */
+    constructor(container: HTMLElement, options?: LinearTransformationSceneOptions);
+    /**
+     * Set up the background grid.
+     */
+    private _setupGrid;
+    /**
+     * Set up the basis vectors.
+     */
+    private _setupBasisVectors;
+    /**
+     * Convert x coordinate to visual x position.
+     */
+    private _coordToVisualX;
+    /**
+     * Convert y coordinate to visual y position.
+     */
+    private _coordToVisualY;
+    /**
+     * Convert graph coordinates to visual point coordinates.
+     * @param x - X coordinate in graph space
+     * @param y - Y coordinate in graph space
+     * @returns The visual point [x, y, z]
+     */
+    coordsToPoint(x: number, y: number): Vector3Tuple;
+    /**
+     * Convert visual point to graph coordinates.
+     * @param point - Visual point [x, y, z]
+     * @returns Graph coordinates [x, y]
+     */
+    pointToCoords(point: Vector3Tuple): [number, number];
+    /**
+     * Get the i basis vector mobject.
+     */
+    get iVector(): Mobject | null;
+    /**
+     * Get the j basis vector mobject.
+     */
+    get jVector(): Mobject | null;
+    /**
+     * Get the background grid mobject.
+     */
+    get grid(): Mobject | null;
+    /**
+     * Get the current transformation matrix.
+     */
+    get currentMatrix(): Matrix2D;
+    /**
+     * Apply a matrix transformation to all transformable objects.
+     * @param matrix - 2D transformation matrix [[a, b], [c, d]]
+     * @returns this for chaining
+     */
+    applyMatrix(matrix: Matrix2D): this;
+    /**
+     * Reset the transformation to identity.
+     * @returns this for chaining
+     */
+    resetTransformation(): this;
+    /**
+     * Rebuild the scene from scratch.
+     */
+    private _rebuildScene;
+    /**
+     * Add a vector to the scene that will transform with the matrix.
+     * @param vector - Vector coordinates [x, y]
+     * @param options - Optional configuration
+     * @returns The created vector mobject
+     */
+    addVector(vector: [number, number], options?: {
+        color?: string;
+        addToTransformable?: boolean;
+    }): Mobject;
+    /**
+     * Add a mobject (such as a label or shape) that will transform with the matrix.
+     * Use this to add any mobject that should participate in linear transformations.
+     * @param mobject - The mobject to add
+     * @param position - Optional position [x, y] in graph coordinates
+     * @returns The added mobject
+     */
+    addTransformableLabel(mobject: Mobject, position?: [number, number]): Mobject;
+    /**
+     * Get the origin point in visual coordinates.
+     */
+    getOrigin(): Vector3Tuple;
+    /**
+     * Show the basis vectors if hidden.
+     * @returns this for chaining
+     */
+    showBasisVectors(): this;
+    /**
+     * Hide the basis vectors.
+     * @returns this for chaining
+     */
+    hideBasisVectors(): this;
+    /**
+     * Clean up all resources.
+     */
+    dispose(): void;
+}
+//# sourceMappingURL=LinearTransformationScene.d.ts.map

package/dist/core/LinearTransformationScene.d.ts.map

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

package/dist/core/Mobject.d.ts

@@ -1,247 +1,66 @@
+import { Vector3Tuple, UpdaterFunction, MobjectStyle } from './MobjectTypes';
 import * as THREE from 'three';
-/**
- * Vector3 type as a tuple for external API
- */
-export type Vector3Tuple = [number, number, number];
-export declare const UP: Vector3Tuple;
-export declare const DOWN: Vector3Tuple;
-export declare const LEFT: Vector3Tuple;
-export declare const RIGHT: Vector3Tuple;
-export declare const OUT: Vector3Tuple;
-export declare const IN: Vector3Tuple;
-export declare const ORIGIN: Vector3Tuple;
-export declare const UL: Vector3Tuple;
-export declare const UR: Vector3Tuple;
-export declare const DL: Vector3Tuple;
-export declare const DR: Vector3Tuple;
-/**
- * Updater function type that runs every frame
- * @param mobject - The mobject being updated
- * @param dt - Delta time in seconds since last frame
- */
-export type UpdaterFunction = (mobject: Mobject, dt: number) => void;
-/**
- * Style properties for mobjects
- */
-export interface MobjectStyle {
-    fillColor?: string;
-    fillOpacity?: number;
-    strokeColor?: string;
-    strokeOpacity?: number;
-    strokeWidth?: number;
-}
-/**
- * Base mathematical object class.
- * All visible objects in manimweb inherit from this class.
- */
+export { type Vector3Tuple, type UpdaterFunction, type MobjectStyle, type VMobjectLike, isVMobjectLike, UP, DOWN, LEFT, RIGHT, OUT, IN, ORIGIN, UL, UR, DL, DR, } from './MobjectTypes';
+/** Base mathematical object class. All visible objects in manimweb inherit from this class. */
 export declare abstract class Mobject {
-    /** Unique identifier for this mobject */
     readonly id: string;
-    /** Parent mobject in hierarchy */
     parent: Mobject | null;
-    /** Child mobjects */
     children: Mobject[];
-    /** Position in 3D space */
     position: THREE.Vector3;
-    /** Rotation as Euler angles */
     rotation: THREE.Euler;
-    /** Scale factors (named scaleVector to avoid conflict with scale method) */
     scaleVector: THREE.Vector3;
-    /** Color as CSS color string (syncs stroke and fill via setter) */
     protected _color: string;
     get color(): string;
     set color(value: string);
-    /** Overall opacity (0-1) - protected for backward compatibility */
     protected _opacity: number;
-    /** Stroke width for outlines (default 4, matching Manim's thicker strokes) */
     strokeWidth: number;
-    /** Fill opacity (0-1) */
     fillOpacity: number;
-    /** When true, children skip the 2D z-layering offset in _syncToThree.
-     *  Set this on 3D container objects (e.g. ThreeDAxes) where z-offsets
-     *  would shift objects away from their intended 3D positions. */
+    /** When true, children skip the 2D z-layering offset in _syncToThree. */
     protected _disableChildZLayering: boolean;
-    /** Style properties for backward compatibility */
     protected _style: MobjectStyle;
-    /** Three.js backing object */
     _threeObject: THREE.Object3D | null;
-    /** Dirty flag indicating transforms need sync */
     _dirty: boolean;
-    /** Updater functions that run every frame */
     private _updaters;
-    /**
-     * Saved mobject copy (used by Restore animation in TransformExtensions).
-     * Set by saveState().
-     */
+    /** Saved mobject copy (used by Restore animation). Set by saveState(). */
     savedState: Mobject | null;
-    /**
-     * Target copy used by generateTarget() / MoveToTarget animation.
-     * Call generateTarget() to create a copy, modify targetCopy, then
-     * play MoveToTarget to interpolate from current to target state.
-     */
+    /** Target copy used by generateTarget() / MoveToTarget animation. */
     targetCopy: Mobject | null;
-    /**
-     * JSON-serializable saved state (used by restoreState()).
-     * Set by saveState() -- typed as `unknown` here to avoid circular import;
-     * actual type is MobjectState from StateManager.ts.
-     */
+    /** JSON-serializable saved state (used by restoreState()). */
     __savedMobjectState: unknown;
     private static _idCounter;
-    private static _tempVec3;
-    private static _tempBox3;
-    private static _tempQuaternion;
     constructor();
-    /**
-     * Get the overall opacity of the mobject
-     */
     get opacity(): number;
-    /**
-     * Set the overall opacity of the mobject
-     */
     set opacity(value: number);
-    /**
-     * Get the style properties
-     */
     get style(): MobjectStyle;
-    /**
-     * Set style properties
-     */
     setStyle(style: Partial<MobjectStyle>): this;
-    /**
-     * Get all submobjects (alias for children)
-     */
     get submobjects(): Mobject[];
-    /**
-     * Translate the mobject by a delta
-     * @param delta - Translation vector [x, y, z]
-     * @returns this for chaining
-     */
+    setColor(color: string): this;
+    setOpacity(opacity: number): this;
+    setStrokeWidth(width: number): this;
+    setFillOpacity(opacity: number): this;
+    setFill(color?: string, opacity?: number): this;
+    get fillColor(): string | undefined;
+    set fillColor(color: string);
     shift(delta: Vector3Tuple): this;
-    /**
-     * Move the mobject to an absolute position, or align with another Mobject.
-     * @param target - Target position [x, y, z] or Mobject to align with
-     * @param alignedEdge - Optional edge direction to align (e.g., UL aligns upper-left edges)
-     * @returns this for chaining
-     */
     moveTo(target: Vector3Tuple | Mobject, alignedEdge?: Vector3Tuple): this;
     /**
-     * Rotate the mobject around an axis
-     * Uses object pooling to avoid allocations in hot paths (performance optimization).
-     * @param angle - Rotation angle in radians
-     * @param axisOrOptions - Axis of rotation [x, y, z] (defaults to Z axis), or options object
-     * @returns this for chaining
+     * Rotate the mobject around an axis.
+     * Delegates to rotateMobject for the heavy lifting.
      */
     rotate(angle: number, axisOrOptions?: Vector3Tuple | {
         axis?: Vector3Tuple;
         aboutPoint?: Vector3Tuple;
     }): this;
-    /**
-     * Rotate the mobject about the coordinate origin [0, 0, 0].
-     * @param angle - Rotation angle in radians
-     * @param axis - Axis of rotation (defaults to Z axis [0, 0, 1])
-     * @returns this for chaining
-     */
     rotateAboutOrigin(angle: number, axis?: Vector3Tuple): this;
-    /**
-     * Flip the mobject along an axis (mirror reflection).
-     * @param axis - Axis to flip across, defaults to RIGHT ([1,0,0]) for horizontal flip
-     * @returns this for chaining
-     */
     flip(axis?: Vector3Tuple): this;
-    /**
-     * Scale the mobject uniformly or non-uniformly
-     * @param factor - Scale factor (number for uniform, tuple for non-uniform)
-     * @returns this for chaining
-     */
     scale(factor: number | Vector3Tuple): this;
-    /**
-     * Set the mobject's color
-     * Only marks dirty if value actually changed (performance optimization).
-     * @param color - CSS color string
-     * @returns this for chaining
-     */
-    setColor(color: string): this;
-    /**
-     * Set the mobject's overall opacity
-     * Only marks dirty if value actually changed (performance optimization).
-     * @param opacity - Opacity value (0-1)
-     * @returns this for chaining
-     */
-    setOpacity(opacity: number): this;
-    /**
-     * Set the stroke width for outlines
-     * Only marks dirty if value actually changed (performance optimization).
-     * @param width - Stroke width in pixels
-     * @returns this for chaining
-     */
-    setStrokeWidth(width: number): this;
-    /**
-     * Set the fill opacity
-     * Only marks dirty if value actually changed (performance optimization).
-     * @param opacity - Fill opacity (0-1)
-     * @returns this for chaining
-     */
-    setFillOpacity(opacity: number): this;
-    /**
-     * Set the fill color and/or opacity (Manim Python parity: set_fill)
-     * @param color - CSS color string (optional)
-     * @param opacity - Fill opacity 0-1 (optional)
-     * @returns this for chaining
-     */
-    setFill(color?: string, opacity?: number): this;
-    /**
-     * Get the fill color
-     */
-    get fillColor(): string | undefined;
-    /**
-     * Set the fill color
-     */
-    set fillColor(color: string);
-    /**
-     * Add a child mobject (supports multiple arguments for backward compatibility)
-     * @param mobjects - Child mobjects to add
-     * @returns this for chaining
-     */
     add(...mobjects: Mobject[]): this;
-    /**
-     * Remove a child mobject (supports multiple arguments for backward compatibility)
-     * @param mobjects - Child mobjects to remove
-     * @returns this for chaining
-     */
     remove(...mobjects: Mobject[]): this;
-    /**
-     * Create a deep copy of this mobject
-     * @returns New mobject with copied properties
-     */
     copy(): Mobject;
-    /**
-     * Replace this mobject's visual properties with those of another mobject.
-     * Preserves identity (updaters, scene membership) but copies appearance.
-     * @param other - The mobject to copy appearance from
-     * @returns this for chaining
-     */
+    protected abstract _createCopy(): Mobject;
     become(other: Mobject): this;
-    /**
-     * Scale and reposition this mobject to match another mobject's bounding box.
-     * Matches Manim Python's replace() behavior.
-     * @param target - The mobject whose bounding box to match
-     * @param stretch - If true, stretch per-axis to match exactly; if false (default), uniform scale to match width
-     * @returns this for chaining
-     */
     replace(target: Mobject, stretch?: boolean): this;
-    /**
-     * Create a new instance for copying. Subclasses must implement this.
-     */
-    protected abstract _createCopy(): Mobject;
-    /**
-     * Get the center point of this mobject
-     * @returns Center position as [x, y, z]
-     */
     getCenter(): Vector3Tuple;
-    /**
-     * Get the bounding box of this mobject in world coordinates.
-     * @returns Object with min and max Vector3Tuple
-     */
     getBounds(): {
         min: {
             x: number;
@@ -254,234 +73,52 @@ export declare abstract class Mobject {
             z: number;
         };
     };
-    /**
-     * Position this mobject next to another mobject
-     * @param target The mobject to position next to
-     * @param direction Direction from target (e.g., RIGHT, UP)
-     * @param buff Buffer distance between mobjects, default 0.25
-     * @returns this for chaining
-     */
     nextTo(target: Mobject | Vector3Tuple, direction?: Vector3Tuple, buff?: number): this;
-    /**
-     * Align this mobject with another along an edge
-     * @param target The mobject or point to align with
-     * @param direction The direction/edge to align (e.g., LEFT aligns left edges)
-     * @returns this for chaining
-     */
     alignTo(target: Mobject | Vector3Tuple, direction: Vector3Tuple): this;
-    /**
-     * Move this mobject to align its center with a point or mobject center
-     * @param target Target mobject or point to align with
-     * @param alignedEdge Optional edge to align instead of centers
-     * @returns this for chaining
-     */
     moveToAligned(target: Mobject | Vector3Tuple, alignedEdge?: Vector3Tuple): this;
-    /**
-     * Get the edge point of the bounding box in a direction
-     * @param direction Direction to get edge in
-     * @returns Edge point as [x, y, z]
-     */
     _getEdgeInDirection(direction: Vector3Tuple): Vector3Tuple;
-    /**
-     * Get bounding box dimensions
-     * Uses object pooling to avoid allocations in hot paths (performance optimization).
-     * @returns Object with width, height, and depth
-     */
-    protected _getBoundingBox(): {
+    getBoundingBox(): {
+        width: number;
+        height: number;
+        depth: number;
+    };
+    /** @deprecated Use getBoundingBox() instead. */
+    _getBoundingBox(): {
         width: number;
         height: number;
         depth: number;
     };
-    /**
-     * Get a specific edge point of the bounding box in a direction
-     * @param direction Direction to the edge point
-     * @returns Edge point as [x, y, z]
-     */
     getEdge(direction: Vector3Tuple): Vector3Tuple;
-    /**
-     * Get the top edge center
-     * @returns Top edge center as [x, y, z]
-     */
     getTop(): Vector3Tuple;
-    /**
-     * Get the bottom edge center
-     * @returns Bottom edge center as [x, y, z]
-     */
     getBottom(): Vector3Tuple;
-    /**
-     * Get the left edge center
-     * @returns Left edge center as [x, y, z]
-     */
     getLeft(): Vector3Tuple;
-    /**
-     * Get the right edge center
-     * @returns Right edge center as [x, y, z]
-     */
     getRight(): Vector3Tuple;
-    /**
-     * Set the x-coordinate of this mobject's center, preserving y and z.
-     * Matches Manim Python's set_x() behavior.
-     */
     setX(x: number): this;
-    /**
-     * Set the y-coordinate of this mobject's center, preserving x and z.
-     * Matches Manim Python's set_y() behavior.
-     */
     setY(y: number): this;
-    /**
-     * Set the z-coordinate of this mobject's center, preserving x and y.
-     * Matches Manim Python's set_z() behavior.
-     */
     setZ(z: number): this;
-    /**
-     * Center this mobject at origin
-     * @returns this for chaining
-     */
     center(): this;
-    /**
-     * Move to the edge of the frame
-     * @param direction Direction to move towards
-     * @param buff Buffer from edge
-     * @returns this for chaining
-     */
-    toEdge(direction: Vector3Tuple, buff?: number): this;
-    /**
-     * Move to a corner of the frame
-     * @param direction Corner direction (e.g., UR for upper right)
-     * @param buff Buffer from edges
-     * @returns this for chaining
-     */
-    toCorner(direction?: Vector3Tuple, buff?: number): this;
-    /**
-     * Sync transform properties to the Three.js object
-     */
+    toEdge(direction: Vector3Tuple, buff?: number, frameDimensions?: [number, number]): this;
+    toCorner(direction?: Vector3Tuple, buff?: number, frameDimensions?: [number, number]): this;
     _syncToThree(): void;
-    /**
-     * Sync material-specific properties. Override in subclasses.
-     */
     protected _syncMaterialToThree(): void;
-    /**
-     * Mark this mobject as needing sync
-     */
     _markDirty(): void;
-    /**
-     * Mark this mobject and all ancestors as needing sync.
-     * Use when a deep child's geometry changes and the parent tree must re-traverse.
-     * Short-circuits if this node is already dirty (ancestors must be dirty too).
-     */
     _markDirtyUpward(): void;
-    /**
-     * Check if this mobject needs sync
-     */
     get isDirty(): boolean;
-    /**
-     * Get the Three.js object, creating it if necessary
-     */
     getThreeObject(): THREE.Object3D;
-    /**
-     * Create the Three.js backing object. Subclasses must implement.
-     */
     protected abstract _createThreeObject(): THREE.Object3D;
-    /**
-     * Apply a function to this mobject and all descendants
-     */
     applyToFamily(func: (mobject: Mobject) => void): this;
-    /**
-     * Get all mobjects in the family (this mobject and all descendants)
-     */
     getFamily(): Mobject[];
-    /**
-     * Add an updater function that runs every frame
-     * @param updater Function called with (mobject, dt) each frame
-     * @param callOnAdd Whether to call immediately, default false
-     * @returns this for chaining
-     */
     addUpdater(updater: UpdaterFunction, callOnAdd?: boolean): this;
-    /**
-     * Remove an updater function
-     * @param updater The updater function to remove
-     * @returns this for chaining
-     */
     removeUpdater(updater: UpdaterFunction): this;
-    /**
-     * Remove all updaters
-     * @returns this for chaining
-     */
     clearUpdaters(): this;
-    /**
-     * Check if this mobject has any updaters
-     * @returns true if the mobject has updaters
-     */
     hasUpdaters(): boolean;
-    /**
-     * Get all updaters (for internal use)
-     * @returns A copy of the updaters array
-     */
     getUpdaters(): UpdaterFunction[];
-    /**
-     * Run all updaters with given dt
-     * Called by Scene during render loop
-     * @param dt Delta time in seconds since last frame
-     */
     update(dt: number): void;
-    /**
-     * Apply a point-wise function to every VMobject descendant's control points.
-     * Uses duck-type check for getPoints/setPoints to avoid circular imports.
-     * @param fn - Function mapping [x, y, z] to [x', y', z']
-     * @returns this for chaining
-     */
     applyFunction(fn: (point: number[]) => number[]): this;
-    /**
-     * Subdivide every VMobject descendant's cubic Bezier curves so that non-linear
-     * transforms produce smooth results. Each cubic segment is split into n sub-segments
-     * via de Casteljau evaluation.
-     * @param numPieces - Number of sub-segments per original cubic segment (default 50)
-     * @returns this for chaining
-     */
     prepareForNonlinearTransform(numPieces?: number): this;
-    /**
-     * Create a copy of this mobject as a target for MoveToTarget animation.
-     * Modify the returned copy, then play `new MoveToTarget(this)` to
-     * smoothly interpolate from the current state to the target.
-     *
-     * @returns The target copy for modification
-     *
-     * @example
-     * ```ts
-     * mob.generateTarget();
-     * mob.targetCopy!.shift([2, 0, 0]);
-     * mob.targetCopy!.setColor('red');
-     * await scene.play(new MoveToTarget(mob));
-     * ```
-     */
     generateTarget(): Mobject;
-    /**
-     * Save the current state of this mobject so it can be restored later.
-     * Stores a deep copy on `this.savedState` (for Restore animation
-     * compatibility) and a serializable snapshot on `this.__savedMobjectState`
-     * (for restoreState).
-     *
-     * @returns this for chaining
-     *
-     * @example
-     * ```ts
-     * mob.saveState();
-     * mob.shift([2, 0, 0]);
-     * mob.setColor('red');
-     * mob.restoreState(); // back to original position and color
-     * ```
-     */
     saveState(): this;
-    /**
-     * Restore this mobject to its previously saved state (from saveState).
-     * Uses the deep copy stored on `this.savedState` to restore all properties.
-     *
-     * @returns true if state was restored, false if no saved state exists
-     */
     restoreState(): boolean;
-    /**
-     * Clean up Three.js resources.
-     */
     dispose(): void;
 }
 export default Mobject;