@unmade/text-renderer 1.1.0 → 1.1.1

package/dist/worker/glyph/svg-glyph-converter.d.ts

@@ -0,0 +1,42 @@
+import { LoadedFont } from '../loading';
+import { ColourInfo, ColourMap, GlyphFill } from '../types';
+/**
+ * Get the unique colours used by a font's SVG glyphs.
+ *
+ * @param font - A loaded font with svgGlyphs populated
+ * @returns Array of unique hex colour strings found in the font's SVG glyphs
+ */
+export declare function getFontColours(font: LoadedFont): string[];
+/**
+ * Extract fill paths from SVG content with optional colour remapping.
+ *
+ * @param svgContent - Raw SVG string from the font's SVG table
+ * @param colourMap - Optional mapping of original colours to replacements
+ * @returns Array of GlyphFill objects
+ */
+export declare function extractFillsFromSVG(svgContent: string, colourMap?: ColourMap): GlyphFill[];
+/**
+ * Apply colour map to remap a colour value.
+ *
+ * @param colour - Original colour hex string
+ * @param colourMap - Optional colour replacement mapping
+ * @returns ColourInfo with hex and optional reference
+ */
+export declare function applyColourMap(colour: string, colourMap?: ColourMap): ColourInfo;
+/**
+ * Extract the inner content from a raw SVG glyph string.
+ * Strips the XML declaration and outer <svg> wrapper, returning the inner elements.
+ */
+export declare function extractSvgGlyphContent(rawSvg: string): string;
+/**
+ * Namespace all IDs in SVG content to prevent collisions when multiple
+ * glyphs are embedded in the same document. Prefixes all id attributes
+ * and updates all references (href, url(), clip-path, mask, filter).
+ */
+export declare function namespaceSvgIds(svgContent: string, prefix: string): string;
+/**
+ * Remap colour values in raw SVG content. Replaces fill, stroke,
+ * and stop-color attribute values according to the colour map.
+ * Also handles elements without explicit fill that default to black.
+ */
+export declare function remapSvgColours(svgContent: string, colourMap: ColourMap): string;

package/dist/worker/helpers/bbox.d.ts

@@ -0,0 +1,33 @@
+export declare class Box {
+    corners: DOMPoint[];
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    _x3: number | undefined;
+    _y3: number | undefined;
+    _x4: number | undefined;
+    _y4: number | undefined;
+    get x3(): number;
+    get y3(): number;
+    get x4(): number;
+    get y4(): number;
+    constructor(x1: number, y1: number, x2: number, y2: number, x3?: number, y3?: number, x4?: number, y4?: number);
+    transform(matrix: DOMMatrix): void;
+    toPointsArray(): number[][];
+    getBBox(): BBox;
+}
+export declare class BBox extends Box {
+    get x(): number;
+    get y(): number;
+    get width(): number;
+    get height(): number;
+    add(box: Box): void;
+    addPoint(x: number, y: number): void;
+    serialize(): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}

package/dist/worker/helpers/matrix.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Create a matrix with optional initial values
+ * Detects what style of matrix is supported by the browser
+ *
+ * @param {Array} initialValues - the initial values for the matrix
+ * @returns {DOMMatrix} the new matrix
+ */
+export declare const createMatrix: (initialValues?: number[]) => DOMMatrix;

package/dist/worker/helpers/point.d.ts

@@ -0,0 +1,17 @@
+export declare class Point {
+    private x;
+    private y;
+    constructor(x: number, y: number);
+    get X(): number;
+    get Y(): number;
+    toSVGString(): string;
+}
+/**
+ * Rotate a point about a pivot point
+ *
+ * @param point - the point to rotate
+ * @param rotate - the amount in degrees
+ * @param pivotPoint - the point around which to rotate
+ * @returns the new point
+ */
+export declare function rotatePoint(point: Point, rotate: number, pivotPoint?: Point): Point;

package/dist/worker/helpers/xml.d.ts

@@ -0,0 +1 @@
+export declare function escapeXML(str: string): string;

package/dist/worker/index.d.ts

@@ -1,249 +1,16 @@
-export declare type BaselineConfig = {
-    type: 'flat';
-} | {
-    type: 'curved';
-} | {
-    type: 'custom';
-    path: string;
-};
-
-export declare type BaselineType = 'flat' | 'curved';
-
-export declare type BoxDimensions = {
-    width: number;
-    height: number;
-    physicalWidth: number;
-    physicalHeight: number;
-    physicalUnits: MeasurementUnits;
-};
-
-export declare interface ColourInfo {
-    readonly hex: string;
-    readonly reference?: string;
-}
-
-/** Maps original hex colour → replacement ColourInfo. */
-export declare type ColourMap = Readonly<Record<string, ColourInfo>>;
-
-export declare const DEFAULT_OUTLINE_FACTOR = 0.03125;
-
-export declare const DEFAULT_SPACING: TextSpacing;
-
-/**
- * Generate a path command to curve text and align that text to the top of the box.
- * Uses two quadratic bezier curves — one from the bottom left to the peak, and a
- * second mirrored from the peak to the end.
- *
- * Curved text is not currently supported for multiline text.
- *
- * @returns an SVG path command to draw the curve
- */
-export declare const generateCurvedBaseline: ({ boxDimensions, baseline, textHeight, verticalAlignment, }: GenerateCurvedBaselineOptions) => string;
-
-export declare interface GenerateCurvedBaselineOptions {
-    boxDimensions: BoxDimensions;
-    baseline: number;
-    textHeight: number;
-    verticalAlignment: VerticalTextAlignmentValues;
-}
-
-/**
- * Generate a path as a baseline for straight text
- * This can be called multiple times for multiline text by incrementing the lineNumber parameter
- *
- * @returns an SVG path command to draw the baseline
- */
-export declare const generateFlatBaseline: ({ boxDimensions, totalTextHeight, baseline, lineHeight, verticalAlignment, lineNumber, }: GenerateFlatBaselineOptions) => string;
-
-export declare interface GenerateFlatBaselineOptions {
-    boxDimensions: BoxDimensions;
-    totalTextHeight: number;
-    baseline: number;
-    lineHeight: number;
-    verticalAlignment?: VerticalTextAlignmentValues;
-    lineNumber?: number;
-}
-
-export declare const getFontCache: () => Map<string, LoadedFont>;
-
-/**
- * Get the unique colours used by a font's SVG glyphs.
- *
- * @param font - A loaded font with svgGlyphs populated
- * @returns Array of unique hex colour strings found in the font's SVG glyphs
- */
-export declare function getFontColours(font: LoadedFont): string[];
-
-export declare const getFontSizeFromPhysicalSize: ({ font, boxDimensions, physicalSize, spacing, }: GetFontSizeFromPhysicalSizeOptions) => number;
-
-export declare interface GetFontSizeFromPhysicalSizeOptions {
-    font: LoadedFont;
-    boxDimensions: BoxDimensions;
-    physicalSize: PhysicalSize;
-    spacing?: TextSpacing;
-}
-
-/**
- * Async text renderer. Loads font from URL, then delegates to renderText.
- *
- * If the calculated font size causes a TOO_WIDE error and fontSizeFallback is
- * provided, retries once using the fallback as an explicit fontSize override.
- */
-export declare const getRenderedText: (options: GetRenderedTextOptions) => Promise<string>;
-
-/** Options for async getRenderedText (loads font from URL). */
-export declare interface GetRenderedTextOptions {
-    text: string;
-    fontUrl: string;
-    physicalSize: PhysicalSize;
-    /**
-     * Fallback font size (in pixels) to use if the calculated size causes a
-     * TOO_WIDE error. Useful when the caller has an authoritative size (e.g.
-     * from the CE) that avoids floating-point rounding issues.
-     */
-    fontSizeFallback?: number;
-    boxDimensions: BoxDimensions;
-    spacing?: TextSpacing;
-    verticalAlignment?: VerticalTextAlignmentValues;
-    baseline?: BaselineType | BaselineConfig;
-    horizontalAlignment?: HorizontalTextAlignmentValues;
-    fillColour?: ColourInfo;
-    strokeColour?: ColourInfo;
-    colourMap?: ColourMap;
-}
-
-export declare interface GetTextAsPathDataOptions {
-    font: LoadedFont;
-    baselinePath: string;
-    text: string;
-    fontSize: number;
-    spacing?: TextSpacing;
-    horizontalAlignment?: HorizontalTextAlignmentValues;
-    colourMap?: ColourMap;
-}
-
-export declare const getTextMetricsAtFontSize: ({ font, text, fontSize, spacing, }: GetTextMetricsAtFontSizeOptions) => {
-    width: number;
-    height: number;
-    baseline: number;
-};
-
-export declare interface GetTextMetricsAtFontSizeOptions {
-    font: LoadedFont;
-    text: string;
-    fontSize: number;
-    spacing?: TextSpacing;
-}
-
-export declare interface GlyphFill {
-    readonly pathData: string;
-    readonly colour: ColourInfo;
-}
-
-export declare type HorizontalTextAlignmentValues = 'left' | 'centre' | 'right' | 'distributed';
-
-export declare const LINE_HEIGHT = 1.1;
-
-export declare interface LoadedFont {
-    unitsPerEm: number;
-    names: {
-        fontFamily: string;
-    };
-    svgGlyphs?: Map<number, SVGGlyphData>;
-    charToGlyph(char: string): {
-        index: number;
-        advanceWidth: number;
-        name: string;
-        getBoundingBox(): {
-            x1: number;
-            y1: number;
-            x2: number;
-            y2: number;
-        };
-    };
-    getPath(text: string, x: number, y: number, fontSize: number, options?: {
-        drawSVG?: boolean;
-    }): {
-        getBoundingBox(): {
-            x1: number;
-            y1: number;
-            x2: number;
-            y2: number;
-        };
-        toPathData(decimals?: number): string;
-    };
-    getPaths(text: string, x: number, y: number, fontSize: number, options?: {
-        drawSVG?: boolean;
-    }): Array<{
-        getBoundingBox(): {
-            x1: number;
-            y1: number;
-            x2: number;
-            y2: number;
-        };
-        toPathData(decimals?: number): string;
-    }>;
-}
-
-export declare const loadFont: (fontUrl: string, fetchSVGGlyphs?: boolean) => Promise<LoadedFont>;
-
-export declare type MeasurementUnits = 'mm' | 'in';
-
-/**
- * Normalise a baseline option (string shorthand or object) into a BaselineConfig.
- */
-export declare const normaliseBaselineOption: (baseline: BaselineType | BaselineConfig | undefined) => BaselineConfig;
-
-export declare type PhysicalSize = [height: number, units: MeasurementUnits];
-
-/**
- * Synchronous text renderer. Requires a pre-loaded font.
- */
-export declare const renderText: (options: RenderTextOptions) => string;
-
-/** Options for synchronous renderText (font already loaded). */
-export declare interface RenderTextOptions {
-    text: string;
-    font: LoadedFont;
-    physicalSize: PhysicalSize;
-    /** When provided, bypasses the physicalSize → font size calculation. */
-    fontSize?: number;
-    boxDimensions: BoxDimensions;
-    spacing?: TextSpacing;
-    verticalAlignment?: VerticalTextAlignmentValues;
-    baseline?: BaselineType | BaselineConfig;
-    horizontalAlignment?: HorizontalTextAlignmentValues;
-    fillColour?: ColourInfo;
-    strokeColour?: ColourInfo;
-    colourMap?: ColourMap;
-}
-
-declare interface SVGGlyphData {
-    svg: string;
-    viewbox: string;
-}
-
-export declare interface SvgGlyphEntry {
-    content: string;
-    viewBox: string;
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    glyphIndex: number;
-}
-
-export declare interface TextSpacing {
-    readonly outlineWidth: number;
-    readonly letterSpacing: number;
-    readonly letterSpacingOutline: number;
-}
-
-/**
- * Validate a custom baseline SVG path string.
- */
-export declare const validateCustomBaselinePath: (path: string) => void;
-
-export declare type VerticalTextAlignmentValues = 'centre' | 'top' | 'bottom';
-
-export { }
+import { GetRenderedTextOptions } from './types';
+export { type GenerateCurvedBaselineOptions, type GenerateFlatBaselineOptions, generateCurvedBaseline, generateFlatBaseline, normaliseBaselineOption, validateCustomBaselinePath, } from './baselines';
+export { DEFAULT_OUTLINE_FACTOR, DEFAULT_SPACING, LINE_HEIGHT, } from './constants';
+export { getFontColours } from './glyph/svg-glyph-converter';
+export { getFontCache, type LoadedFont, loadFont } from './loading';
+export { type GetFontSizeFromPhysicalSizeOptions, type GetTextMetricsAtFontSizeOptions, getFontSizeFromPhysicalSize, getTextMetricsAtFontSize, } from './measuring';
+export type { GetTextAsPathDataOptions, SvgGlyphEntry } from './rendering';
+export { renderText } from './renderText';
+export type { BaselineConfig, BaselineType, BoxDimensions, ColourInfo, ColourMap, GetRenderedTextOptions, GlyphFill, HorizontalTextAlignmentValues, MeasurementUnits, PhysicalSize, RenderTextOptions, TextSpacing, VerticalTextAlignmentValues, } from './types';
+/**
+ * Async text renderer. Loads font from URL, then delegates to renderText.
+ *
+ * If the calculated font size causes a TOO_WIDE error and fontSizeFallback is
+ * provided, retries once using the fallback as an explicit fontSize override.
+ */
+export declare const getRenderedText: (options: GetRenderedTextOptions) => Promise<string>;