text-shaper 0.1.0 → 0.1.1

package/dist/raster/bbox.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Exact bounding box calculation for paths with bezier curves
+ *
+ * Bezier curves can extend beyond their control points, so we need to find
+ * the actual extrema by solving for where the derivative equals zero.
+ */
+import type { GlyphPath } from "../render/path.ts";
+/**
+ * Bounding box in 2D space
+ */
+export interface BBox {
+    xMin: number;
+    yMin: number;
+    xMax: number;
+    yMax: number;
+}
+/**
+ * Calculate exact bounding box for a path
+ *
+ * For line segments: min/max of endpoints
+ * For quadratic bezier: find t where derivative = 0, evaluate curve at those t values
+ * For cubic bezier: solve quadratic for extrema, evaluate curve at those t values
+ *
+ * @param path - Path to calculate bounds for
+ * @returns Bounding box or null for empty path
+ */
+export declare function getExactBounds(path: GlyphPath): BBox | null;
+/**
+ * Find t values where a quadratic bezier has extrema
+ *
+ * For quadratic bezier B(t) = (1-t)²p0 + 2(1-t)t*p1 + t²p2
+ * Derivative: B'(t) = 2(1-t)(p1-p0) + 2t(p2-p1)
+ *                   = 2(p1-p0) + 2t(p0-2p1+p2)
+ *                   = 2[(p1-p0) + t(p0-2p1+p2)]
+ *
+ * Set B'(t) = 0:
+ * (p1-p0) + t(p0-2p1+p2) = 0
+ * t = -(p1-p0)/(p0-2p1+p2)
+ *   = (p0-p1)/(p0-2p1+p2)
+ *
+ * @param p0 - Start point
+ * @param p1 - Control point
+ * @param p2 - End point
+ * @returns Array of t values in [0,1] where extrema occur
+ */
+export declare function getQuadraticExtrema(p0: number, p1: number, p2: number): number[];
+/**
+ * Find t values where a cubic bezier has extrema
+ *
+ * For cubic bezier B(t) = (1-t)³p0 + 3(1-t)²t*p1 + 3(1-t)t²p2 + t³p3
+ * Derivative: B'(t) = 3(1-t)²(p1-p0) + 6(1-t)t(p2-p1) + 3t²(p3-p2)
+ *
+ * Simplified: B'(t) = at² + bt + c where:
+ * a = 3(p3 - 3p2 + 3p1 - p0)
+ * b = 6(p2 - 2p1 + p0)
+ * c = 3(p1 - p0)
+ *
+ * Solve using quadratic formula: t = (-b ± √(b²-4ac)) / 2a
+ *
+ * @param p0 - Start point
+ * @param p1 - First control point
+ * @param p2 - Second control point
+ * @param p3 - End point
+ * @returns Array of t values in [0,1] where extrema occur
+ */
+export declare function getCubicExtrema(p0: number, p1: number, p2: number, p3: number): number[];
+/**
+ * Evaluate quadratic bezier at parameter t
+ *
+ * B(t) = (1-t)²p0 + 2(1-t)t*p1 + t²p2
+ *
+ * @param p0 - Start point
+ * @param p1 - Control point
+ * @param p2 - End point
+ * @param t - Parameter in [0,1]
+ * @returns Value at t
+ */
+export declare function evaluateQuadratic(p0: number, p1: number, p2: number, t: number): number;
+/**
+ * Evaluate cubic bezier at parameter t
+ *
+ * B(t) = (1-t)³p0 + 3(1-t)²t*p1 + 3(1-t)t²p2 + t³p3
+ *
+ * @param p0 - Start point
+ * @param p1 - First control point
+ * @param p2 - Second control point
+ * @param p3 - End point
+ * @param t - Parameter in [0,1]
+ * @returns Value at t
+ */
+export declare function evaluateCubic(p0: number, p1: number, p2: number, p3: number, t: number): number;

package/dist/raster/bitmap-utils.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Bitmap manipulation utilities
+ */
+import { type Bitmap, PixelMode } from "./types.ts";
+/**
+ * Embolden a bitmap by dilating pixel values
+ * Makes text bolder by spreading coverage in x and y directions
+ */
+export declare function emboldenBitmap(bitmap: Bitmap, xStrength: number, yStrength: number): Bitmap;
+/**
+ * Convert bitmap between pixel modes
+ */
+export declare function convertBitmap(bitmap: Bitmap, targetMode: PixelMode): Bitmap;
+/**
+ * Alpha blend src bitmap onto dst bitmap at position (x, y)
+ */
+export declare function blendBitmap(dst: Bitmap, src: Bitmap, x: number, y: number, opacity: number): void;
+/**
+ * Create a deep copy of a bitmap
+ */
+export declare function copyBitmap(bitmap: Bitmap): Bitmap;
+/**
+ * Resize bitmap using nearest-neighbor interpolation
+ */
+export declare function resizeBitmap(bitmap: Bitmap, newWidth: number, newHeight: number): Bitmap;

package/dist/raster/blur.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Bitmap blur filters - Gaussian and Box blur
+ */
+import { type Bitmap } from "./types.ts";
+/**
+ * Generate 1D Gaussian kernel
+ * Uses Gaussian function: exp(-x²/(2σ²))
+ */
+export declare function createGaussianKernel(radius: number): Float32Array;
+/**
+ * Gaussian blur implementation using separable 2-pass algorithm
+ * Modifies bitmap in-place and returns it
+ */
+export declare function gaussianBlur(bitmap: Bitmap, radius: number): Bitmap;
+/**
+ * Box blur using running sum for O(1) per pixel
+ * Modifies bitmap in-place and returns it
+ */
+export declare function boxBlur(bitmap: Bitmap, radius: number): Bitmap;
+/**
+ * Apply blur filter to a bitmap in-place
+ * @param bitmap - Bitmap to blur (modified in-place)
+ * @param radius - Blur radius in pixels (can be fractional)
+ * @param type - Blur type: 'gaussian' (default) or 'box'
+ * @returns The modified bitmap
+ */
+export declare function blurBitmap(bitmap: Bitmap, radius: number, type?: "gaussian" | "box"): Bitmap;

package/dist/raster/gradient.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Gradient fill rendering for paths
+ */
+import type { GlyphPath } from "../render/path.ts";
+import { type Bitmap, type RasterizeOptions } from "./types.ts";
+/**
+ * Color stop in a gradient (RGBA, 0-255 each)
+ */
+export interface ColorStop {
+    /** Position along gradient, 0.0 to 1.0 */
+    offset: number;
+    /** RGBA color values, 0-255 each */
+    color: [number, number, number, number];
+}
+/**
+ * Linear gradient from point (x0,y0) to (x1,y1)
+ */
+export interface LinearGradient {
+    type: "linear";
+    /** Start X coordinate */
+    x0: number;
+    /** Start Y coordinate */
+    y0: number;
+    /** End X coordinate */
+    x1: number;
+    /** End Y coordinate */
+    y1: number;
+    /** Color stops */
+    stops: ColorStop[];
+}
+/**
+ * Radial gradient from center point with radius
+ */
+export interface RadialGradient {
+    type: "radial";
+    /** Center X coordinate */
+    cx: number;
+    /** Center Y coordinate */
+    cy: number;
+    /** Gradient radius */
+    radius: number;
+    /** Color stops */
+    stops: ColorStop[];
+}
+/**
+ * Gradient type union
+ */
+export type Gradient = LinearGradient | RadialGradient;
+/**
+ * Get color at position in gradient
+ */
+export declare function interpolateGradient(gradient: Gradient, x: number, y: number): [number, number, number, number];
+/**
+ * Create a bitmap filled with gradient (no path)
+ */
+export declare function createGradientBitmap(width: number, height: number, gradient: Gradient): Bitmap;
+/**
+ * Rasterize path with gradient fill
+ * First rasterizes path to get coverage mask, then fills with gradient
+ */
+export declare function rasterizePathWithGradient(path: GlyphPath, gradient: Gradient, options: RasterizeOptions): Bitmap;

package/dist/raster/rasterize.d.ts

@@ -33,4 +33,11 @@ export declare function bitmapToRGBA(bitmap: Bitmap): Uint8Array;
  * Export bitmap to grayscale array
  */
 export declare function bitmapToGray(bitmap: Bitmap): Uint8Array;
+export { type BBox, evaluateCubic, evaluateQuadratic, getCubicExtrema, getExactBounds, getQuadraticExtrema, } from "./bbox.ts";
+export { blendBitmap, convertBitmap, copyBitmap, emboldenBitmap, resizeBitmap, } from "./bitmap-utils.ts";
+export { blurBitmap, boxBlur, createGaussianKernel, gaussianBlur, } from "./blur.ts";
+export { type ColorStop, createGradientBitmap, type Gradient, interpolateGradient, type LinearGradient, type RadialGradient, rasterizePathWithGradient, } from "./gradient.ts";
+export { renderSdf, type SdfOptions } from "./sdf.ts";
+export { type LineCap, type LineJoin, type StrokerOptions, strokePath, } from "./stroker.ts";
+export { condensePath, emboldenPath, obliquePath, transformPath, } from "./synth.ts";
 export { type Bitmap, clearBitmap, createBitmap, FillRule, PixelMode, type RasterizedGlyph, type RasterizeOptions, type Span, } from "./types.ts";

package/dist/raster/sdf.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Signed Distance Field (SDF) rasterizer
+ *
+ * For each pixel, compute the shortest distance to the outline.
+ * Positive values are inside the outline, negative are outside.
+ * This allows GPU text rendering at any scale.
+ *
+ * Algorithm:
+ * 1. For each pixel center, find the minimum distance to all outline edges
+ * 2. Determine sign based on whether point is inside or outside the outline
+ * 3. Normalize and encode to 0-255 (128 = on the edge)
+ */
+import type { GlyphPath } from "../render/path.ts";
+import { type Bitmap } from "./types.ts";
+/**
+ * Options for SDF rendering
+ */
+export interface SdfOptions {
+    /** Width in pixels */
+    width: number;
+    /** Height in pixels */
+    height: number;
+    /** Scale factor (font units to pixels) */
+    scale: number;
+    /** X offset in pixels */
+    offsetX?: number;
+    /** Y offset in pixels */
+    offsetY?: number;
+    /** Flip Y axis (font coords are Y-up, bitmap is Y-down) */
+    flipY?: boolean;
+    /** Spread/radius - how far the distance field extends in pixels (default: 8) */
+    spread?: number;
+}
+/**
+ * Render a glyph path as a signed distance field
+ */
+export declare function renderSdf(path: GlyphPath, options: SdfOptions): Bitmap;

package/dist/raster/stroker.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Path Stroker
+ *
+ * Converts a path outline into a stroked outline that can be filled.
+ * Based on FreeType's ftstroke.c algorithm.
+ *
+ * The stroker generates two borders (inside and outside) by offsetting
+ * the original path by half the stroke width in both directions.
+ */
+import type { GlyphPath } from "../render/path.ts";
+/** Line cap styles */
+export type LineCap = "butt" | "round" | "square";
+/** Line join styles */
+export type LineJoin = "miter" | "round" | "bevel";
+/** Stroker options */
+export interface StrokerOptions {
+    /** Stroke width in font units */
+    width: number;
+    /** Line cap style (default: "butt") */
+    lineCap?: LineCap;
+    /** Line join style (default: "miter") */
+    lineJoin?: LineJoin;
+    /** Miter limit for miter joins (default: 4) */
+    miterLimit?: number;
+}
+/**
+ * Stroke a glyph path, producing a new path that represents the stroked outline
+ */
+export declare function strokePath(path: GlyphPath, options: StrokerOptions): GlyphPath;

package/dist/raster/synth.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Synthetic Font Effects
+ *
+ * Provides transformations for creating synthetic bold, italic, and other effects
+ * on glyph outlines. These are useful for fonts that don't have native bold/italic
+ * variants.
+ */
+import type { GlyphPath } from "../render/path.ts";
+/**
+ * Apply oblique (slant/italic) transformation to a path
+ *
+ * @param path - The glyph path to transform
+ * @param slant - Tangent of the slant angle (0.2 = ~12 degrees, typical italic)
+ * @returns New path with slant applied
+ *
+ * Transform: x' = x + y * slant, y' = y
+ */
+export declare function obliquePath(path: GlyphPath, slant: number): GlyphPath;
+/**
+ * Apply general 2D affine transformation to a path
+ *
+ * @param path - The glyph path to transform
+ * @param matrix - 2D transformation matrix [a, b, c, d, e, f]
+ * @returns New path with transformation applied
+ *
+ * Transform: x' = a*x + c*y + e, y' = b*x + d*y + f
+ */
+export declare function transformPath(path: GlyphPath, matrix: [number, number, number, number, number, number]): GlyphPath;
+/**
+ * Apply horizontal scaling (condensing/expanding) to a path
+ *
+ * @param path - The glyph path to transform
+ * @param factor - Horizontal scale factor (< 1 = narrower, > 1 = wider)
+ * @returns New path with horizontal scaling applied
+ *
+ * Transform: x' = x * factor, y' = y
+ */
+export declare function condensePath(path: GlyphPath, factor: number): GlyphPath;
+/**
+ * Embolden (make bolder) a path by offsetting the outline
+ *
+ * This implementation uses a simplified approach that offsets each contour
+ * outward by moving points along the normal direction. For production use,
+ * a proper stroking algorithm would be more accurate.
+ *
+ * @param path - The glyph path to embolden
+ * @param strength - Offset strength in font units (positive = bolder, negative = thinner)
+ * @returns New path with emboldening applied
+ */
+export declare function emboldenPath(path: GlyphPath, strength: number): GlyphPath;

package/dist/raster/types.d.ts

@@ -13,7 +13,9 @@ export declare enum PixelMode {
     /** 24-bit LCD subpixel RGB, 3 bytes per pixel */
     LCD = 2,
     /** 24-bit LCD subpixel vertical RGB */
-    LCD_V = 3
+    LCD_V = 3,
+    /** 32-bit RGBA, 4 bytes per pixel */
+    RGBA = 4
 }
 /**
  * Fill rule for outline rendering

package/dist/render/path.d.ts

@@ -73,6 +73,21 @@ export declare function pathToSVG(path: GlyphPath, options?: {
     flipY?: boolean;
     scale?: number;
 }): string;
+/**
+ * Render options for stroke/fill
+ */
+export interface RenderOptions {
+    flipY?: boolean;
+    scale?: number;
+    offsetX?: number;
+    offsetY?: number;
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+    lineCap?: CanvasLineCap;
+    lineJoin?: CanvasLineJoin;
+    miterLimit?: number;
+}
 /**
  * Render path commands to a Canvas 2D context
  */
@@ -88,6 +103,8 @@ export declare function pathToCanvas(ctx: CanvasRenderingContext2D | Path2D, pat
 export declare function glyphToSVG(font: Font, glyphId: GlyphId, options?: {
     fontSize?: number;
     fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
 }): string | null;
 /**
  * Render shaped text to Canvas
@@ -104,6 +121,10 @@ export declare function renderShapedText(ctx: CanvasRenderingContext2D, font: Fo
     x?: number;
     y?: number;
     fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+    lineCap?: CanvasLineCap;
+    lineJoin?: CanvasLineJoin;
 }): void;
 /**
  * Generate SVG for shaped text
@@ -111,6 +132,10 @@ export declare function renderShapedText(ctx: CanvasRenderingContext2D, font: Fo
 export declare function shapedTextToSVG(font: Font, glyphs: ShapedGlyph[], options?: {
     fontSize?: number;
     fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+    lineCap?: "butt" | "round" | "square";
+    lineJoin?: "miter" | "round" | "bevel";
 }): string;
 /**
  * Convert GlyphBuffer output to ShapedGlyph array
@@ -128,6 +153,10 @@ export declare function renderShapedTextWithVariation(ctx: CanvasRenderingContex
     x?: number;
     y?: number;
     fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+    lineCap?: CanvasLineCap;
+    lineJoin?: CanvasLineJoin;
 }): void;
 /**
  * Generate SVG for shaped text with variable font support
@@ -135,6 +164,10 @@ export declare function renderShapedTextWithVariation(ctx: CanvasRenderingContex
 export declare function shapedTextToSVGWithVariation(font: Font, glyphs: ShapedGlyph[], axisCoords: number[], options?: {
     fontSize?: number;
     fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+    lineCap?: "butt" | "round" | "square";
+    lineJoin?: "miter" | "round" | "bevel";
 }): string;
 /**
  * Calculate the total advance width of shaped text

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "text-shaper",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "devDependencies": {