@mihirsarya/manim-scroll-next 0.1.1

package/dist/index.js

@@ -0,0 +1,180 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderAnimations = exports.cleanOrphanedCache = exports.readCacheManifest = exports.writeCacheManifest = exports.getAnimationsToRender = exports.getCacheEntry = exports.isCached = exports.computePropsHash = exports.extractAnimations = void 0;
+exports.withManimScroll = withManimScroll;
+exports.processManimScroll = processManimScroll;
+const path = __importStar(require("path"));
+const extractor_1 = require("./extractor");
+const cache_1 = require("./cache");
+const renderer_1 = require("./renderer");
+let hasProcessed = false;
+/**
+ * Process ManimScroll components: extract, cache, and render.
+ */
+async function processManimScroll(projectDir, config) {
+    var _a;
+    if (hasProcessed) {
+        return;
+    }
+    hasProcessed = true;
+    const publicDir = path.join(projectDir, "public");
+    const verbose = (_a = config.verbose) !== null && _a !== void 0 ? _a : false;
+    if (verbose) {
+        console.log("[manim-scroll] Scanning for ManimScroll components...");
+    }
+    // Extract all ManimScroll usages from source files
+    const animations = await (0, extractor_1.extractAnimations)({
+        rootDir: projectDir,
+        include: config.include,
+        exclude: config.exclude,
+    });
+    if (animations.length === 0) {
+        if (verbose) {
+            console.log("[manim-scroll] No ManimScroll components found.");
+        }
+        return;
+    }
+    if (verbose) {
+        console.log(`[manim-scroll] Found ${animations.length} ManimScroll component(s).`);
+        for (const animation of animations) {
+            const hash = (0, cache_1.computePropsHash)(animation.scene, animation.props);
+            console.log(`  - ${animation.id} (hash: ${hash})`);
+        }
+    }
+    // Determine which need rendering
+    const { cached, toRender } = (0, cache_1.getAnimationsToRender)(animations, publicDir);
+    if (verbose && cached.length > 0) {
+        console.log(`[manim-scroll] ${cached.length} animation(s) already cached.`);
+    }
+    // Render new animations
+    if (toRender.length > 0) {
+        console.log(`[manim-scroll] Rendering ${toRender.length} animation(s)...`);
+        const renderOptions = {
+            pythonPath: config.pythonPath,
+            cliPath: config.cliPath,
+            templatesDir: config.templatesDir,
+            concurrency: config.concurrency,
+            fps: config.fps,
+            resolution: config.resolution,
+            quality: config.quality,
+            format: config.format,
+        };
+        const results = await (0, renderer_1.renderAnimations)(toRender, publicDir, renderOptions);
+        const failed = results.filter((r) => !r.success);
+        if (failed.length > 0) {
+            console.error(`[manim-scroll] Warning: ${failed.length} animation(s) failed to render.`);
+        }
+    }
+    else if (verbose) {
+        console.log("[manim-scroll] All animations are cached, skipping render.");
+    }
+    // Write the cache manifest for runtime lookup
+    (0, cache_1.writeCacheManifest)(animations, publicDir);
+    // Clean up orphaned cache entries
+    if (config.cleanOrphans !== false) {
+        (0, cache_1.cleanOrphanedCache)(animations, publicDir);
+    }
+    console.log("[manim-scroll] Build complete.");
+}
+/**
+ * Wrap a Next.js config with ManimScroll build-time processing.
+ *
+ * @example
+ * ```js
+ * // next.config.js
+ * const { withManimScroll } = require("@mihirsarya/manim-scroll-next");
+ *
+ * module.exports = withManimScroll({
+ *   manimScroll: {
+ *     pythonPath: "python3",
+ *     quality: "h",
+ *   },
+ * });
+ * ```
+ */
+function withManimScroll(nextConfig = {}) {
+    var _a;
+    const manimConfig = (_a = nextConfig.manimScroll) !== null && _a !== void 0 ? _a : {};
+    // Remove manimScroll from the config passed to Next.js
+    const { manimScroll: _, ...restConfig } = nextConfig;
+    return {
+        ...restConfig,
+        webpack(config, context) {
+            // Only process on the server build to avoid double processing
+            if (context.isServer && !context.dev) {
+                // Run processing before webpack starts
+                const projectDir = context.dir;
+                // We need to run this synchronously before webpack continues
+                // Using a sync wrapper around the async function
+                const { execSync } = require("child_process");
+                const scriptPath = path.join(__dirname, "process-cli.js");
+                // Check if the CLI script exists, if not we'll inline the processing
+                if (require("fs").existsSync(scriptPath)) {
+                    try {
+                        execSync(`node "${scriptPath}" --project-dir "${projectDir}" --config '${JSON.stringify(manimConfig)}'`, { stdio: "inherit" });
+                    }
+                    catch (error) {
+                        console.error("[manim-scroll] Error during build:", error);
+                    }
+                }
+            }
+            // Run in dev mode on first build
+            if (context.dev && context.isServer) {
+                processManimScroll(context.dir, manimConfig).catch((error) => {
+                    console.error("[manim-scroll] Error during dev processing:", error);
+                });
+            }
+            // Call the original webpack config if provided
+            if (typeof restConfig.webpack === "function") {
+                return restConfig.webpack(config, context);
+            }
+            return config;
+        },
+    };
+}
+// Export types and utilities for advanced usage
+var extractor_2 = require("./extractor");
+Object.defineProperty(exports, "extractAnimations", { enumerable: true, get: function () { return extractor_2.extractAnimations; } });
+var cache_2 = require("./cache");
+Object.defineProperty(exports, "computePropsHash", { enumerable: true, get: function () { return cache_2.computePropsHash; } });
+Object.defineProperty(exports, "isCached", { enumerable: true, get: function () { return cache_2.isCached; } });
+Object.defineProperty(exports, "getCacheEntry", { enumerable: true, get: function () { return cache_2.getCacheEntry; } });
+Object.defineProperty(exports, "getAnimationsToRender", { enumerable: true, get: function () { return cache_2.getAnimationsToRender; } });
+Object.defineProperty(exports, "writeCacheManifest", { enumerable: true, get: function () { return cache_2.writeCacheManifest; } });
+Object.defineProperty(exports, "readCacheManifest", { enumerable: true, get: function () { return cache_2.readCacheManifest; } });
+Object.defineProperty(exports, "cleanOrphanedCache", { enumerable: true, get: function () { return cache_2.cleanOrphanedCache; } });
+var renderer_2 = require("./renderer");
+Object.defineProperty(exports, "renderAnimations", { enumerable: true, get: function () { return renderer_2.renderAnimations; } });

package/dist/process-cli.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+/**
+ * CLI script for processing ManimScroll components.
+ * This is called during the Next.js build process.
+ */
+export {};

package/dist/process-cli.js

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * CLI script for processing ManimScroll components.
+ * This is called during the Next.js build process.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = __importStar(require("path"));
+const extractor_1 = require("./extractor");
+const cache_1 = require("./cache");
+const renderer_1 = require("./renderer");
+async function main() {
+    var _a;
+    const args = process.argv.slice(2);
+    let projectDir = process.cwd();
+    let config = {};
+    // Parse arguments
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--project-dir" && args[i + 1]) {
+            projectDir = args[++i];
+        }
+        else if (arg === "--config" && args[i + 1]) {
+            try {
+                config = JSON.parse(args[++i]);
+            }
+            catch {
+                console.error("Invalid JSON config");
+                process.exit(1);
+            }
+        }
+    }
+    const publicDir = path.join(projectDir, "public");
+    const verbose = (_a = config.verbose) !== null && _a !== void 0 ? _a : false;
+    if (verbose) {
+        console.log("[manim-scroll] Scanning for ManimScroll components...");
+    }
+    // Extract all ManimScroll usages
+    const animations = await (0, extractor_1.extractAnimations)({
+        rootDir: projectDir,
+        include: config.include,
+        exclude: config.exclude,
+    });
+    if (animations.length === 0) {
+        if (verbose) {
+            console.log("[manim-scroll] No ManimScroll components found.");
+        }
+        return;
+    }
+    if (verbose) {
+        console.log(`[manim-scroll] Found ${animations.length} ManimScroll component(s).`);
+        for (const animation of animations) {
+            const hash = (0, cache_1.computePropsHash)(animation.scene, animation.props);
+            console.log(`  - ${animation.id} (hash: ${hash})`);
+        }
+    }
+    // Determine which need rendering
+    const { cached, toRender } = (0, cache_1.getAnimationsToRender)(animations, publicDir);
+    if (verbose && cached.length > 0) {
+        console.log(`[manim-scroll] ${cached.length} animation(s) already cached.`);
+    }
+    // Render new animations
+    if (toRender.length > 0) {
+        console.log(`[manim-scroll] Rendering ${toRender.length} animation(s)...`);
+        const renderOptions = {
+            pythonPath: config.pythonPath,
+            cliPath: config.cliPath,
+            templatesDir: config.templatesDir,
+            concurrency: config.concurrency,
+            fps: config.fps,
+            resolution: config.resolution,
+            quality: config.quality,
+            format: config.format,
+        };
+        const results = await (0, renderer_1.renderAnimations)(toRender, publicDir, renderOptions);
+        const failed = results.filter((r) => !r.success);
+        if (failed.length > 0) {
+            console.error(`[manim-scroll] Warning: ${failed.length} animation(s) failed to render.`);
+        }
+    }
+    else if (verbose) {
+        console.log("[manim-scroll] All animations are cached, skipping render.");
+    }
+    // Write the cache manifest
+    (0, cache_1.writeCacheManifest)(animations, publicDir);
+    // Clean orphans
+    if (config.cleanOrphans !== false) {
+        (0, cache_1.cleanOrphanedCache)(animations, publicDir);
+    }
+    console.log("[manim-scroll] Build complete.");
+}
+main().catch((error) => {
+    console.error("[manim-scroll] Fatal error:", error);
+    process.exit(1);
+});

package/dist/renderer.d.ts

@@ -0,0 +1,30 @@
+import type { ExtractedAnimation } from "./extractor";
+export interface RenderOptions {
+    /** Path to the Python executable */
+    pythonPath?: string;
+    /** Path to the render CLI script */
+    cliPath?: string;
+    /** Path to the scene templates directory */
+    templatesDir?: string;
+    /** Maximum number of parallel renders */
+    concurrency?: number;
+    /** FPS for the animation */
+    fps?: number;
+    /** Resolution in "WIDTHxHEIGHT" format */
+    resolution?: string;
+    /** Manim quality preset (l, m, h, k) */
+    quality?: string;
+    /** Output format (frames, video, both) */
+    format?: string;
+}
+export interface RenderResult {
+    animation: ExtractedAnimation;
+    hash: string;
+    success: boolean;
+    manifestUrl: string;
+    error?: string;
+}
+/**
+ * Render multiple animations in parallel with a concurrency limit.
+ */
+export declare function renderAnimations(animations: ExtractedAnimation[], publicDir: string, options?: RenderOptions): Promise<RenderResult[]>;

package/dist/renderer.js

@@ -0,0 +1,235 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderAnimations = renderAnimations;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const child_process_1 = require("child_process");
+const cache_1 = require("./cache");
+const DEFAULT_OPTIONS = {
+    pythonPath: "python3",
+    concurrency: Math.max(1, os.cpus().length - 1),
+    fps: 30,
+    resolution: "1920x1080",
+    quality: "h",
+    format: "both",
+};
+/**
+ * Find the render CLI path relative to this package.
+ */
+function findCliPath(providedPath) {
+    if (providedPath) {
+        return providedPath;
+    }
+    // Try to find the CLI relative to the package
+    const candidates = [
+        path.resolve(__dirname, "../../render/cli.py"),
+        path.resolve(__dirname, "../../../render/cli.py"),
+        path.resolve(process.cwd(), "render/cli.py"),
+        path.resolve(process.cwd(), "node_modules/@mihirsarya/manim-scroll-next/render/cli.py"),
+    ];
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    throw new Error("Could not find render/cli.py. Please provide the cliPath option or ensure the render directory is accessible.");
+}
+/**
+ * Find the templates directory.
+ */
+function findTemplatesDir(providedPath) {
+    if (providedPath) {
+        return providedPath;
+    }
+    const candidates = [
+        path.resolve(__dirname, "../../render/templates"),
+        path.resolve(__dirname, "../../../render/templates"),
+        path.resolve(process.cwd(), "render/templates"),
+        path.resolve(process.cwd(), "node_modules/@mihirsarya/manim-scroll-next/render/templates"),
+    ];
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    throw new Error("Could not find render/templates directory. Please provide the templatesDir option.");
+}
+/**
+ * Render a single animation using the Python CLI.
+ */
+async function renderAnimation(animation, publicDir, options) {
+    var _a, _b, _c, _d, _e;
+    const hash = (0, cache_1.computePropsHash)(animation.scene, animation.props);
+    const outputDir = (0, cache_1.getOutputDir)(hash, publicDir);
+    const manifestUrl = `/manim-assets/${hash}/manifest.json`;
+    const pythonPath = (_a = options.pythonPath) !== null && _a !== void 0 ? _a : DEFAULT_OPTIONS.pythonPath;
+    const cliPath = findCliPath(options.cliPath);
+    const templatesDir = findTemplatesDir(options.templatesDir);
+    // Ensure output directory exists
+    (0, cache_1.ensureAssetDir)(publicDir);
+    // Create a temp props file
+    const propsFile = path.join(os.tmpdir(), `manim-props-${hash}.json`);
+    fs.writeFileSync(propsFile, JSON.stringify(animation.props, null, 2));
+    // Determine scene file path
+    const sceneFile = path.join(templatesDir, `${animation.scene.toLowerCase().replace("scene", "_scene")}.py`);
+    const actualSceneFile = fs.existsSync(sceneFile)
+        ? sceneFile
+        : path.join(templatesDir, "text_scene.py");
+    const args = [
+        cliPath,
+        "--scene-file",
+        actualSceneFile,
+        "--scene-name",
+        animation.scene,
+        "--output-dir",
+        outputDir,
+        "--format",
+        (_b = options.format) !== null && _b !== void 0 ? _b : DEFAULT_OPTIONS.format,
+        "--fps",
+        String((_c = options.fps) !== null && _c !== void 0 ? _c : DEFAULT_OPTIONS.fps),
+        "--resolution",
+        (_d = options.resolution) !== null && _d !== void 0 ? _d : DEFAULT_OPTIONS.resolution,
+        "--quality",
+        (_e = options.quality) !== null && _e !== void 0 ? _e : DEFAULT_OPTIONS.quality,
+        "--props",
+        propsFile,
+    ];
+    return new Promise((resolve) => {
+        const process = (0, child_process_1.spawn)(pythonPath, args, {
+            stdio: ["ignore", "pipe", "pipe"],
+            env: {
+                ...global.process.env,
+                MANIM_SCROLL_PROPS: propsFile,
+            },
+        });
+        let stdout = "";
+        let stderr = "";
+        process.stdout.on("data", (data) => {
+            stdout += data.toString();
+        });
+        process.stderr.on("data", (data) => {
+            stderr += data.toString();
+        });
+        process.on("close", (code) => {
+            // Clean up temp props file
+            try {
+                fs.unlinkSync(propsFile);
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+            if (code === 0) {
+                resolve({
+                    animation,
+                    hash,
+                    success: true,
+                    manifestUrl,
+                });
+            }
+            else {
+                resolve({
+                    animation,
+                    hash,
+                    success: false,
+                    manifestUrl,
+                    error: stderr || stdout || `Process exited with code ${code}`,
+                });
+            }
+        });
+        process.on("error", (err) => {
+            resolve({
+                animation,
+                hash,
+                success: false,
+                manifestUrl,
+                error: err.message,
+            });
+        });
+    });
+}
+/**
+ * Run a limited number of promises concurrently.
+ */
+async function runWithConcurrency(items, concurrency, fn) {
+    const results = [];
+    const executing = [];
+    for (const item of items) {
+        const promise = fn(item).then((result) => {
+            results.push(result);
+        });
+        executing.push(promise);
+        if (executing.length >= concurrency) {
+            await Promise.race(executing);
+            // Remove completed promises
+            for (let i = executing.length - 1; i >= 0; i--) {
+                const p = executing[i];
+                // Check if promise is settled by racing with resolved promise
+                const settled = await Promise.race([
+                    p.then(() => true).catch(() => true),
+                    Promise.resolve(false),
+                ]);
+                if (settled) {
+                    executing.splice(i, 1);
+                }
+            }
+        }
+    }
+    await Promise.all(executing);
+    return results;
+}
+/**
+ * Render multiple animations in parallel with a concurrency limit.
+ */
+async function renderAnimations(animations, publicDir, options = {}) {
+    var _a;
+    if (animations.length === 0) {
+        return [];
+    }
+    const concurrency = (_a = options.concurrency) !== null && _a !== void 0 ? _a : DEFAULT_OPTIONS.concurrency;
+    console.log(`Rendering ${animations.length} animation(s) with concurrency ${concurrency}...`);
+    const results = await runWithConcurrency(animations, concurrency, (animation) => renderAnimation(animation, publicDir, options));
+    const successful = results.filter((r) => r.success).length;
+    const failed = results.filter((r) => !r.success);
+    console.log(`Rendered ${successful}/${animations.length} animation(s) successfully.`);
+    if (failed.length > 0) {
+        console.error("Failed to render the following animations:");
+        for (const result of failed) {
+            console.error(`  - ${result.animation.id}: ${result.error}`);
+        }
+    }
+    return results;
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@mihirsarya/manim-scroll-next",
+  "version": "0.1.1",
+  "description": "Next.js plugin for build-time Manim scroll animation rendering.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "next": ">=13.0.0"
+  },
+  "dependencies": {
+    "@babel/parser": "^7.24.0",
+    "@babel/traverse": "^7.24.0",
+    "@babel/types": "^7.24.0",
+    "glob": "^10.3.10"
+  },
+  "devDependencies": {
+    "@types/babel__traverse": "^7.20.5",
+    "@types/node": "^20.11.0",
+    "typescript": "^5.4.5"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json"
+  }
+}