@mlightcad/mtext-parser 1.0.0

package/dist/parser.d.ts

@@ -0,0 +1,449 @@
+/**
+ * Token types used in MText parsing
+ */
+export declare enum TokenType {
+    /** No token */
+    NONE = 0,
+    /** Word token with string data */
+    WORD = 1,
+    /** Stack token with [numerator, denominator, type] data */
+    STACK = 2,
+    /** Space token with no data */
+    SPACE = 3,
+    /** Non-breaking space token with no data */
+    NBSP = 4,
+    /** Tab token with no data */
+    TABULATOR = 5,
+    /** New paragraph token with no data */
+    NEW_PARAGRAPH = 6,
+    /** New column token with no data */
+    NEW_COLUMN = 7,
+    /** Wrap at dimension line token with no data */
+    WRAP_AT_DIMLINE = 8,
+    /** Properties changed token with string data (full command) */
+    PROPERTIES_CHANGED = 9
+}
+/**
+ * Type for token data based on token type
+ */
+export type TokenData = {
+    [TokenType.NONE]: null;
+    [TokenType.WORD]: string;
+    [TokenType.STACK]: [string, string, string];
+    [TokenType.SPACE]: null;
+    [TokenType.NBSP]: null;
+    [TokenType.TABULATOR]: null;
+    [TokenType.NEW_PARAGRAPH]: null;
+    [TokenType.NEW_COLUMN]: null;
+    [TokenType.WRAP_AT_DIMLINE]: null;
+    [TokenType.PROPERTIES_CHANGED]: string;
+};
+/**
+ * Line alignment options for MText
+ */
+export declare enum MTextLineAlignment {
+    /** Align text to bottom */
+    BOTTOM = 0,
+    /** Align text to middle */
+    MIDDLE = 1,
+    /** Align text to top */
+    TOP = 2
+}
+/**
+ * Paragraph alignment options for MText
+ */
+export declare enum MTextParagraphAlignment {
+    /** Default alignment */
+    DEFAULT = 0,
+    /** Left alignment */
+    LEFT = 1,
+    /** Right alignment */
+    RIGHT = 2,
+    /** Center alignment */
+    CENTER = 3,
+    /** Justified alignment */
+    JUSTIFIED = 4,
+    /** Distributed alignment */
+    DISTRIBUTED = 5
+}
+/**
+ * Text stroke options for MText
+ */
+export declare enum MTextStroke {
+    /** No stroke */
+    NONE = 0,
+    /** Underline stroke */
+    UNDERLINE = 1,
+    /** Overline stroke */
+    OVERLINE = 2,
+    /** Strike-through stroke */
+    STRIKE_THROUGH = 4
+}
+/**
+ * RGB color tuple
+ */
+export type RGB = [number, number, number];
+/**
+ * Font face properties
+ */
+export interface FontFace {
+    /** Font family name */
+    family: string;
+    /** Font style (e.g., 'Regular', 'Italic') */
+    style: string;
+    /** Font weight (e.g., 400 for normal, 700 for bold) */
+    weight: number;
+}
+/**
+ * Font measurement properties
+ */
+export interface FontMeasurements {
+    /** Height of capital letters */
+    cap_height: number;
+    /** Baseline position */
+    baseline: number;
+    /** Bottom position */
+    bottom: number;
+    /** Top position */
+    top: number;
+    /** Total height of the font */
+    total_height: number;
+    /**
+     * Scale measurements by a factor
+     * @param factor - The scaling factor
+     * @returns New scaled measurements
+     */
+    scale(factor: number): FontMeasurements;
+}
+/**
+ * Abstract font interface
+ */
+export interface AbstractFont {
+    /**
+     * Calculate text width
+     * @param text - The text to measure
+     * @returns Width of the text
+     */
+    text_width(text: string): number;
+    /**
+     * Get width of a space character
+     * @returns Width of a space
+     */
+    space_width(): number;
+    /** Font measurements */
+    measurements: FontMeasurements;
+}
+/**
+ * Paragraph properties
+ */
+export interface ParagraphProperties {
+    /** Indentation value */
+    indent: number;
+    /** Left margin value */
+    left: number;
+    /** Right margin value */
+    right: number;
+    /** Paragraph alignment */
+    align: MTextParagraphAlignment;
+    /** Tab stop positions and types */
+    tab_stops: (number | string)[];
+}
+/**
+ * Convert RGB tuple to integer color value
+ * @param rgb - RGB color tuple
+ * @returns Integer color value
+ */
+export declare function rgb2int(rgb: RGB): number;
+/**
+ * Convert integer color value to RGB tuple
+ * @param value - Integer color value
+ * @returns RGB color tuple
+ */
+export declare function int2rgb(value: number): RGB;
+/**
+ * DXF stores some special characters using caret notation. This function
+ * decodes this notation to normalize the representation of special characters
+ * in the string.
+ * see: https://en.wikipedia.org/wiki/Caret_notation
+ * @param text - Text to decode
+ * @returns Decoded text
+ */
+export declare function caretDecode(text: string): string;
+/**
+ * Escape DXF line endings
+ * @param text - Text to escape
+ * @returns Escaped text
+ */
+export declare function escapeDxfLineEndings(text: string): string;
+/**
+ * Check if text contains inline formatting codes
+ * @param text - Text to check
+ * @returns True if text contains formatting codes
+ */
+export declare function hasInlineFormattingCodes(text: string): boolean;
+/**
+ * Main parser class for MText content
+ */
+export declare class MTextParser {
+    private scanner;
+    private ctx;
+    private ctxStack;
+    private continueStroke;
+    private yieldPropertyCommands;
+    /**
+     * Creates a new MTextParser instance
+     * @param content - The MText content to parse
+     * @param ctx - Optional initial MText context
+     * @param yieldPropertyCommands - Whether to yield property change commands
+     */
+    constructor(content: string, ctx?: MTextContext, yieldPropertyCommands?: boolean);
+    /**
+     * Push current context onto the stack
+     */
+    private pushCtx;
+    /**
+     * Pop context from the stack
+     */
+    private popCtx;
+    /**
+     * Parse stacking expression (numerator/denominator)
+     * @returns Tuple of [TokenType.STACK, [numerator, denominator, type]]
+     */
+    private parseStacking;
+    /**
+     * Parse MText properties
+     * @param cmd - The property command to parse
+     */
+    private parseProperties;
+    /**
+     * Parse alignment property
+     * @param ctx - The context to update
+     */
+    private parseAlign;
+    /**
+     * Parse height property
+     * @param ctx - The context to update
+     */
+    private parseHeight;
+    /**
+     * Parse width property
+     * @param ctx - The context to update
+     */
+    private parseWidth;
+    /**
+     * Parse character tracking property
+     * @param ctx - The context to update
+     */
+    private parseCharTracking;
+    /**
+     * Parse float value or factor
+     * @param value - Current value to apply factor to
+     * @returns New value
+     */
+    private parseFloatValueOrFactor;
+    /**
+     * Parse oblique angle property
+     * @param ctx - The context to update
+     */
+    private parseOblique;
+    /**
+     * Parse ACI color property
+     * @param ctx - The context to update
+     */
+    private parseAciColor;
+    /**
+     * Parse RGB color property
+     * @param ctx - The context to update
+     */
+    private parseRgbColor;
+    /**
+     * Extract float expression from scanner
+     * @param relative - Whether to allow relative values (ending in 'x')
+     * @returns Extracted expression
+     */
+    private extractFloatExpression;
+    /**
+     * Extract integer expression from scanner
+     * @returns Extracted expression
+     */
+    private extractIntExpression;
+    /**
+     * Extract expression until semicolon or end
+     * @param escape - Whether to handle escaped semicolons
+     * @returns Extracted expression
+     */
+    private extractExpression;
+    /**
+     * Parse font properties
+     * @param ctx - The context to update
+     */
+    private parseFontProperties;
+    /**
+     * Parse paragraph properties from the MText content
+     * Handles properties like indentation, alignment, and tab stops
+     * @param ctx - The context to update
+     */
+    private parseParagraphProperties;
+    /**
+     * Consume optional terminator (semicolon)
+     */
+    private consumeOptionalTerminator;
+    /**
+     * Parse MText content into tokens
+     * @yields MTextToken objects
+     */
+    parse(): Generator<MTextToken>;
+}
+/**
+ * Text scanner for parsing MText content
+ */
+export declare class TextScanner {
+    private text;
+    private textLen;
+    private _index;
+    /**
+     * Create a new text scanner
+     * @param text - The text to scan
+     */
+    constructor(text: string);
+    /**
+     * Get the current index in the text
+     */
+    get currentIndex(): number;
+    /**
+     * Check if the scanner has reached the end of the text
+     */
+    get isEmpty(): boolean;
+    /**
+     * Check if there is more text to scan
+     */
+    get hasData(): boolean;
+    /**
+     * Get the next character and advance the index
+     * @returns The next character, or empty string if at end
+     */
+    get(): string;
+    /**
+     * Advance the index by the specified count
+     * @param count - Number of characters to advance
+     */
+    consume(count?: number): void;
+    /**
+     * Look at a character without advancing the index
+     * @param offset - Offset from current position
+     * @returns The character at the offset position, or empty string if out of bounds
+     */
+    peek(offset?: number): string;
+    /**
+     * Find the next occurrence of a character
+     * @param char - The character to find
+     * @param escape - Whether to handle escaped characters
+     * @returns Index of the character, or -1 if not found
+     */
+    find(char: string, escape?: boolean): number;
+    /**
+     * Get the remaining text from the current position
+     */
+    get tail(): string;
+    /**
+     * Check if the next character is a space
+     */
+    isNextSpace(): boolean;
+    /**
+     * Consume spaces until a non-space character is found
+     * @returns Number of spaces consumed
+     */
+    consumeSpaces(): number;
+}
+/**
+ * MText context class for managing text formatting state
+ */
+export declare class MTextContext {
+    private _stroke;
+    /** Whether to continue stroke formatting */
+    continueStroke: boolean;
+    private _aci;
+    /** RGB color value, or null if using ACI */
+    rgb: RGB | null;
+    /** Line alignment */
+    align: MTextLineAlignment;
+    /** Font face properties */
+    fontFace: FontFace;
+    /** Capital letter height */
+    capHeight: number;
+    /** Character width factor */
+    widthFactor: number;
+    /** Character tracking factor */
+    charTrackingFactor: number;
+    /** Oblique angle */
+    oblique: number;
+    /** Paragraph properties */
+    paragraph: ParagraphProperties;
+    /**
+     * Get the ACI color value
+     */
+    get aci(): number;
+    /**
+     * Set the ACI color value
+     * @param value - ACI color value (0-256)
+     * @throws Error if value is out of range
+     */
+    set aci(value: number);
+    /**
+     * Get whether text is underlined
+     */
+    get underline(): boolean;
+    /**
+     * Set whether text is underlined
+     * @param value - Whether to underline
+     */
+    set underline(value: boolean);
+    /**
+     * Get whether text has strike-through
+     */
+    get strikeThrough(): boolean;
+    /**
+     * Set whether text has strike-through
+     * @param value - Whether to strike through
+     */
+    set strikeThrough(value: boolean);
+    /**
+     * Get whether text has overline
+     */
+    get overline(): boolean;
+    /**
+     * Set whether text has overline
+     * @param value - Whether to overline
+     */
+    set overline(value: boolean);
+    /**
+     * Check if any stroke formatting is active
+     */
+    get hasAnyStroke(): boolean;
+    /**
+     * Set the state of a stroke type
+     * @param stroke - The stroke type to set
+     * @param state - Whether to enable or disable the stroke
+     */
+    private _setStrokeState;
+    /**
+     * Create a copy of this context
+     * @returns A new context with the same properties
+     */
+    copy(): MTextContext;
+}
+/**
+ * Token class for MText parsing
+ */
+export declare class MTextToken {
+    type: TokenType;
+    ctx: MTextContext;
+    data: TokenData[TokenType];
+    /**
+     * Create a new MText token
+     * @param type - The token type
+     * @param ctx - The text context at this token
+     * @param data - Optional token data
+     */
+    constructor(type: TokenType, ctx: MTextContext, data: TokenData[TokenType]);
+}