@redwilly/anima 0.1.0

package/dist/mobjects/text/Glyph.d.ts

@@ -0,0 +1,11 @@
+import { VMobject } from '../VMobject';
+import type { Glyph as FontkitGlyph } from 'fontkit';
+/**
+ * A VMobject representing a single glyph character.
+ * Converts fontkit glyph path to BezierPath for rendering.
+ */
+export declare class Glyph extends VMobject {
+    readonly character: string;
+    readonly glyphId: number;
+    constructor(fontkitGlyph: FontkitGlyph, character: string, scale: number, offsetX: number, offsetY: number);
+}

package/dist/mobjects/text/Glyph.js

@@ -0,0 +1,72 @@
+import { VMobject } from '../VMobject';
+import { BezierPath } from '../../core/math/bezier/BezierPath';
+import { Vector2 } from '../../core/math/Vector2/Vector2';
+/**
+ * Converts a fontkit path command to BezierPath commands.
+ * Fontkit uses: moveTo, lineTo, quadraticCurveTo, bezierCurveTo, closePath
+ */
+function convertFontkitPath(fontkitPath, scale, offsetX, offsetY) {
+    const path = new BezierPath();
+    const commands = fontkitPath.commands;
+    const transformX = (val) => val * scale + offsetX;
+    // Note: Fontkit uses Y-up coordinates (same as Manim world coords)
+    // The renderer handles the flip to screen Y-down coordinates
+    const transformY = (val) => val * scale + offsetY;
+    for (const cmd of commands) {
+        const type = cmd.command;
+        const args = cmd.args;
+        if (type === 'moveTo' && args.length >= 2) {
+            const x = args[0] ?? 0;
+            const y = args[1] ?? 0;
+            path.moveTo(new Vector2(transformX(x), transformY(y)));
+        }
+        else if (type === 'lineTo' && args.length >= 2) {
+            const x = args[0] ?? 0;
+            const y = args[1] ?? 0;
+            path.lineTo(new Vector2(transformX(x), transformY(y)));
+        }
+        else if (type === 'quadraticCurveTo' && args.length >= 4) {
+            const cpx = args[0] ?? 0;
+            const cpy = args[1] ?? 0;
+            const x = args[2] ?? 0;
+            const y = args[3] ?? 0;
+            const cp = new Vector2(transformX(cpx), transformY(cpy));
+            const end = new Vector2(transformX(x), transformY(y));
+            path.quadraticTo(cp, end);
+        }
+        else if (type === 'bezierCurveTo' && args.length >= 6) {
+            const cp1x = args[0] ?? 0;
+            const cp1y = args[1] ?? 0;
+            const cp2x = args[2] ?? 0;
+            const cp2y = args[3] ?? 0;
+            const x = args[4] ?? 0;
+            const y = args[5] ?? 0;
+            const cp1 = new Vector2(transformX(cp1x), transformY(cp1y));
+            const cp2 = new Vector2(transformX(cp2x), transformY(cp2y));
+            const end = new Vector2(transformX(x), transformY(y));
+            path.cubicTo(cp1, cp2, end);
+        }
+        else if (type === 'closePath') {
+            path.closePath();
+        }
+    }
+    return path;
+}
+/**
+ * A VMobject representing a single glyph character.
+ * Converts fontkit glyph path to BezierPath for rendering.
+ */
+export class Glyph extends VMobject {
+    character;
+    glyphId;
+    constructor(fontkitGlyph, character, scale, offsetX, offsetY) {
+        super();
+        this.character = character;
+        this.glyphId = fontkitGlyph.id;
+        const glyphPath = fontkitGlyph.path;
+        if (glyphPath.commands.length > 0) {
+            const bezierPath = convertFontkitPath(glyphPath, scale, offsetX, offsetY);
+            this.addPath(bezierPath);
+        }
+    }
+}

package/dist/mobjects/text/Text.d.ts

@@ -0,0 +1,19 @@
+import { VGroup } from '../VGroup';
+import { Glyph } from './Glyph';
+import type { TextStyle } from './types';
+/**
+ * A VGroup of vectorized glyphs created from a text string using fontkit.
+ * Each character becomes a Glyph VMobject that can be individually animated.
+ */
+export declare class Text extends VGroup {
+    readonly text: string;
+    private style;
+    private fontPath;
+    constructor(text: string, fontPath: string, options?: Partial<TextStyle>);
+    private buildGlyphs;
+    private getCharacterForGlyph;
+    private applyStyle;
+    setStyle(options: Partial<TextStyle>): this;
+    getStyle(): TextStyle;
+    getGlyph(index: number): Glyph | undefined;
+}

package/dist/mobjects/text/Text.js

@@ -0,0 +1,76 @@
+import * as fontkit from 'fontkit';
+import { VGroup } from '../VGroup';
+import { centerGroup } from '../VGroup/layout';
+import { Glyph } from './Glyph';
+import { DEFAULT_TEXT_STYLE } from './types';
+/**
+ * A VGroup of vectorized glyphs created from a text string using fontkit.
+ * Each character becomes a Glyph VMobject that can be individually animated.
+ */
+export class Text extends VGroup {
+    text;
+    style;
+    fontPath;
+    constructor(text, fontPath, options = {}) {
+        super();
+        this.text = text;
+        this.fontPath = fontPath;
+        this.style = { ...DEFAULT_TEXT_STYLE, ...options };
+        this.buildGlyphs();
+        centerGroup(this);
+        this.applyStyle();
+    }
+    buildGlyphs() {
+        const fontOrCollection = fontkit.openSync(this.fontPath);
+        // Handle FontCollection (e.g., .ttc files) by getting first font
+        const font = 'fonts' in fontOrCollection
+            ? fontOrCollection.fonts[0]
+            : fontOrCollection;
+        if (!font) {
+            throw new Error(`Could not load font from ${this.fontPath}`);
+        }
+        const run = font.layout(this.text);
+        const scale = this.style.fontSize / font.unitsPerEm;
+        let penX = 0;
+        let penY = 0;
+        for (let i = 0; i < run.glyphs.length; i++) {
+            const glyph = run.glyphs[i];
+            const pos = run.positions[i];
+            if (glyph === undefined || pos === undefined)
+                continue;
+            // Get the character for this glyph position
+            const char = this.getCharacterForGlyph(i);
+            // Calculate glyph position with offsets
+            const glyphX = penX + pos.xOffset * scale;
+            const glyphY = penY + pos.yOffset * scale;
+            const glyphMobject = new Glyph(glyph, char, scale, glyphX, glyphY);
+            this.add(glyphMobject);
+            // Advance pen position
+            penX += pos.xAdvance * scale;
+            penY += pos.yAdvance * scale;
+        }
+    }
+    getCharacterForGlyph(index) {
+        return this.text.charAt(index) || '';
+    }
+    applyStyle() {
+        for (const child of this.getChildren()) {
+            if (child instanceof Glyph) {
+                child.stroke(this.style.color, 0);
+                child.fill(this.style.color, 1);
+            }
+        }
+    }
+    setStyle(options) {
+        this.style = { ...this.style, ...options };
+        this.applyStyle();
+        return this;
+    }
+    getStyle() {
+        return { ...this.style };
+    }
+    getGlyph(index) {
+        const child = this.get(index);
+        return child instanceof Glyph ? child : undefined;
+    }
+}

package/dist/mobjects/text/index.d.ts

@@ -0,0 +1,4 @@
+export { Glyph } from './Glyph';
+export { Text } from './Text';
+export { DEFAULT_TEXT_STYLE } from './types';
+export type { TextStyle } from './types';

package/dist/mobjects/text/index.js

@@ -0,0 +1,3 @@
+export { Glyph } from './Glyph';
+export { Text } from './Text';
+export { DEFAULT_TEXT_STYLE } from './types';

package/dist/mobjects/text/types.d.ts

@@ -0,0 +1,12 @@
+import { Color } from '../../core/math/color/Color';
+/**
+ * Options for configuring Text appearance.
+ */
+export interface TextStyle {
+    fontSize: number;
+    color: Color;
+}
+/**
+ * Default text style values.
+ */
+export declare const DEFAULT_TEXT_STYLE: TextStyle;

package/dist/mobjects/text/types.js

@@ -0,0 +1,8 @@
+import { Color } from '../../core/math/color/Color';
+/**
+ * Default text style values.
+ */
+export const DEFAULT_TEXT_STYLE = {
+    fontSize: 1,
+    color: Color.WHITE
+};

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@redwilly/anima",
+  "version": "0.1.0",
+  "description": "Animation library for mathematical visualizations",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "anima": "./dist/cli/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "clean": "rimraf dist",
+    "build": "bun run clean && tsc -p tsconfig.build.json",
+    "prepublishOnly": "bun run build"
+  },
+  "keywords": [
+    "animation",
+    "math",
+    "visualization",
+    "canvas",
+    "manim"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/fontkit": "^2.0.8",
+    "fast-check": "^4.5.3",
+    "rimraf": "^6.0.1"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "@napi-rs/canvas": "^0.1.88",
+    "commander": "^14.0.2",
+    "fontkit": "^2.0.4"
+  }
+}