@mihirsarya/manim-scroll-next 0.1.1 → 0.1.3

package/dist/renderer.js

@@ -55,10 +55,16 @@ function findCliPath(providedPath) {
         return providedPath;
     }
     // Try to find the CLI relative to the package
+    // When installed, __dirname is next/dist/, render is at next/render/
     const candidates = [
+        // When running from dist/, render/ is a sibling directory
+        path.resolve(__dirname, "../render/cli.py"),
+        // Legacy paths for development
         path.resolve(__dirname, "../../render/cli.py"),
         path.resolve(__dirname, "../../../render/cli.py"),
+        // When running from project root
         path.resolve(process.cwd(), "render/cli.py"),
+        // When installed in node_modules
         path.resolve(process.cwd(), "node_modules/@mihirsarya/manim-scroll-next/render/cli.py"),
     ];
     for (const candidate of candidates) {
@@ -75,10 +81,16 @@ function findTemplatesDir(providedPath) {
     if (providedPath) {
         return providedPath;
     }
+    // When installed, __dirname is next/dist/, templates are at next/render/templates/
     const candidates = [
+        // When running from dist/, render/ is a sibling directory
+        path.resolve(__dirname, "../render/templates"),
+        // Legacy paths for development
         path.resolve(__dirname, "../../render/templates"),
         path.resolve(__dirname, "../../../render/templates"),
+        // When running from project root
         path.resolve(process.cwd(), "render/templates"),
+        // When installed in node_modules
         path.resolve(process.cwd(), "node_modules/@mihirsarya/manim-scroll-next/render/templates"),
     ];
     for (const candidate of candidates) {

package/package.json

@@ -1,12 +1,18 @@
 {
   "name": "@mihirsarya/manim-scroll-next",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Next.js plugin for build-time Manim scroll animation rendering.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
-    "dist"
+    "dist",
+    "render"
   ],
+  "scripts": {
+    "prebuild": "rm -rf render && cp -r ../render .",
+    "build": "tsc -p tsconfig.json",
+    "prepublishOnly": "rm -rf render && cp -r ../render . && npm run build"
+  },
   "peerDependencies": {
     "next": ">=13.0.0"
   },
@@ -20,8 +26,5 @@
     "@types/babel__traverse": "^7.20.5",
     "@types/node": "^20.11.0",
     "typescript": "^5.4.5"
-  },
-  "scripts": {
-    "build": "tsc -p tsconfig.json"
   }
-}
+}

package/render/cli.py

@@ -0,0 +1,115 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import subprocess
+import sys
+from dataclasses import dataclass, asdict
+from pathlib import Path
+from typing import List, Optional
+
+
+@dataclass
+class RenderManifest:
+    scene: str
+    fps: int
+    width: int
+    height: int
+    frames: List[str]
+    video: Optional[str]
+
+
+def _parse_resolution(value: str) -> tuple[int, int]:
+    if "x" in value:
+        w, h = value.split("x", 1)
+    elif "," in value:
+        w, h = value.split(",", 1)
+    else:
+        raise argparse.ArgumentTypeError("Resolution must be WxH or W,H")
+    return int(w), int(h)
+
+
+def _find_latest(files: List[Path]) -> Optional[Path]:
+    if not files:
+        return None
+    return max(files, key=lambda p: p.stat().st_mtime)
+
+
+def _collect_assets(media_dir: Path) -> tuple[List[str], Optional[str]]:
+    frames = sorted(
+        [p.relative_to(media_dir).as_posix() for p in media_dir.rglob("*.png")]
+    )
+    video = _find_latest([*media_dir.rglob("*.mp4"), *media_dir.rglob("*.webm")])
+    return frames, video.relative_to(media_dir).as_posix() if video else None
+
+
+def _run_manim(cmd: List[str], env: dict[str, str]) -> None:
+    result = subprocess.run(cmd, check=False, env=env)
+    if result.returncode != 0:
+        raise RuntimeError("Manim render failed. Check the command and logs.")
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Render Manim scenes for scroll playback.")
+    parser.add_argument("--scene-file", required=True, help="Path to Manim scene file.")
+    parser.add_argument("--scene-name", required=True, help="Scene class name.")
+    parser.add_argument("--output-dir", required=True, help="Directory for render outputs.")
+    parser.add_argument("--format", choices=["frames", "video", "both"], default="both")
+    parser.add_argument("--fps", type=int, default=30)
+    parser.add_argument("--resolution", type=_parse_resolution, default=(1920, 1080))
+    parser.add_argument("--quality", default="k", help="Manim quality preset (l, m, h, k).")
+    parser.add_argument("--video-format", choices=["mp4", "webm"], default="mp4")
+    parser.add_argument(
+        "--props",
+        help="Path to JSON props for the scene (exposed as MANIM_SCROLL_PROPS).",
+    )
+
+    args = parser.parse_args()
+    output_dir = Path(args.output_dir).resolve()
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    width, height = args.resolution
+    base_cmd = [
+        "manim",
+        f"-q{args.quality}",
+        "--media_dir",
+        str(output_dir),
+        "--fps",
+        str(args.fps),
+        "--resolution",
+        f"{width},{height}",
+        args.scene_file,
+        args.scene_name,
+    ]
+
+    env = os.environ.copy()
+    if args.props:
+        props_path = Path(args.props).resolve()
+        env["MANIM_SCROLL_PROPS"] = str(props_path)
+
+    if args.format in ("frames", "both"):
+        _run_manim(base_cmd + ["--write_all_frames", "--format", "png"], env)
+
+    if args.format in ("video", "both"):
+        _run_manim(base_cmd + ["--format", args.video_format], env)
+
+    frames, video = _collect_assets(output_dir)
+    manifest = RenderManifest(
+        scene=args.scene_name,
+        fps=args.fps,
+        width=width,
+        height=height,
+        frames=frames,
+        video=video,
+    )
+    manifest_path = output_dir / "manifest.json"
+    manifest_path.write_text(json.dumps(asdict(manifest), indent=2))
+
+    print(f"Wrote manifest to {manifest_path}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/render/pyproject.toml

@@ -0,0 +1,14 @@
+[project]
+name = "manim-scroll-render"
+version = "0.1.0"
+description = "Render pipeline for Manim scroll animations."
+requires-python = ">=3.10"
+dependencies = [
+  "manim>=0.18.0"
+]
+
+[project.scripts]
+manim-scroll-render = "cli:main"
+
+[tool.setuptools]
+py-modules = ["cli"]

package/render/templates/text_scene.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+
+from manim import ORIGIN, Scene, Text, Write
+
+
+def _load_props() -> dict:
+    props_path = os.environ.get("MANIM_SCROLL_PROPS")
+    if not props_path:
+        return {}
+    path = Path(props_path)
+    if not path.exists():
+        return {}
+    with path.open("r", encoding="utf-8") as handle:
+        return json.load(handle)
+
+
+class TextScene(Scene):
+    def construct(self) -> None:
+        props = _load_props()
+        text_value = props.get("text", "Hello Manim")
+        font_size = props.get("fontSize", props.get("font_size", 64))
+        color = props.get("color", "#FFFFFF")
+        font = props.get("font")
+
+        if font:
+            text_mob = Text(text_value, font_size=font_size, color=color, font=font)
+        else:
+            text_mob = Text(text_value, font_size=font_size, color=color)
+
+        text_mob.move_to(ORIGIN)
+        self.play(Write(text_mob))
+        self.wait(0.5)