@mihirsarya/manim-scroll-next 0.1.1

package/dist/extractor.js

@@ -0,0 +1,293 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractAnimations = extractAnimations;
+exports.extractAnimationsFromFile = extractAnimationsFromFile;
+const fs = __importStar(require("fs"));
+const parser_1 = require("@babel/parser");
+const traverse_1 = __importDefault(require("@babel/traverse"));
+const t = __importStar(require("@babel/types"));
+const glob_1 = require("glob");
+/**
+ * Extract the text content from JSX children.
+ * Handles string literals and JSX text nodes.
+ */
+function extractChildrenText(children) {
+    const textParts = [];
+    for (const child of children) {
+        if (t.isJSXText(child)) {
+            const trimmed = child.value.trim();
+            if (trimmed) {
+                textParts.push(trimmed);
+            }
+        }
+        else if (t.isStringLiteral(child)) {
+            textParts.push(child.value);
+        }
+        else if (t.isJSXExpressionContainer(child)) {
+            if (t.isStringLiteral(child.expression)) {
+                textParts.push(child.expression.value);
+            }
+            else if (t.isTemplateLiteral(child.expression)) {
+                // Handle simple template literals without expressions
+                const parts = child.expression.quasis.map((q) => q.value.cooked || q.value.raw);
+                textParts.push(parts.join(""));
+            }
+        }
+    }
+    return textParts.length > 0 ? textParts.join(" ") : null;
+}
+/**
+ * Extract a literal value from a JSX attribute value.
+ */
+function extractAttributeValue(value) {
+    if (value === null) {
+        return true; // Boolean attribute like `disabled`
+    }
+    if (t.isStringLiteral(value)) {
+        return value.value;
+    }
+    if (t.isJSXExpressionContainer(value)) {
+        const expr = value.expression;
+        if (t.isStringLiteral(expr)) {
+            return expr.value;
+        }
+        if (t.isNumericLiteral(expr)) {
+            return expr.value;
+        }
+        if (t.isBooleanLiteral(expr)) {
+            return expr.value;
+        }
+        if (t.isNullLiteral(expr)) {
+            return null;
+        }
+        if (t.isObjectExpression(expr)) {
+            return extractObjectExpression(expr);
+        }
+        if (t.isArrayExpression(expr)) {
+            return extractArrayExpression(expr);
+        }
+    }
+    // Cannot statically extract, return undefined
+    return undefined;
+}
+/**
+ * Extract an object expression into a plain object.
+ */
+function extractObjectExpression(expr) {
+    const result = {};
+    for (const prop of expr.properties) {
+        if (t.isObjectProperty(prop)) {
+            let key = null;
+            if (t.isIdentifier(prop.key)) {
+                key = prop.key.name;
+            }
+            else if (t.isStringLiteral(prop.key)) {
+                key = prop.key.value;
+            }
+            if (key !== null) {
+                if (t.isStringLiteral(prop.value)) {
+                    result[key] = prop.value.value;
+                }
+                else if (t.isNumericLiteral(prop.value)) {
+                    result[key] = prop.value.value;
+                }
+                else if (t.isBooleanLiteral(prop.value)) {
+                    result[key] = prop.value.value;
+                }
+                else if (t.isNullLiteral(prop.value)) {
+                    result[key] = null;
+                }
+                else if (t.isObjectExpression(prop.value)) {
+                    result[key] = extractObjectExpression(prop.value);
+                }
+                else if (t.isArrayExpression(prop.value)) {
+                    result[key] = extractArrayExpression(prop.value);
+                }
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Extract an array expression into a plain array.
+ */
+function extractArrayExpression(expr) {
+    const result = [];
+    for (const element of expr.elements) {
+        if (element === null) {
+            result.push(null);
+        }
+        else if (t.isStringLiteral(element)) {
+            result.push(element.value);
+        }
+        else if (t.isNumericLiteral(element)) {
+            result.push(element.value);
+        }
+        else if (t.isBooleanLiteral(element)) {
+            result.push(element.value);
+        }
+        else if (t.isNullLiteral(element)) {
+            result.push(null);
+        }
+        else if (t.isObjectExpression(element)) {
+            result.push(extractObjectExpression(element));
+        }
+        else if (t.isArrayExpression(element)) {
+            result.push(extractArrayExpression(element));
+        }
+    }
+    return result;
+}
+/**
+ * Check if a JSX element is a ManimScroll component.
+ */
+function isManimScrollComponent(node) {
+    if (t.isJSXIdentifier(node.name)) {
+        return node.name.name === "ManimScroll";
+    }
+    if (t.isJSXMemberExpression(node.name)) {
+        // Handle cases like `Components.ManimScroll`
+        if (t.isJSXIdentifier(node.name.property)) {
+            return node.name.property.name === "ManimScroll";
+        }
+    }
+    return false;
+}
+/**
+ * Extract ManimScroll component data from a JSX element.
+ */
+function extractManimScroll(jsxElement, filePath) {
+    var _a, _b;
+    const openingElement = jsxElement.openingElement;
+    if (!isManimScrollComponent(openingElement)) {
+        return null;
+    }
+    const props = {};
+    let scene = "TextScene";
+    // Extract attributes
+    for (const attr of openingElement.attributes) {
+        if (t.isJSXAttribute(attr) && t.isJSXIdentifier(attr.name)) {
+            const name = attr.name.name;
+            const value = extractAttributeValue(attr.value);
+            if (name === "scene" && typeof value === "string") {
+                scene = value;
+            }
+            else if (name === "manifestUrl") {
+                // Skip manifestUrl - this is for explicit mode
+                continue;
+            }
+            else if (value !== undefined) {
+                props[name] = value;
+            }
+        }
+    }
+    // Extract children as text prop
+    const childrenText = extractChildrenText(jsxElement.children);
+    if (childrenText) {
+        props.text = childrenText;
+    }
+    const line = (_b = (_a = openingElement.loc) === null || _a === void 0 ? void 0 : _a.start.line) !== null && _b !== void 0 ? _b : 0;
+    return {
+        filePath,
+        line,
+        scene,
+        props,
+    };
+}
+/**
+ * Parse a source file and extract all ManimScroll components.
+ */
+function extractFromFile(filePath) {
+    const source = fs.readFileSync(filePath, "utf-8");
+    const animations = [];
+    let ast;
+    try {
+        ast = (0, parser_1.parse)(source, {
+            sourceType: "module",
+            plugins: ["jsx", "typescript"],
+        });
+    }
+    catch {
+        // Skip files that cannot be parsed
+        return [];
+    }
+    (0, traverse_1.default)(ast, {
+        JSXElement(nodePath) {
+            const extracted = extractManimScroll(nodePath.node, filePath);
+            if (extracted) {
+                // Create a unique ID based on file path and line number
+                const relativePath = filePath.replace(/\\/g, "/");
+                const id = `${relativePath}:${extracted.line}`;
+                animations.push({
+                    id,
+                    ...extracted,
+                });
+            }
+        },
+    });
+    return animations;
+}
+/**
+ * Scan a directory for ManimScroll components and extract their configurations.
+ */
+async function extractAnimations(options) {
+    const { rootDir, include = ["**/*.tsx", "**/*.jsx"], exclude = ["node_modules/**", ".next/**", "dist/**"], } = options;
+    const allAnimations = [];
+    for (const pattern of include) {
+        const files = await (0, glob_1.glob)(pattern, {
+            cwd: rootDir,
+            ignore: exclude,
+            absolute: true,
+        });
+        for (const file of files) {
+            const animations = extractFromFile(file);
+            allAnimations.push(...animations);
+        }
+    }
+    return allAnimations;
+}
+/**
+ * Extract animations from a single file (useful for watch mode).
+ */
+function extractAnimationsFromFile(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return [];
+    }
+    return extractFromFile(filePath);
+}

package/dist/extractor.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/extractor.test.js

@@ -0,0 +1,288 @@
+"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 });
+const vitest_1 = require("vitest");
+const fs = __importStar(require("fs"));
+const extractor_1 = require("./extractor");
+// Mock fs module
+vitest_1.vi.mock("fs");
+// Mock glob module
+vitest_1.vi.mock("glob", () => ({
+    glob: vitest_1.vi.fn().mockResolvedValue([]),
+}));
+(0, vitest_1.describe)("extractAnimationsFromFile", () => {
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.resetAllMocks();
+    });
+    (0, vitest_1.it)("should return empty array for non-existent file", () => {
+        vitest_1.vi.mocked(fs.existsSync).mockReturnValue(false);
+        const result = (0, extractor_1.extractAnimationsFromFile)("/path/to/missing.tsx");
+        (0, vitest_1.expect)(result).toEqual([]);
+    });
+    (0, vitest_1.it)("should extract basic ManimScroll component", () => {
+        vitest_1.vi.mocked(fs.existsSync).mockReturnValue(true);
+        vitest_1.vi.mocked(fs.readFileSync).mockReturnValue(`
+      import { ManimScroll } from "@mihirsarya/manim-scroll";
+
+      export default function Page() {
+        return (
+          <ManimScroll fontSize={72} color="#ffffff">
+            Hello World
+          </ManimScroll>
+        );
+      }
+    `);
+        const result = (0, extractor_1.extractAnimationsFromFile)("/app/page.tsx");
+        (0, vitest_1.expect)(result).toHaveLength(1);
+        (0, vitest_1.expect)(result[0].scene).toBe("TextScene"); // default
+        (0, vitest_1.expect)(result[0].props.fontSize).toBe(72);
+        (0, vitest_1.expect)(result[0].props.color).toBe("#ffffff");
+        (0, vitest_1.expect)(result[0].props.text).toBe("Hello World");
+    });
+    (0, vitest_1.it)("should extract custom scene name", () => {
+        vitest_1.vi.mocked(fs.existsSync).mockReturnValue(true);
+        vitest_1.vi.mocked(fs.readFileSync).mockReturnValue(`
+      <ManimScroll scene="CustomScene" value={42} />
+    `);
+        const result = (0, extractor_1.extractAnimationsFromFile)("/app/page.tsx");
+        (0, vitest_1.expect)(result).toHaveLength(1);
+        (0, vitest_1.expect)(result[0].scene).toBe("CustomScene");
+        (0, vitest_1.expect)(result[0].props.value).toBe(42);
+    });
+    (0, vitest_1.it)("should extract multiple ManimScroll components", () => {
+        vitest_1.vi.mocked(fs.existsSync).mockReturnValue(true);
+        vitest_1.vi.mocked(fs.readFileSync).mockReturnValue(`
+      function Page() {
+        return (
+          <div>
+            <ManimScroll fontSize={48}>First</ManimScroll>
+            <ManimScroll fontSize={72}>Second</ManimScroll>
+          </div>
+        );
+      }
+    `);
+        const result = (0, extractor_1.extractAnimationsFromFile)("/app/page.tsx");
+        (0, vitest_1.expect)(result).toHaveLength(2);
+        (0, vitest_1.expect)(result[0].props.text).toBe("First");
+        (0, vitest_1.expect)(result[1].props.text).toBe("Second");
+    });
+    (0, vitest_1.it)("should skip components with manifestUrl (explicit mode)", () => {
+        vitest_1.vi.mocked(fs.existsSync).mockReturnValue(true);
+        vitest_1.vi.mocked(fs.readFileSync).mockReturnValue(`
+      <ManimScroll manifestUrl="/assets/scene/manifest.json">
+        This should be skipped
+      </ManimScroll>
+    `);
+        const result = (0, extractor_1.extractAnimationsFromFile)("/app/page.tsx");
+        (0, vitest_1.expect)(result).toHaveLength(1);
+        // manifestUrl should not be in props
+        (0, vitest_1.expect)(result[0].props.manifestUrl).toBeUndefined();
+    });
+    (0, vitest_1.it)("should extract boolean attributes", () => {
+        vitest_1.vi.mocked(fs.existsSync).mockReturnValue(true);
+        vitest_1.vi.mocked(fs.readFileSync).mockReturnValue(`
+      <ManimScroll enabled loop />
+    `);
+        const result = (0, extractor_1.extractAnimationsFromFile)("/app/page.tsx");
+        (0, vitest_1.expect)(result).toHaveLength(1);
+        (0, vitest_1.expect)(result[0].props.enabled).toBe(true);
+        (0, vitest_1.expect)(result[0].props.loop).toBe(true);
+    });
+    (0, vitest_1.it)("should extract object props", () => {
+        vitest_1.vi.mocked(fs.existsSync).mockReturnValue(true);
+        vitest_1.vi.mocked(fs.readFileSync).mockReturnValue(`
+      <ManimScroll config={{ theme: "dark", size: 10 }} />
+    `);
+        const result = (0, extractor_1.extractAnimationsFromFile)("/app/page.tsx");
+        (0, vitest_1.expect)(result).toHaveLength(1);
+        (0, vitest_1.expect)(result[0].props.config).toEqual({ theme: "dark", size: 10 });
+    });
+    (0, vitest_1.it)("should extract array props", () => {
+        vitest_1.vi.mocked(fs.existsSync).mockReturnValue(true);
+        vitest_1.vi.mocked(fs.readFileSync).mockReturnValue(`
+      <ManimScroll items={[1, 2, 3]} />
+    `);
+        const result = (0, extractor_1.extractAnimationsFromFile)("/app/page.tsx");
+        (0, vitest_1.expect)(result).toHaveLength(1);
+        (0, vitest_1.expect)(result[0].props.items).toEqual([1, 2, 3]);
+    });
+    (0, vitest_1.it)("should extract null props", () => {
+        vitest_1.vi.mocked(fs.existsSync).mockReturnValue(true);
+        vitest_1.vi.mocked(fs.readFileSync).mockReturnValue(`
+      <ManimScroll value={null} />
+    `);
+        const result = (0, extractor_1.extractAnimationsFromFile)("/app/page.tsx");
+        (0, vitest_1.expect)(result).toHaveLength(1);
+        (0, vitest_1.expect)(result[0].props.value).toBeNull();
+    });
+    (0, vitest_1.it)("should handle template literals in children", () => {
+        vitest_1.vi.mocked(fs.existsSync).mockReturnValue(true);
+        vitest_1.vi.mocked(fs.readFileSync).mockReturnValue(`
+      <ManimScroll>{\`Hello World\`}</ManimScroll>
+    `);
+        const result = (0, extractor_1.extractAnimationsFromFile)("/app/page.tsx");
+        (0, vitest_1.expect)(result).toHaveLength(1);
+        (0, vitest_1.expect)(result[0].props.text).toBe("Hello World");
+    });
+    (0, vitest_1.it)("should handle JSX expression with string literal in children", () => {
+        vitest_1.vi.mocked(fs.existsSync).mockReturnValue(true);
+        vitest_1.vi.mocked(fs.readFileSync).mockReturnValue(`
+      <ManimScroll>{"Hello World"}</ManimScroll>
+    `);
+        const result = (0, extractor_1.extractAnimationsFromFile)("/app/page.tsx");
+        (0, vitest_1.expect)(result).toHaveLength(1);
+        (0, vitest_1.expect)(result[0].props.text).toBe("Hello World");
+    });
+    (0, vitest_1.it)("should handle ManimScroll as member expression", () => {
+        vitest_1.vi.mocked(fs.existsSync).mockReturnValue(true);
+        vitest_1.vi.mocked(fs.readFileSync).mockReturnValue(`
+      import * as Components from "@mihirsarya/manim-scroll";
+
+      <Components.ManimScroll fontSize={72}>Test</Components.ManimScroll>
+    `);
+        const result = (0, extractor_1.extractAnimationsFromFile)("/app/page.tsx");
+        (0, vitest_1.expect)(result).toHaveLength(1);
+        (0, vitest_1.expect)(result[0].scene).toBe("TextScene");
+        (0, vitest_1.expect)(result[0].props.fontSize).toBe(72);
+    });
+    (0, vitest_1.it)("should return empty array for files with no ManimScroll", () => {
+        vitest_1.vi.mocked(fs.existsSync).mockReturnValue(true);
+        vitest_1.vi.mocked(fs.readFileSync).mockReturnValue(`
+      function Page() {
+        return <div>No animations here</div>;
+      }
+    `);
+        const result = (0, extractor_1.extractAnimationsFromFile)("/app/page.tsx");
+        (0, vitest_1.expect)(result).toEqual([]);
+    });
+    (0, vitest_1.it)("should return empty array for unparseable files", () => {
+        vitest_1.vi.mocked(fs.existsSync).mockReturnValue(true);
+        vitest_1.vi.mocked(fs.readFileSync).mockReturnValue(`
+      this is not valid javascript/typescript
+      <ManimScroll>Test</ManimScroll>
+      !!!syntax error!!!
+    `);
+        const result = (0, extractor_1.extractAnimationsFromFile)("/app/page.tsx");
+        // Should return empty array, not throw
+        (0, vitest_1.expect)(result).toEqual([]);
+    });
+    (0, vitest_1.it)("should include file path and line number", () => {
+        vitest_1.vi.mocked(fs.existsSync).mockReturnValue(true);
+        vitest_1.vi.mocked(fs.readFileSync).mockReturnValue(`
+      // Line 1
+      // Line 2
+      <ManimScroll>Test</ManimScroll>
+    `);
+        const result = (0, extractor_1.extractAnimationsFromFile)("/app/page.tsx");
+        (0, vitest_1.expect)(result).toHaveLength(1);
+        (0, vitest_1.expect)(result[0].filePath).toBe("/app/page.tsx");
+        (0, vitest_1.expect)(result[0].line).toBeGreaterThan(0);
+        (0, vitest_1.expect)(result[0].id).toContain("/app/page.tsx:");
+    });
+    (0, vitest_1.it)("should handle nested objects in props", () => {
+        vitest_1.vi.mocked(fs.existsSync).mockReturnValue(true);
+        vitest_1.vi.mocked(fs.readFileSync).mockReturnValue(`
+      <ManimScroll 
+        config={{ 
+          theme: { primary: "#fff", secondary: "#000" },
+          sizes: [10, 20, 30]
+        }} 
+      />
+    `);
+        const result = (0, extractor_1.extractAnimationsFromFile)("/app/page.tsx");
+        (0, vitest_1.expect)(result).toHaveLength(1);
+        (0, vitest_1.expect)(result[0].props.config).toEqual({
+            theme: { primary: "#fff", secondary: "#000" },
+            sizes: [10, 20, 30],
+        });
+    });
+    (0, vitest_1.it)("should handle numeric string keys in objects", () => {
+        vitest_1.vi.mocked(fs.existsSync).mockReturnValue(true);
+        vitest_1.vi.mocked(fs.readFileSync).mockReturnValue(`
+      <ManimScroll data={{ "123": "value" }} />
+    `);
+        const result = (0, extractor_1.extractAnimationsFromFile)("/app/page.tsx");
+        (0, vitest_1.expect)(result).toHaveLength(1);
+        (0, vitest_1.expect)(result[0].props.data).toEqual({ "123": "value" });
+    });
+});
+(0, vitest_1.describe)("extractChildrenText (via extractor)", () => {
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.resetAllMocks();
+    });
+    (0, vitest_1.it)("should combine multiple JSX text nodes", () => {
+        vitest_1.vi.mocked(fs.existsSync).mockReturnValue(true);
+        // When text spans multiple lines, JSX parser treats it as a single text node
+        // with internal whitespace preserved (only leading/trailing trimmed)
+        vitest_1.vi.mocked(fs.readFileSync).mockReturnValue(`
+      <ManimScroll>Hello World</ManimScroll>
+    `);
+        const result = (0, extractor_1.extractAnimationsFromFile)("/app/page.tsx");
+        (0, vitest_1.expect)(result).toHaveLength(1);
+        (0, vitest_1.expect)(result[0].props.text).toBe("Hello World");
+    });
+    (0, vitest_1.it)("should handle multiline text (preserves internal whitespace)", () => {
+        vitest_1.vi.mocked(fs.existsSync).mockReturnValue(true);
+        vitest_1.vi.mocked(fs.readFileSync).mockReturnValue(`
+      <ManimScroll>
+        Hello
+        World
+      </ManimScroll>
+    `);
+        const result = (0, extractor_1.extractAnimationsFromFile)("/app/page.tsx");
+        (0, vitest_1.expect)(result).toHaveLength(1);
+        // Multiline JSX text preserves internal newlines after trimming
+        (0, vitest_1.expect)(result[0].props.text).toContain("Hello");
+        (0, vitest_1.expect)(result[0].props.text).toContain("World");
+    });
+    (0, vitest_1.it)("should handle whitespace-only children as no text", () => {
+        vitest_1.vi.mocked(fs.existsSync).mockReturnValue(true);
+        vitest_1.vi.mocked(fs.readFileSync).mockReturnValue(`
+      <ManimScroll>   </ManimScroll>
+    `);
+        const result = (0, extractor_1.extractAnimationsFromFile)("/app/page.tsx");
+        (0, vitest_1.expect)(result).toHaveLength(1);
+        (0, vitest_1.expect)(result[0].props.text).toBeUndefined();
+    });
+    (0, vitest_1.it)("should trim whitespace from text", () => {
+        vitest_1.vi.mocked(fs.existsSync).mockReturnValue(true);
+        vitest_1.vi.mocked(fs.readFileSync).mockReturnValue(`
+      <ManimScroll>  Hello World  </ManimScroll>
+    `);
+        const result = (0, extractor_1.extractAnimationsFromFile)("/app/page.tsx");
+        (0, vitest_1.expect)(result).toHaveLength(1);
+        (0, vitest_1.expect)(result[0].props.text).toBe("Hello World");
+    });
+});

package/dist/index.d.ts

@@ -0,0 +1,55 @@
+import type { NextConfig } from "next";
+export interface ManimScrollConfig {
+    /** Path to the Python executable (default: "python3") */
+    pythonPath?: string;
+    /** Path to the render CLI script */
+    cliPath?: string;
+    /** Path to the scene templates directory */
+    templatesDir?: string;
+    /** Maximum number of parallel renders (default: CPU count - 1) */
+    concurrency?: number;
+    /** FPS for the animation (default: 30) */
+    fps?: number;
+    /** Resolution in "WIDTHxHEIGHT" format (default: "1920x1080") */
+    resolution?: string;
+    /** Manim quality preset: l, m, h, k (default: "h") */
+    quality?: string;
+    /** Output format: frames, video, both (default: "both") */
+    format?: string;
+    /** Glob patterns to include (default: ["**\/*.tsx", "**\/*.jsx"]) */
+    include?: string[];
+    /** Glob patterns to exclude (default: ["node_modules/**", ".next/**"]) */
+    exclude?: string[];
+    /** Clean up orphaned cache entries (default: true) */
+    cleanOrphans?: boolean;
+    /** Verbose logging (default: false) */
+    verbose?: boolean;
+}
+export interface NextConfigWithManimScroll extends NextConfig {
+    manimScroll?: ManimScrollConfig;
+}
+/**
+ * Process ManimScroll components: extract, cache, and render.
+ */
+declare function processManimScroll(projectDir: string, config: ManimScrollConfig): Promise<void>;
+/**
+ * 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",
+ *   },
+ * });
+ * ```
+ */
+export declare function withManimScroll(nextConfig?: NextConfigWithManimScroll): NextConfig;
+export { extractAnimations, type ExtractedAnimation } from "./extractor";
+export { computePropsHash, isCached, getCacheEntry, getAnimationsToRender, writeCacheManifest, readCacheManifest, cleanOrphanedCache, } from "./cache";
+export { renderAnimations, type RenderResult, type RenderOptions } from "./renderer";
+export { processManimScroll };