@mentra/sdk 2.1.29-beta.1 → 2.1.30-beta.1

package/dist/display-utils/measurer/TextMeasurer.d.ts

@@ -0,0 +1,160 @@
+import type { DisplayProfile, ScriptType } from "../profiles/types";
+/**
+ * Character measurement result with detailed breakdown.
+ */
+export interface CharMeasurement {
+    /** The character measured */
+    char: string;
+    /** Width in rendered pixels */
+    widthPx: number;
+    /** The script type of the character */
+    script: ScriptType;
+    /** Whether width came from glyph map (true) or fallback (false) */
+    fromGlyphMap: boolean;
+}
+/**
+ * Text measurement result with detailed breakdown.
+ */
+export interface TextMeasurement {
+    /** The text measured */
+    text: string;
+    /** Total width in rendered pixels */
+    totalWidthPx: number;
+    /** Number of characters */
+    charCount: number;
+    /** Per-character measurements (optional, for debugging) */
+    chars?: CharMeasurement[];
+}
+/**
+ * Measures text width in pixels based on a DisplayProfile.
+ * All measurements are in actual rendered pixels, not abstract units.
+ *
+ * Key features:
+ * - Pixel-perfect measurement for mapped characters
+ * - Uniform-width handling for CJK, Korean, Cyrillic
+ * - Safe fallback for unmapped Latin characters
+ * - Caching for performance
+ */
+export declare class TextMeasurer {
+    private readonly profile;
+    private readonly charCache;
+    constructor(profile: DisplayProfile);
+    /**
+     * Pre-compute rendered widths for all known glyphs.
+     */
+    private buildCharCache;
+    /**
+     * Measure the total pixel width of a text string.
+     *
+     * @param text - The text to measure
+     * @returns Width in rendered pixels
+     */
+    measureText(text: string): number;
+    /**
+     * Measure text with detailed breakdown of each character.
+     *
+     * @param text - The text to measure
+     * @returns Detailed measurement result
+     */
+    measureTextDetailed(text: string): TextMeasurement;
+    /**
+     * Measure a single character's pixel width.
+     *
+     * IMPORTANT: This is PIXEL-PERFECT measurement, not averaging!
+     * - Mapped characters: exact width from glyph map
+     * - Uniform scripts (CJK, Korean, Cyrillic): verified uniform width
+     * - Unmapped Latin: MAX width fallback (safe, never overflow)
+     *
+     * @param char - Single character to measure
+     * @returns Width in rendered pixels
+     */
+    measureChar(char: string): number;
+    /**
+     * Calculate character width (called when not in cache).
+     */
+    private calculateCharWidth;
+    /**
+     * Get the raw glyph width (before render formula).
+     * Returns undefined for unmapped characters.
+     *
+     * @param char - Single character
+     * @returns Glyph width in pixels, or undefined if not in glyph map
+     */
+    getGlyphWidth(char: string): number | undefined;
+    /**
+     * Check if text fits within a pixel width.
+     *
+     * @param text - Text to check
+     * @param maxWidthPx - Maximum width in pixels
+     * @returns true if text fits
+     */
+    fitsInWidth(text: string, maxWidthPx: number): boolean;
+    /**
+     * Find how many characters fit within a pixel width.
+     *
+     * @param text - Text to measure
+     * @param maxWidthPx - Maximum width in pixels
+     * @param startIndex - Starting index (default: 0)
+     * @returns Number of characters that fit
+     */
+    charsThatFit(text: string, maxWidthPx: number, startIndex?: number): number;
+    /**
+     * Find the pixel position of a character index in text.
+     *
+     * @param text - Text to measure
+     * @param index - Character index
+     * @returns Pixel offset from start of text
+     */
+    getPixelOffset(text: string, index: number): number;
+    /**
+     * Detect the script type of a character.
+     *
+     * @param char - Single character
+     * @returns Script type
+     */
+    detectScript(char: string): ScriptType;
+    /**
+     * Check if a character is from a uniform-width script.
+     *
+     * @param char - Single character
+     * @returns true if character is from CJK, Korean, or Cyrillic
+     */
+    isUniformWidth(char: string): boolean;
+    /**
+     * Get the display profile.
+     */
+    getProfile(): DisplayProfile;
+    /**
+     * Get the display width in pixels.
+     */
+    getDisplayWidthPx(): number;
+    /**
+     * Get the maximum number of lines.
+     */
+    getMaxLines(): number;
+    /**
+     * Get the maximum payload size in bytes.
+     */
+    getMaxPayloadBytes(): number;
+    /**
+     * Calculate the UTF-8 byte size of text.
+     *
+     * @param text - Text to measure
+     * @returns Byte size
+     */
+    getByteSize(text: string): number;
+    /**
+     * Get the width of a hyphen character in rendered pixels.
+     */
+    getHyphenWidth(): number;
+    /**
+     * Get the width of a space character in rendered pixels.
+     */
+    getSpaceWidth(): number;
+    /**
+     * Clear the character cache.
+     * Useful if profile metrics change at runtime.
+     */
+    clearCache(): void;
+}
+//# sourceMappingURL=TextMeasurer.d.ts.map

package/dist/display-utils/measurer/TextMeasurer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TextMeasurer.d.ts","sourceRoot":"","sources":["../../../src/display-utils/measurer/TextMeasurer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAGnE;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,6BAA6B;IAC7B,IAAI,EAAE,MAAM,CAAA;IACZ,+BAA+B;IAC/B,OAAO,EAAE,MAAM,CAAA;IACf,uCAAuC;IACvC,MAAM,EAAE,UAAU,CAAA;IAClB,mEAAmE;IACnE,YAAY,EAAE,OAAO,CAAA;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,wBAAwB;IACxB,IAAI,EAAE,MAAM,CAAA;IACZ,qCAAqC;IACrC,YAAY,EAAE,MAAM,CAAA;IACpB,2BAA2B;IAC3B,SAAS,EAAE,MAAM,CAAA;IACjB,2DAA2D;IAC3D,KAAK,CAAC,EAAE,eAAe,EAAE,CAAA;CAC1B;AAED;;;;;;;;;GASG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAgB;IACxC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAiC;gBAE/C,OAAO,EAAE,cAAc;IAMnC;;OAEG;IACH,OAAO,CAAC,cAAc;IAStB;;;;;OAKG;IACH,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAYjC;;;;;OAKG;IACH,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe;IAoClD;;;;;;;;;;OAUG;IACH,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAoBjC;;OAEG;IACH,OAAO,CAAC,kBAAkB;IA+B1B;;;;;;OAMG;IACH,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAI/C;;;;;;OAMG;IACH,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO;IAItD;;;;;;;OAOG;IACH,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,GAAE,MAAU,GAAG,MAAM;IAyB9E;;;;;;OAMG;IACH,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM;IAenD;;;;;OAKG;IACH,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU;IAItC;;;;;OAKG;IACH,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAIrC;;OAEG;IACH,UAAU,IAAI,cAAc;IAI5B;;OAEG;IACH,iBAAiB,IAAI,MAAM;IAI3B;;OAEG;IACH,WAAW,IAAI,MAAM;IAIrB;;OAEG;IACH,kBAAkB,IAAI,MAAM;IAI5B;;;;;OAKG;IACH,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAIjC;;OAEG;IACH,cAAc,IAAI,MAAM;IAIxB;;OAEG;IACH,aAAa,IAAI,MAAM;IAIvB;;;OAGG;IACH,UAAU,IAAI,IAAI;CAInB"}

package/dist/display-utils/measurer/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Text Measurer Module
+ *
+ * Provides pixel-accurate text measurement based on display profiles.
+ * All measurements are in actual rendered pixels, not abstract units.
+ */
+export { TextMeasurer } from "./TextMeasurer";
+export type { CharMeasurement, TextMeasurement } from "./TextMeasurer";
+export { detectScript, isCJKCharacter, isKoreanCharacter, isUniformWidthScript, isUnsupportedScript, needsHyphenForBreak, SCRIPT_RANGES, } from "./script-detection";
+//# sourceMappingURL=index.d.ts.map

package/dist/display-utils/measurer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/display-utils/measurer/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAC7C,YAAY,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAGtE,OAAO,EACL,YAAY,EACZ,cAAc,EACd,iBAAiB,EACjB,oBAAoB,EACpB,mBAAmB,EACnB,mBAAmB,EACnB,aAAa,GACd,MAAM,oBAAoB,CAAA"}

package/dist/display-utils/measurer/script-detection.d.ts

@@ -0,0 +1,53 @@
+import type { ScriptType } from "../profiles/types";
+/**
+ * Unicode ranges for script detection.
+ * Used to classify characters for proper width measurement.
+ */
+export declare const SCRIPT_RANGES: {
+    readonly cjk: readonly [readonly [19968, 40959], readonly [13312, 19903], readonly [131072, 173791], readonly [173824, 177983], readonly [177984, 178207], readonly [63744, 64255]];
+    readonly hiragana: readonly [readonly [12352, 12447]];
+    readonly katakana: readonly [readonly [12448, 12543], readonly [12784, 12799]];
+    readonly korean: readonly [readonly [44032, 55215], readonly [4352, 4607], readonly [12592, 12687], readonly [43360, 43391], readonly [55216, 55295]];
+    readonly cyrillic: readonly [readonly [1024, 1279], readonly [1280, 1327]];
+    readonly numbers: readonly [readonly [48, 57]];
+    readonly punctuation: readonly [readonly [32, 47], readonly [58, 64], readonly [91, 96], readonly [123, 126]];
+    readonly arabic: readonly [readonly [1536, 1791]];
+    readonly hebrew: readonly [readonly [1424, 1535]];
+    readonly thai: readonly [readonly [3584, 3711]];
+    readonly emoji: readonly [readonly [128512, 128591], readonly [127744, 128511], readonly [128640, 128767], readonly [127456, 127487], readonly [9728, 9983], readonly [9984, 10175], readonly [65024, 65039], readonly [129280, 129535]];
+};
+/**
+ * Detect the script type of a single character.
+ *
+ * @param char - Single character to classify
+ * @returns The script type of the character
+ */
+export declare function detectScript(char: string): ScriptType;
+/**
+ * Check if a character is a CJK character (Chinese, Japanese Kanji).
+ * CJK characters can break anywhere without needing a hyphen.
+ */
+export declare function isCJKCharacter(char: string): boolean;
+/**
+ * Check if a character is Korean Hangul.
+ */
+export declare function isKoreanCharacter(char: string): boolean;
+/**
+ * Check if a character is from a uniform-width script.
+ * These scripts render all characters at the same width.
+ */
+export declare function isUniformWidthScript(char: string): boolean;
+/**
+ * Check if a character is from an unsupported script.
+ * These characters may not render correctly on the glasses.
+ */
+export declare function isUnsupportedScript(char: string): boolean;
+/**
+ * Check if breaking between two characters requires a hyphen.
+ * Returns false for:
+ * - Breaking after CJK characters (can break anywhere)
+ * - Breaking before or after spaces
+ * - Breaking after punctuation
+ */
+export declare function needsHyphenForBreak(charBefore: string, charAfter: string): boolean;
+//# sourceMappingURL=script-detection.d.ts.map

package/dist/display-utils/measurer/script-detection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"script-detection.d.ts","sourceRoot":"","sources":["../../../src/display-utils/measurer/script-detection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,mBAAmB,CAAA;AAEjD;;;GAGG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;CA4DhB,CAAA;AAcV;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CA0DrD;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAGpD;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAK1D;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CA6BlF"}

package/dist/display-utils/profiles/g1.d.ts

@@ -0,0 +1,33 @@
+import { DisplayProfile } from "./types";
+/**
+ * Even Realities G1 Smart Glasses Display Profile
+ *
+ * Verified through empirical testing with actual hardware.
+ * See: line-width-debug-tool/line-width-spec.md
+ */
+export declare const G1_PROFILE: DisplayProfile;
+/**
+ * G1 Profile for LEGACY mobile clients that have their own wrapping logic.
+ *
+ * Old mobile clients re-wrap text received from the cloud, causing double-wrapping.
+ * This profile uses a reduced display width (~522px instead of 576px) so that
+ * when the mobile client re-wraps, the result still fits within 5 lines.
+ *
+ * Use this profile when:
+ * - Mobile client version < X.X.X (has old wrapping logic)
+ * - You see text getting cut off or exceeding 5 lines
+ *
+ * Once all clients are updated, this can be deprecated.
+ */
+export declare const G1_PROFILE_LEGACY: DisplayProfile;
+/**
+ * Get the hyphen width for G1 in rendered pixels.
+ * Hyphen glyph = 4px → rendered = (4+1)*2 = 10px
+ */
+export declare const G1_HYPHEN_WIDTH_PX = 10;
+/**
+ * Get the space width for G1 in rendered pixels.
+ * Space glyph = 2px → rendered = (2+1)*2 = 6px
+ */
+export declare const G1_SPACE_WIDTH_PX = 6;
+//# sourceMappingURL=g1.d.ts.map

package/dist/display-utils/profiles/g1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"g1.d.ts","sourceRoot":"","sources":["../../../src/display-utils/profiles/g1.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,cAAc,EAAC,MAAM,SAAS,CAAA;AAsHtC;;;;;GAKG;AACH,eAAO,MAAM,UAAU,EAAE,cAgDxB,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,iBAAiB,EAAE,cAoC/B,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,kBAAkB,KAAK,CAAA;AAEpC;;;GAGG;AACH,eAAO,MAAM,iBAAiB,IAAI,CAAA"}

package/dist/display-utils/profiles/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Display Profiles
+ *
+ * Hardware-specific configurations for smart glasses displays.
+ * Each profile defines display dimensions, font metrics, and constraints.
+ */
+export type { DisplayProfile, FontMetrics, UniformScriptWidths, FallbackConfig, DisplayConstraints, ScriptType, } from "./types";
+export { G1_PROFILE, G1_PROFILE_LEGACY, G1_HYPHEN_WIDTH_PX, G1_SPACE_WIDTH_PX } from "./g1";
+//# sourceMappingURL=index.d.ts.map

package/dist/display-utils/profiles/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/display-utils/profiles/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,YAAY,EACV,cAAc,EACd,WAAW,EACX,mBAAmB,EACnB,cAAc,EACd,kBAAkB,EAClB,UAAU,GACX,MAAM,SAAS,CAAA;AAGhB,OAAO,EAAC,UAAU,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,iBAAiB,EAAC,MAAM,MAAM,CAAA"}

package/dist/display-utils/profiles/types.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Display profile for a specific glasses model.
+ * All text measurement and wrapping derives from this configuration.
+ */
+export interface DisplayProfile {
+    /** Unique identifier for this glasses model */
+    id: string;
+    /** Human-readable name */
+    name: string;
+    /** Display width in pixels */
+    displayWidthPx: number;
+    /** Display height in pixels (if applicable) */
+    displayHeightPx?: number;
+    /** Maximum number of lines that can be displayed */
+    maxLines: number;
+    /** Maximum safe payload size in bytes (for BLE transmission) */
+    maxPayloadBytes: number;
+    /** BLE chunk size for transmission */
+    bleChunkSize: number;
+    /** Font metrics for text measurement */
+    fontMetrics: FontMetrics;
+    /** Optional constraints */
+    constraints?: DisplayConstraints;
+}
+/**
+ * Font metrics for pixel-accurate text measurement.
+ */
+export interface FontMetrics {
+    /**
+     * Map of character to glyph width in pixels.
+     * Keys are single characters.
+     */
+    glyphWidths: Map<string, number>;
+    /** Default glyph width for unmapped characters */
+    defaultGlyphWidth: number;
+    /**
+     * Formula to convert glyph width to rendered pixel width.
+     * G1 example: (glyphWidth + 1) * 2
+     */
+    renderFormula: (glyphWidth: number) => number;
+    /**
+     * Uniform-width scripts - verified to render all characters at same width.
+     * These are NOT averages - they are the actual uniform width in RENDERED pixels.
+     */
+    uniformScripts: UniformScriptWidths;
+    /**
+     * Fallback configuration for unmapped characters.
+     */
+    fallback: FallbackConfig;
+}
+/**
+ * Uniform width scripts - these scripts render all characters at the same width.
+ * Values are in RENDERED pixels (after applying renderFormula if applicable).
+ * Verified through hardware testing.
+ */
+export interface UniformScriptWidths {
+    /** Chinese, Japanese Kanji - all chars same width */
+    cjk: number;
+    /** Japanese Hiragana - all chars same width */
+    hiragana: number;
+    /** Japanese Katakana - all chars same width */
+    katakana: number;
+    /** Korean Hangul - all chars same width */
+    korean: number;
+    /** Russian, etc. - all chars same width */
+    cyrillic: number;
+}
+/**
+ * Fallback strategy for unmapped characters.
+ */
+export interface FallbackConfig {
+    /**
+     * Max known Latin width for safe fallback (in rendered pixels).
+     * Using max ensures we never overflow (worst case: slight under-utilization).
+     */
+    latinMaxWidth: number;
+    /** What to do with completely unknown characters */
+    unknownBehavior: "useLatinMax" | "throw" | "filter";
+}
+/**
+ * Optional display constraints.
+ */
+export interface DisplayConstraints {
+    /** Minimum characters before allowing hyphen break */
+    minCharsBeforeHyphen?: number;
+    /** Characters that should not appear at start of line (kinsoku) */
+    noStartChars?: string[];
+    /** Characters that should not appear at end of line (kinsoku) */
+    noEndChars?: string[];
+}
+/**
+ * Script type for character classification.
+ */
+export type ScriptType = "latin" | "cjk" | "hiragana" | "katakana" | "korean" | "cyrillic" | "numbers" | "punctuation" | "unsupported";
+//# sourceMappingURL=types.d.ts.map

package/dist/display-utils/profiles/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/display-utils/profiles/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,+CAA+C;IAC/C,EAAE,EAAE,MAAM,CAAA;IAEV,0BAA0B;IAC1B,IAAI,EAAE,MAAM,CAAA;IAEZ,8BAA8B;IAC9B,cAAc,EAAE,MAAM,CAAA;IAEtB,+CAA+C;IAC/C,eAAe,CAAC,EAAE,MAAM,CAAA;IAExB,oDAAoD;IACpD,QAAQ,EAAE,MAAM,CAAA;IAEhB,gEAAgE;IAChE,eAAe,EAAE,MAAM,CAAA;IAEvB,sCAAsC;IACtC,YAAY,EAAE,MAAM,CAAA;IAEpB,wCAAwC;IACxC,WAAW,EAAE,WAAW,CAAA;IAExB,2BAA2B;IAC3B,WAAW,CAAC,EAAE,kBAAkB,CAAA;CACjC;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B;;;OAGG;IACH,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAEhC,kDAAkD;IAClD,iBAAiB,EAAE,MAAM,CAAA;IAEzB;;;OAGG;IACH,aAAa,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,MAAM,CAAA;IAE7C;;;OAGG;IACH,cAAc,EAAE,mBAAmB,CAAA;IAEnC;;OAEG;IACH,QAAQ,EAAE,cAAc,CAAA;CACzB;AAED;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IAClC,qDAAqD;IACrD,GAAG,EAAE,MAAM,CAAA;IACX,+CAA+C;IAC/C,QAAQ,EAAE,MAAM,CAAA;IAChB,+CAA+C;IAC/C,QAAQ,EAAE,MAAM,CAAA;IAChB,2CAA2C;IAC3C,MAAM,EAAE,MAAM,CAAA;IACd,2CAA2C;IAC3C,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B;;;OAGG;IACH,aAAa,EAAE,MAAM,CAAA;IAErB,oDAAoD;IACpD,eAAe,EAAE,aAAa,GAAG,OAAO,GAAG,QAAQ,CAAA;CACpD;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,sDAAsD;IACtD,oBAAoB,CAAC,EAAE,MAAM,CAAA;IAE7B,mEAAmE;IACnE,YAAY,CAAC,EAAE,MAAM,EAAE,CAAA;IAEvB,iEAAiE;IACjE,UAAU,CAAC,EAAE,MAAM,EAAE,CAAA;CACtB;AAED;;GAEG;AACH,MAAM,MAAM,UAAU,GAClB,OAAO,GACP,KAAK,GACL,UAAU,GACV,UAAU,GACV,QAAQ,GACR,UAAU,GACV,SAAS,GACT,aAAa,GACb,aAAa,CAAA"}

package/dist/display-utils/wrapper/TextWrapper.d.ts

@@ -0,0 +1,94 @@
+import { TextMeasurer } from "../measurer/TextMeasurer";
+import type { WrapOptions, WrapResult } from "./types";
+/**
+ * Wraps text to fit display constraints.
+ *
+ * Supports multiple break modes:
+ * - 'character': Break mid-word with hyphen for 100% line utilization
+ * - 'word': Break at word boundaries, hyphenate only if word > line width
+ * - 'strict-word': Break at word boundaries only, no hyphenation
+ *
+ * Key features:
+ * - Pixel-accurate wrapping (no abstract units)
+ * - Hyphen-aware breaking (accounts for hyphen width)
+ * - CJK support (breaks anywhere without hyphen)
+ * - Preserves explicit newlines
+ * - Respects byte limits for BLE transmission
+ */
+export declare class TextWrapper {
+    private readonly measurer;
+    private readonly defaultOptions;
+    constructor(measurer: TextMeasurer, defaultOptions?: WrapOptions);
+    /**
+     * Wrap text to fit within constraints.
+     *
+     * @param text - Text to wrap (may contain \n for explicit breaks)
+     * @param options - Override default options
+     * @returns Wrap result with lines and metadata
+     */
+    wrap(text: string, options?: WrapOptions): WrapResult;
+    /**
+     * Simple wrap returning just lines (convenience method).
+     *
+     * @param text - Text to wrap
+     * @param options - Override default options
+     * @returns Array of wrapped lines
+     */
+    wrapToLines(text: string, options?: WrapOptions): string[];
+    /**
+     * Check if text needs wrapping.
+     *
+     * @param text - Text to check
+     * @param maxWidthPx - Optional width override
+     * @returns true if text exceeds single line
+     */
+    needsWrap(text: string, maxWidthPx?: number): boolean;
+    /**
+     * Get current default options.
+     */
+    getOptions(): Required<WrapOptions>;
+    /**
+     * Get the measurer instance.
+     */
+    getMeasurer(): TextMeasurer;
+    /**
+     * Wrap a single paragraph (no newlines) according to break mode.
+     */
+    private wrapParagraph;
+    /**
+     * Character break mode: Break mid-word with hyphen for 100% line utilization.
+     */
+    private wrapCharacterMode;
+    /**
+     * Word break mode: Break at word boundaries, hyphenate only if word > line width.
+     */
+    private wrapWordMode;
+    /**
+     * Strict word break mode: Break at word boundaries only, no hyphenation.
+     * Long words will overflow the line.
+     */
+    private wrapStrictWordMode;
+    /**
+     * Split text into words, handling CJK characters specially.
+     * CJK characters are treated as individual "words" since they can break anywhere.
+     */
+    private splitIntoWords;
+    /**
+     * Hyphenate a word that's too long to fit on a single line.
+     */
+    private hyphenateLongWord;
+    /**
+     * Back off characters from line end until hyphen fits.
+     * Returns null if we back off to a space (natural break point - no hyphen needed).
+     */
+    private backoffForHyphen;
+    /**
+     * Merge user options with defaults.
+     */
+    private mergeOptions;
+    /**
+     * Create an empty result for empty input.
+     */
+    private createEmptyResult;
+}
+//# sourceMappingURL=TextWrapper.d.ts.map

package/dist/display-utils/wrapper/TextWrapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TextWrapper.d.ts","sourceRoot":"","sources":["../../../src/display-utils/wrapper/TextWrapper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,YAAY,EAAC,MAAM,0BAA0B,CAAA;AAErD,OAAO,KAAK,EAAC,WAAW,EAAE,UAAU,EAAyB,MAAM,SAAS,CAAA;AAG5E;;;;;;;;;;;;;;GAcG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAc;IACvC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAuB;gBAE1C,QAAQ,EAAE,YAAY,EAAE,cAAc,CAAC,EAAE,WAAW;IAahE;;;;;;OAMG;IACH,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,UAAU;IA2ErD;;;;;;OAMG;IACH,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAI1D;;;;;;OAMG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO;IAKrD;;OAEG;IACH,UAAU,IAAI,QAAQ,CAAC,WAAW,CAAC;IAInC;;OAEG;IACH,WAAW,IAAI,YAAY;IAI3B;;OAEG;IACH,OAAO,CAAC,aAAa;IA6BrB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IA6DzB;;OAEG;IACH,OAAO,CAAC,YAAY;IA2DpB;;;OAGG;IACH,OAAO,CAAC,kBAAkB;IA4C1B;;;OAGG;IACH,OAAO,CAAC,cAAc;IA6BtB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAgDzB;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IAgCxB;;OAEG;IACH,OAAO,CAAC,YAAY;IAOpB;;OAEG;IACH,OAAO,CAAC,iBAAiB;CAoB1B"}

package/dist/display-utils/wrapper/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Text Wrapper Module
+ *
+ * Provides text wrapping with multiple break modes:
+ * - 'character': Break mid-word with hyphen for 100% line utilization
+ * - 'word': Break at word boundaries, hyphenate only if word > line width
+ * - 'strict-word': Break at word boundaries only, no hyphenation
+ */
+export { TextWrapper } from "./TextWrapper";
+export type { WrapOptions, WrapResult, LineMetrics, BreakMode } from "./types";
+export { DEFAULT_WRAP_OPTIONS } from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/display-utils/wrapper/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/display-utils/wrapper/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAG3C,YAAY,EAAE,WAAW,EAAE,UAAU,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAC9E,OAAO,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAA"}

package/dist/display-utils/wrapper/types.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Options for text wrapping.
+ */
+export interface WrapOptions {
+    /** Maximum width in pixels (defaults to profile's displayWidthPx) */
+    maxWidthPx?: number;
+    /** Maximum number of lines (defaults to profile's maxLines) */
+    maxLines?: number;
+    /** Maximum total bytes (defaults to profile's maxPayloadBytes) */
+    maxBytes?: number;
+    /**
+     * Break mode:
+     * - 'character': Break mid-word with hyphen for 100% utilization
+     * - 'word': Break at word boundaries, hyphenate only if word > line
+     * - 'strict-word': Break at word boundaries only, truncate long words
+     */
+    breakMode?: BreakMode;
+    /** Character to use for hyphenation (default: '-') */
+    hyphenChar?: string;
+    /** Minimum characters before allowing hyphen break (default: 3) */
+    minCharsBeforeHyphen?: number;
+    /** Whether to trim whitespace from line ends (default: true) */
+    trimLines?: boolean;
+    /** Whether to preserve explicit newlines in input (default: true) */
+    preserveNewlines?: boolean;
+}
+/**
+ * Break mode for text wrapping.
+ */
+export type BreakMode = "character" | "word" | "strict-word";
+/**
+ * Result of wrapping operation.
+ */
+export interface WrapResult {
+    /** Wrapped lines */
+    lines: string[];
+    /** Whether content was truncated to fit constraints */
+    truncated: boolean;
+    /** Total pixel width of widest line */
+    maxLineWidthPx: number;
+    /** Total byte size of all lines */
+    totalBytes: number;
+    /** Per-line metadata */
+    lineMetrics: LineMetrics[];
+    /** Original input text */
+    originalText: string;
+    /** Break mode used */
+    breakMode: BreakMode;
+}
+/**
+ * Per-line metrics from wrapping.
+ */
+export interface LineMetrics {
+    /** The line text */
+    text: string;
+    /** Width in pixels */
+    widthPx: number;
+    /** Byte size of this line */
+    bytes: number;
+    /** Utilization percentage (widthPx / maxWidthPx * 100) */
+    utilizationPercent: number;
+    /** Whether this line ends with a hyphen from breaking */
+    endsWithHyphen: boolean;
+    /** Whether this line was created from an explicit newline */
+    fromExplicitNewline: boolean;
+}
+/**
+ * Default wrap options.
+ */
+export declare const DEFAULT_WRAP_OPTIONS: Required<Omit<WrapOptions, "maxWidthPx" | "maxLines" | "maxBytes">>;
+//# sourceMappingURL=types.d.ts.map

package/dist/display-utils/wrapper/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/display-utils/wrapper/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,qEAAqE;IACrE,UAAU,CAAC,EAAE,MAAM,CAAA;IAEnB,+DAA+D;IAC/D,QAAQ,CAAC,EAAE,MAAM,CAAA;IAEjB,kEAAkE;IAClE,QAAQ,CAAC,EAAE,MAAM,CAAA;IAEjB;;;;;OAKG;IACH,SAAS,CAAC,EAAE,SAAS,CAAA;IAErB,sDAAsD;IACtD,UAAU,CAAC,EAAE,MAAM,CAAA;IAEnB,mEAAmE;IACnE,oBAAoB,CAAC,EAAE,MAAM,CAAA;IAE7B,gEAAgE;IAChE,SAAS,CAAC,EAAE,OAAO,CAAA;IAEnB,qEAAqE;IACrE,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAC3B;AAED;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,WAAW,GAAG,MAAM,GAAG,aAAa,CAAA;AAE5D;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,oBAAoB;IACpB,KAAK,EAAE,MAAM,EAAE,CAAA;IAEf,uDAAuD;IACvD,SAAS,EAAE,OAAO,CAAA;IAElB,uCAAuC;IACvC,cAAc,EAAE,MAAM,CAAA;IAEtB,mCAAmC;IACnC,UAAU,EAAE,MAAM,CAAA;IAElB,wBAAwB;IACxB,WAAW,EAAE,WAAW,EAAE,CAAA;IAE1B,0BAA0B;IAC1B,YAAY,EAAE,MAAM,CAAA;IAEpB,sBAAsB;IACtB,SAAS,EAAE,SAAS,CAAA;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,oBAAoB;IACpB,IAAI,EAAE,MAAM,CAAA;IAEZ,sBAAsB;IACtB,OAAO,EAAE,MAAM,CAAA;IAEf,6BAA6B;IAC7B,KAAK,EAAE,MAAM,CAAA;IAEb,0DAA0D;IAC1D,kBAAkB,EAAE,MAAM,CAAA;IAE1B,yDAAyD;IACzD,cAAc,EAAE,OAAO,CAAA;IAEvB,6DAA6D;IAC7D,mBAAmB,EAAE,OAAO,CAAA;CAC7B;AAED;;GAEG;AACH,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,IAAI,CAAC,WAAW,EAAE,YAAY,GAAG,UAAU,GAAG,UAAU,CAAC,CAMpG,CAAA"}