bard-legends-framework 0.10.9 → 0.12.0

package/dist/pixi/display-object/objects/text/helpers/process-steps/1-data-in-converter/pixi-text-style-converter.d.ts

@@ -1,5 +1,5 @@
 import { Radian, RGBColor } from 'helpers-lib';
-import * as PIXI from 'pixi.js';
+import * as Pixi from 'pixi.js';
 export interface DropShadowOptions {
     readonly blur: number;
     readonly angle: Radian;
@@ -7,9 +7,10 @@ export interface DropShadowOptions {
     readonly color: RGBColor;
     readonly alpha: number;
 }
+export type TextAlignment = 'center' | 'left' | 'right';
 export interface TextOptions {
     readonly color: RGBColor;
-    readonly align: 'left' | 'center' | 'right';
+    readonly align: TextAlignment;
     readonly fontFamily: string;
     readonly fontSize: number;
     readonly fontStyle: 'normal' | 'italic' | 'oblique';
@@ -21,7 +22,7 @@ export interface TextOptions {
 export type PartialTextOptions = Partial<Omit<TextOptions, 'dropShadow'>> & {
     dropShadow?: Partial<DropShadowOptions> | true;
 };
-export interface ExtendedPixiTextStyle extends Partial<PIXI.ITextStyle> {
+export interface ExtendedPixiTextStyle extends Partial<Pixi.ITextStyle> {
     readonly lineThrough: boolean;
 }
 export declare class TextStyleConverter {

package/dist/pixi/display-object/objects/text/helpers/process-steps/1-data-in-converter/rich-text-data-in-converter.d.ts

@@ -10,10 +10,10 @@ export interface TagsWithStyles {
 }
 export declare class RichTextDataInConverter {
     static process(text: string, options: RichTextOptions): ChunkData[][];
-    private static includeStylesToTags;
-    private static getCombinedStyle;
-    private static combineStyles;
-    private static applyNewLines;
-    private static splitIntoChunks;
-    private static splitToChunks;
+    private static _includeStylesToTags;
+    private static _getCombinedStyle;
+    private static _combineStyles;
+    private static _applyNewLines;
+    private static _splitIntoChunks;
+    private static _splitToChunks;
 }

package/dist/pixi/display-object/objects/text/helpers/process-steps/1-data-in-converter/rich-text-data-in-converter.js

@@ -24,19 +24,19 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RichTextDataInConverter = void 0;
-const PIXI = __importStar(require("pixi.js"));
+const Pixi = __importStar(require("pixi.js"));
 const script_engine_lib_1 = require("script-engine-lib");
 const pixi_text_style_converter_1 = require("./pixi-text-style-converter");
 class RichTextDataInConverter {
     static process(text, options) {
         let styleNameSet = new Set(options.styles ? Object.keys(options.styles) : []);
         let textSegments = script_engine_lib_1.RichTextSeparator.process(text, styleNameSet);
-        let tagsWithStyles = this.includeStylesToTags(textSegments, options);
-        let lines = this.applyNewLines(tagsWithStyles);
-        let chunks = this.splitIntoChunks(lines);
+        let tagsWithStyles = this._includeStylesToTags(textSegments, options);
+        let lines = this._applyNewLines(tagsWithStyles);
+        let chunks = this._splitIntoChunks(lines);
         return chunks;
     }
-    static includeStylesToTags(textSegments, options) {
+    static _includeStylesToTags(textSegments, options) {
         let styleCache = new Map();
         let pixiStyleCache = new Map();
         const GetPixiStyle = (style, cacheKey) => {
@@ -48,9 +48,9 @@ class RichTextDataInConverter {
             return pixiStyle;
         };
         let tagsWithStyles = textSegments.map(segment => {
-            let { style, cacheKey } = this.getCombinedStyle(segment.tags, options, styleCache);
+            let { style, cacheKey } = this._getCombinedStyle(segment.tags, options, styleCache);
             let pixiStyle = GetPixiStyle(style, cacheKey);
-            let spaceMeasurement = PIXI.TextMetrics.measureText(' ', new PIXI.TextStyle(pixiStyle), false);
+            let spaceMeasurement = Pixi.TextMetrics.measureText(' ', new Pixi.TextStyle(pixiStyle), false);
             let data = {
                 text: segment.text,
                 cacheKey,
@@ -62,16 +62,16 @@ class RichTextDataInConverter {
         });
         return tagsWithStyles;
     }
-    static getCombinedStyle(tags, options, styleCache) {
+    static _getCombinedStyle(tags, options, styleCache) {
         let cacheKey = tags.join('+');
         if (styleCache.has(cacheKey)) {
             return { style: styleCache.get(cacheKey), cacheKey };
         }
-        let result = this.combineStyles(tags, options);
+        let result = this._combineStyles(tags, options);
         styleCache.set(cacheKey, result);
         return { style: result, cacheKey };
     }
-    static combineStyles(tags, options) {
+    static _combineStyles(tags, options) {
         let result = { ...options.default };
         for (let tag of tags) {
             if (options.styles && options.styles[tag]) {
@@ -81,7 +81,7 @@ class RichTextDataInConverter {
         let { wordWrapWidth: _wordWrapWidth, align: _align, dropShadow: _dropShadow, ...supportedStyles } = result;
         return supportedStyles;
     }
-    static applyNewLines(tokens) {
+    static _applyNewLines(tokens) {
         let result = [];
         let currentLine = [];
         tokens.forEach((token, index) => {
@@ -103,17 +103,17 @@ class RichTextDataInConverter {
         result.push(currentLine);
         return result;
     }
-    static splitIntoChunks(tagsWithStyles) {
+    static _splitIntoChunks(tagsWithStyles) {
         let chunks = [];
         tagsWithStyles.forEach(line => {
             if (line.length === 0) {
                 throw new Error('Internal Error: Line is unexpectedly empty');
             }
             let chunkData = line.flatMap(data => {
-                let chunkStrings = this.splitToChunks(data.text);
+                let chunkStrings = this._splitToChunks(data.text);
                 return chunkStrings.map(chunkString => {
-                    let pixiStyle = new PIXI.TextStyle(data.pixiStyle);
-                    let metrics = PIXI.TextMetrics.measureText(chunkString, pixiStyle, false);
+                    let pixiStyle = new Pixi.TextStyle(data.pixiStyle);
+                    let metrics = Pixi.TextMetrics.measureText(chunkString, pixiStyle, false);
                     let chunkDatum = {
                         text: chunkString,
                         whitespace: chunkString.trim() === '',
@@ -135,7 +135,7 @@ class RichTextDataInConverter {
         });
         return chunks;
     }
-    static splitToChunks(str) {
+    static _splitToChunks(str) {
         if (str === '') {
             return [''];
         }

package/dist/pixi/display-object/objects/text/helpers/process-steps/1-data-in-converter/rich-text-data-in-converter.test.js

@@ -35,7 +35,7 @@ const ExpectedPixiStyles = {
         (0, vitest_1.test)('should handle plain text without tags', () => {
             let text = 'Simple text without any tags';
             let textSegments = script_engine_lib_1.RichTextSeparator.process(text, StyleNames);
-            let result = rich_text_data_in_converter_1.RichTextDataInConverter['includeStylesToTags'](textSegments, DefaultRichTextOptions);
+            let result = rich_text_data_in_converter_1.RichTextDataInConverter['_includeStylesToTags'](textSegments, DefaultRichTextOptions);
             (0, vitest_1.expect)(result).toEqual([
                 {
                     text: 'Simple text without any tags',
@@ -49,7 +49,7 @@ const ExpectedPixiStyles = {
         (0, vitest_1.test)('should handle single style tag correctly', () => {
             let text = '<style1>Styled text</style1>';
             let textSegments = script_engine_lib_1.RichTextSeparator.process(text, StyleNames);
-            let result = rich_text_data_in_converter_1.RichTextDataInConverter['includeStylesToTags'](textSegments, DefaultRichTextOptions);
+            let result = rich_text_data_in_converter_1.RichTextDataInConverter['_includeStylesToTags'](textSegments, DefaultRichTextOptions);
             (0, vitest_1.expect)(result).toEqual([
                 {
                     text: 'Styled text',
@@ -63,7 +63,7 @@ const ExpectedPixiStyles = {
         (0, vitest_1.test)('should handle text with surrounding styles', () => {
             let text = 'plain text <style1>styled text</style1> more plain text';
             let textSegments = script_engine_lib_1.RichTextSeparator.process(text, StyleNames);
-            let result = rich_text_data_in_converter_1.RichTextDataInConverter['includeStylesToTags'](textSegments, DefaultRichTextOptions);
+            let result = rich_text_data_in_converter_1.RichTextDataInConverter['_includeStylesToTags'](textSegments, DefaultRichTextOptions);
             (0, vitest_1.expect)(result).toEqual([
                 {
                     text: 'plain text ',
@@ -91,7 +91,7 @@ const ExpectedPixiStyles = {
         (0, vitest_1.test)('should handle multiple styles', () => {
             let text = '<style1>Text with style1</style1> plain text <style2>text with style2</style2>';
             let textSegments = script_engine_lib_1.RichTextSeparator.process(text, StyleNames);
-            let result = rich_text_data_in_converter_1.RichTextDataInConverter['includeStylesToTags'](textSegments, DefaultRichTextOptions);
+            let result = rich_text_data_in_converter_1.RichTextDataInConverter['_includeStylesToTags'](textSegments, DefaultRichTextOptions);
             (0, vitest_1.expect)(result).toEqual([
                 {
                     text: 'Text with style1',
@@ -119,7 +119,7 @@ const ExpectedPixiStyles = {
         (0, vitest_1.test)('should handle nested styles', () => {
             let text = 'Text <style1>with <style2>nested</style2> styles</style1>';
             let textSegments = script_engine_lib_1.RichTextSeparator.process(text, StyleNames);
-            let result = rich_text_data_in_converter_1.RichTextDataInConverter['includeStylesToTags'](textSegments, DefaultRichTextOptions);
+            let result = rich_text_data_in_converter_1.RichTextDataInConverter['_includeStylesToTags'](textSegments, DefaultRichTextOptions);
             (0, vitest_1.expect)(result).toEqual([
                 {
                     text: 'Text ',
@@ -164,7 +164,7 @@ const ExpectedPixiStyles = {
         (0, vitest_1.test)('should not accept "default" as a valid tag', () => {
             let text = 'Text with no default tag';
             let textSegments = script_engine_lib_1.RichTextSeparator.process(text, StyleNames);
-            let result = rich_text_data_in_converter_1.RichTextDataInConverter['includeStylesToTags'](textSegments, DefaultRichTextOptions);
+            let result = rich_text_data_in_converter_1.RichTextDataInConverter['_includeStylesToTags'](textSegments, DefaultRichTextOptions);
             (0, vitest_1.expect)(result).toEqual([
                 {
                     text: 'Text with no default tag',
@@ -178,7 +178,7 @@ const ExpectedPixiStyles = {
         (0, vitest_1.test)('should match the example in comments', () => {
             let text = 'This is a sample <style1>Hello</style1><style2>World</style2> text';
             let textSegments = script_engine_lib_1.RichTextSeparator.process(text, StyleNames);
-            let result = rich_text_data_in_converter_1.RichTextDataInConverter['includeStylesToTags'](textSegments, DefaultRichTextOptions);
+            let result = rich_text_data_in_converter_1.RichTextDataInConverter['_includeStylesToTags'](textSegments, DefaultRichTextOptions);
             (0, vitest_1.expect)(result).toEqual([
                 {
                     text: 'This is a sample ',
@@ -234,31 +234,31 @@ const ExpectedPixiStyles = {
         };
         (0, vitest_1.test)('empty text', () => {
             let text = '';
-            let result = rich_text_data_in_converter_1.RichTextDataInConverter['applyNewLines']([GetTagsWithStyles(text)]);
+            let result = rich_text_data_in_converter_1.RichTextDataInConverter['_applyNewLines']([GetTagsWithStyles(text)]);
             (0, vitest_1.expect)(result).toEqual([[GetTagsWithStyles('')]]);
         });
         (0, vitest_1.test)('plane text', () => {
             let text = 'Simple text without styles';
-            let result = rich_text_data_in_converter_1.RichTextDataInConverter['applyNewLines']([GetTagsWithStyles(text)]);
+            let result = rich_text_data_in_converter_1.RichTextDataInConverter['_applyNewLines']([GetTagsWithStyles(text)]);
             (0, vitest_1.expect)(result).toEqual([[GetTagsWithStyles('Simple text without styles')]]);
         });
         (0, vitest_1.test)('text with newlines', () => {
             let text = 'Line 1\nLine 2\nLine 3';
-            let result = rich_text_data_in_converter_1.RichTextDataInConverter['applyNewLines']([GetTagsWithStyles(text)]);
+            let result = rich_text_data_in_converter_1.RichTextDataInConverter['_applyNewLines']([GetTagsWithStyles(text)]);
             (0, vitest_1.expect)(result).toEqual([[GetTagsWithStyles('Line 1')], [GetTagsWithStyles('Line 2')], [GetTagsWithStyles('Line 3')]]);
         });
         (0, vitest_1.test)('text with empty starting line', () => {
             let text = '\n0123';
-            let result = rich_text_data_in_converter_1.RichTextDataInConverter['applyNewLines']([GetTagsWithStyles(text)]);
+            let result = rich_text_data_in_converter_1.RichTextDataInConverter['_applyNewLines']([GetTagsWithStyles(text)]);
             (0, vitest_1.expect)(result).toEqual([[GetTagsWithStyles('')], [GetTagsWithStyles('0123')]]);
         });
         (0, vitest_1.test)('text with empty ending line', () => {
             let text = '0123\n';
-            let result = rich_text_data_in_converter_1.RichTextDataInConverter['applyNewLines']([GetTagsWithStyles(text)]);
+            let result = rich_text_data_in_converter_1.RichTextDataInConverter['_applyNewLines']([GetTagsWithStyles(text)]);
             (0, vitest_1.expect)(result).toEqual([[GetTagsWithStyles('0123')], [GetTagsWithStyles('')]]);
         });
         (0, vitest_1.test)('text with styles', () => {
-            let result = rich_text_data_in_converter_1.RichTextDataInConverter['applyNewLines']([
+            let result = rich_text_data_in_converter_1.RichTextDataInConverter['_applyNewLines']([
                 GetTagsWithStyles('Regular text '),
                 GetTagsWithStyles('red text', 'red'),
                 GetTagsWithStyles(' back to regular')
@@ -268,7 +268,7 @@ const ExpectedPixiStyles = {
             ]);
         });
         (0, vitest_1.test)('text with styles and newlines', () => {
-            let result = rich_text_data_in_converter_1.RichTextDataInConverter['applyNewLines']([
+            let result = rich_text_data_in_converter_1.RichTextDataInConverter['_applyNewLines']([
                 GetTagsWithStyles('Regular text '),
                 GetTagsWithStyles('red text\nnew line still red', 'red'),
                 GetTagsWithStyles(' back to regular')
@@ -279,11 +279,11 @@ const ExpectedPixiStyles = {
             ]);
         });
         (0, vitest_1.test)('should handle CRLF newlines', () => {
-            let result = rich_text_data_in_converter_1.RichTextDataInConverter['applyNewLines']([GetTagsWithStyles('Line 1\r\nLine 2\r\nLine 3')]);
+            let result = rich_text_data_in_converter_1.RichTextDataInConverter['_applyNewLines']([GetTagsWithStyles('Line 1\r\nLine 2\r\nLine 3')]);
             (0, vitest_1.expect)(result).toEqual([[GetTagsWithStyles('Line 1')], [GetTagsWithStyles('Line 2')], [GetTagsWithStyles('Line 3')]]);
         });
         (0, vitest_1.test)('should handle empty lines', () => {
-            let result = rich_text_data_in_converter_1.RichTextDataInConverter['applyNewLines']([GetTagsWithStyles('Line 1\n\nLine 3')]);
+            let result = rich_text_data_in_converter_1.RichTextDataInConverter['_applyNewLines']([GetTagsWithStyles('Line 1\n\nLine 3')]);
             (0, vitest_1.expect)(result).toEqual([[GetTagsWithStyles('Line 1')], [GetTagsWithStyles('')], [GetTagsWithStyles('Line 3')]]);
         });
     });
@@ -297,17 +297,17 @@ const ExpectedPixiStyles = {
         });
         (0, vitest_1.test)('empty string', () => {
             let nonWrappedTextData = [[GetNonWrappedTextData('')]];
-            let result = rich_text_data_in_converter_1.RichTextDataInConverter['splitIntoChunks'](nonWrappedTextData);
+            let result = rich_text_data_in_converter_1.RichTextDataInConverter['_splitIntoChunks'](nonWrappedTextData);
             (0, vitest_1.expect)(result).toEqual([[(0, rich_text_to_plane_text_test_1.CreateSampleChunkData)('')]]);
         });
         (0, vitest_1.test)('single word', () => {
             let nonWrappedTextData = [[GetNonWrappedTextData('Hello')]];
-            let result = rich_text_data_in_converter_1.RichTextDataInConverter['splitIntoChunks'](nonWrappedTextData);
+            let result = rich_text_data_in_converter_1.RichTextDataInConverter['_splitIntoChunks'](nonWrappedTextData);
             (0, vitest_1.expect)(result).toEqual([[(0, rich_text_to_plane_text_test_1.CreateSampleChunkData)('Hello')]]);
         });
         (0, vitest_1.test)('multiple words with spaces', () => {
             let nonWrappedTextData = [[GetNonWrappedTextData('Hello World')]];
-            let result = rich_text_data_in_converter_1.RichTextDataInConverter['splitIntoChunks'](nonWrappedTextData);
+            let result = rich_text_data_in_converter_1.RichTextDataInConverter['_splitIntoChunks'](nonWrappedTextData);
             (0, vitest_1.expect)(result).toEqual([[(0, rich_text_to_plane_text_test_1.CreateSampleChunkData)('Hello'), (0, rich_text_to_plane_text_test_1.CreateSampleChunkData)(' '), (0, rich_text_to_plane_text_test_1.CreateSampleChunkData)('World')]]);
         });
         (0, vitest_1.test)('multiple lines', () => {
@@ -315,7 +315,7 @@ const ExpectedPixiStyles = {
                 [GetNonWrappedTextData('Line 1')],
                 [GetNonWrappedTextData('Line 2', { fontSize: 24 })]
             ];
-            let result = rich_text_data_in_converter_1.RichTextDataInConverter['splitIntoChunks'](nonWrappedTextData);
+            let result = rich_text_data_in_converter_1.RichTextDataInConverter['_splitIntoChunks'](nonWrappedTextData);
             (0, vitest_1.expect)(result).toEqual([
                 [(0, rich_text_to_plane_text_test_1.CreateSampleChunkData)('Line'), (0, rich_text_to_plane_text_test_1.CreateSampleChunkData)(' '), (0, rich_text_to_plane_text_test_1.CreateSampleChunkData)('1')],
                 [
@@ -327,43 +327,43 @@ const ExpectedPixiStyles = {
         });
         (0, vitest_1.test)('empty line throws error', () => {
             let nonWrappedTextData = [[]];
-            (0, vitest_1.expect)(() => rich_text_data_in_converter_1.RichTextDataInConverter['splitIntoChunks'](nonWrappedTextData)).toThrow('Internal Error: Line is unexpectedly empty');
+            (0, vitest_1.expect)(() => rich_text_data_in_converter_1.RichTextDataInConverter['_splitIntoChunks'](nonWrappedTextData)).toThrow('Internal Error: Line is unexpectedly empty');
         });
     });
     (0, vitest_1.describe)('splitToChunks', () => {
         (0, vitest_1.test)('empty string', () => {
             let text = '';
-            let result = rich_text_data_in_converter_1.RichTextDataInConverter['splitToChunks'](text);
+            let result = rich_text_data_in_converter_1.RichTextDataInConverter['_splitToChunks'](text);
             (0, vitest_1.expect)(result).toEqual(['']);
         });
         (0, vitest_1.test)('no spaces', () => {
             let text = 'helloworld';
-            let result = rich_text_data_in_converter_1.RichTextDataInConverter['splitToChunks'](text);
+            let result = rich_text_data_in_converter_1.RichTextDataInConverter['_splitToChunks'](text);
             (0, vitest_1.expect)(result).toEqual(['helloworld']);
         });
         (0, vitest_1.test)('only spaces', () => {
             let text = '   ';
-            let result = rich_text_data_in_converter_1.RichTextDataInConverter['splitToChunks'](text);
+            let result = rich_text_data_in_converter_1.RichTextDataInConverter['_splitToChunks'](text);
             (0, vitest_1.expect)(result).toEqual(['   ']);
         });
         (0, vitest_1.test)('spaces at start', () => {
             let text = '  hello world';
-            let result = rich_text_data_in_converter_1.RichTextDataInConverter['splitToChunks'](text);
+            let result = rich_text_data_in_converter_1.RichTextDataInConverter['_splitToChunks'](text);
             (0, vitest_1.expect)(result).toEqual(['  ', 'hello', ' ', 'world']);
         });
         (0, vitest_1.test)('spaces at end', () => {
             let text = 'hello world  ';
-            let result = rich_text_data_in_converter_1.RichTextDataInConverter['splitToChunks'](text);
+            let result = rich_text_data_in_converter_1.RichTextDataInConverter['_splitToChunks'](text);
             (0, vitest_1.expect)(result).toEqual(['hello', ' ', 'world', '  ']);
         });
         (0, vitest_1.test)('multiple spaces in between', () => {
             let text = 'hello   world';
-            let result = rich_text_data_in_converter_1.RichTextDataInConverter['splitToChunks'](text);
+            let result = rich_text_data_in_converter_1.RichTextDataInConverter['_splitToChunks'](text);
             (0, vitest_1.expect)(result).toEqual(['hello', '   ', 'world']);
         });
         (0, vitest_1.test)('should handle text with alternating spaces and words', () => {
             let text = '  a b c d  ';
-            let result = rich_text_data_in_converter_1.RichTextDataInConverter['splitToChunks'](text);
+            let result = rich_text_data_in_converter_1.RichTextDataInConverter['_splitToChunks'](text);
             (0, vitest_1.expect)(result).toEqual(['  ', 'a', ' ', 'b', ' ', 'c', ' ', 'd', '  ']);
         });
     });

package/dist/pixi/display-object/objects/text/helpers/process-steps/2-wrapping-text/consistent-space-text-wrapper.d.ts

@@ -2,5 +2,5 @@ import { ChunkData } from '../../rich-text-to-plane-text';
 import { PositionedChunk, RichTextTypewriter } from './rich-text-typewriter';
 export declare class ConsistentSpaceTextWrapper {
     static wrapText(sheet: ChunkData[][], typewriter: RichTextTypewriter): PositionedChunk[][];
-    private static wrapSpaces;
+    private static _wrapSpaces;
 }

package/dist/pixi/display-object/objects/text/helpers/process-steps/2-wrapping-text/consistent-space-text-wrapper.js

@@ -13,7 +13,7 @@ class ConsistentSpaceTextWrapper {
                             typewriter.insertWord(chunk);
                         }
                         else {
-                            this.wrapSpaces(chunk, typewriter);
+                            this._wrapSpaces(chunk, typewriter);
                         }
                     }
                     else {
@@ -25,7 +25,7 @@ class ConsistentSpaceTextWrapper {
                         typewriter.insertWord(chunk);
                     }
                     else if (chunk.whitespace) {
-                        this.wrapSpaces(chunk, typewriter);
+                        this._wrapSpaces(chunk, typewriter);
                     }
                     else {
                         typewriter.newLine();
@@ -37,7 +37,7 @@ class ConsistentSpaceTextWrapper {
         });
         return typewriter.print();
     }
-    static wrapSpaces(chunk, typewriter) {
+    static _wrapSpaces(chunk, typewriter) {
         let spacesThatCanFit = Math.max(0, Math.floor(typewriter.remainingWidth / chunk.style.spaceWidth));
         let spacesToInsert = Math.max(0, Math.min(spacesThatCanFit, chunk.text.length - 1));
         if (spacesToInsert > 0) {

package/dist/pixi/display-object/objects/text/helpers/process-steps/2-wrapping-text/rich-text-typewriter.d.ts

@@ -11,27 +11,27 @@ export interface RichTextTypewriterOptions {
     readonly verticalAlignment?: 'top' | 'center' | 'bottom';
 }
 export declare class RichTextTypewriter {
-    private readonly wordWrapWidth;
-    private lines;
-    private currentLine;
-    private cursorPosition;
-    private linePosition;
-    private currentLineHeight;
-    private readonly cut?;
-    private readonly horizontalAlignment;
-    private readonly verticalAlignment;
+    private readonly _wordWrapWidth;
+    private _lines;
+    private _currentLine;
+    private _cursorPosition;
+    private _linePosition;
+    private _currentLineHeight;
+    private readonly _cut?;
+    private readonly _horizontalAlignment;
+    private readonly _verticalAlignment;
     get lineIsEmpty(): boolean;
     get remainingWidth(): number;
-    constructor(wordWrapWidth: number, options?: RichTextTypewriterOptions);
+    constructor(_wordWrapWidth: number, options?: RichTextTypewriterOptions);
     isSpaceAvailable(size: Vector): boolean;
     insertWord(chunk: ChunkData): void;
     newLine(): void;
     print(): PositionedChunk[][];
-    private flushCurrentLine;
-    private alignLine;
-    private horizontallyAlign;
-    private verticallyAlign;
-    private getLineStart;
-    private getLineEnd;
-    private convertRectangleCut;
+    private _flushCurrentLine;
+    private _alignLine;
+    private _horizontallyAlign;
+    private _verticallyAlign;
+    private _getLineStart;
+    private _getLineEnd;
+    private _convertRectangleCut;
 }

package/dist/pixi/display-object/objects/text/helpers/process-steps/2-wrapping-text/rich-text-typewriter.js

@@ -4,83 +4,83 @@ exports.RichTextTypewriter = void 0;
 const helpers_lib_1 = require("helpers-lib");
 class RichTextTypewriter {
     get lineIsEmpty() {
-        return this.currentLine.length === 0;
+        return this._currentLine.length === 0;
     }
     get remainingWidth() {
-        return this.wordWrapWidth - this.cursorPosition;
+        return this._wordWrapWidth - this._cursorPosition;
     }
-    constructor(wordWrapWidth, options) {
-        this.wordWrapWidth = wordWrapWidth;
-        this.lines = [];
-        this.currentLine = [];
-        this.cursorPosition = 0;
-        this.linePosition = new helpers_lib_1.Vector(0, 0);
-        this.currentLineHeight = 0;
-        this.horizontalAlignment = options?.horizontalAlignment ?? 'left';
-        this.verticalAlignment = options?.verticalAlignment ?? 'bottom';
+    constructor(_wordWrapWidth, options) {
+        this._wordWrapWidth = _wordWrapWidth;
+        this._lines = [];
+        this._currentLine = [];
+        this._cursorPosition = 0;
+        this._linePosition = new helpers_lib_1.Vector(0, 0);
+        this._currentLineHeight = 0;
+        this._horizontalAlignment = options?.horizontalAlignment ?? 'left';
+        this._verticalAlignment = options?.verticalAlignment ?? 'bottom';
         if (options?.rectangleCutOption) {
             if (options.rectangleCutOption.position.x < 0 ||
-                options.rectangleCutOption.position.x >= this.wordWrapWidth ||
+                options.rectangleCutOption.position.x >= this._wordWrapWidth ||
                 options.rectangleCutOption.position.y < 0) {
                 throw new Error('Rectangle cut position is out of bounds');
             }
-            this.cut = {
+            this._cut = {
                 direction: options.rectangleCutOption.direction,
-                rectangle: this.convertRectangleCut(options.rectangleCutOption)
+                rectangle: this._convertRectangleCut(options.rectangleCutOption)
             };
         }
     }
     isSpaceAvailable(size) {
-        let lineHeightToBe = Math.max(this.currentLineHeight, size.y);
-        let lineEnd = this.getLineEnd(this.linePosition.y, this.linePosition.y + lineHeightToBe);
-        let cursorToBe = this.cursorPosition + size.x;
+        let lineHeightToBe = Math.max(this._currentLineHeight, size.y);
+        let lineEnd = this._getLineEnd(this._linePosition.y, this._linePosition.y + lineHeightToBe);
+        let cursorToBe = this._cursorPosition + size.x;
         return cursorToBe <= lineEnd;
     }
     insertWord(chunk) {
-        let lineHeightToBe = Math.max(this.currentLineHeight, chunk.style.height);
-        if (this.currentLine.length === 0) {
-            let lineStart = this.getLineStart(this.linePosition.y, this.linePosition.y + lineHeightToBe);
-            this.linePosition = new helpers_lib_1.Vector(lineStart, this.linePosition.y);
-            this.cursorPosition = this.linePosition.x;
+        let lineHeightToBe = Math.max(this._currentLineHeight, chunk.style.height);
+        if (this._currentLine.length === 0) {
+            let lineStart = this._getLineStart(this._linePosition.y, this._linePosition.y + lineHeightToBe);
+            this._linePosition = new helpers_lib_1.Vector(lineStart, this._linePosition.y);
+            this._cursorPosition = this._linePosition.x;
         }
-        this.currentLine.push({ chunk, position: new helpers_lib_1.Vector(this.cursorPosition, this.linePosition.y) });
-        this.currentLineHeight = lineHeightToBe;
-        this.cursorPosition += chunk.style.width;
+        this._currentLine.push({ chunk, position: new helpers_lib_1.Vector(this._cursorPosition, this._linePosition.y) });
+        this._currentLineHeight = lineHeightToBe;
+        this._cursorPosition += chunk.style.width;
     }
     newLine() {
-        let lineY = this.linePosition.y + this.currentLineHeight;
-        let lineX = this.getLineStart(lineY, lineY);
-        this.flushCurrentLine();
-        this.linePosition = new helpers_lib_1.Vector(lineX, lineY);
-        this.cursorPosition = this.linePosition.x;
-        this.currentLineHeight = 0;
+        let lineY = this._linePosition.y + this._currentLineHeight;
+        let lineX = this._getLineStart(lineY, lineY);
+        this._flushCurrentLine();
+        this._linePosition = new helpers_lib_1.Vector(lineX, lineY);
+        this._cursorPosition = this._linePosition.x;
+        this._currentLineHeight = 0;
     }
     print() {
-        this.flushCurrentLine();
-        return this.lines;
+        this._flushCurrentLine();
+        return this._lines;
     }
-    flushCurrentLine() {
-        if (this.currentLine.length > 0) {
-            this.lines.push(this.alignLine(this.currentLine));
-            this.currentLine = [];
+    _flushCurrentLine() {
+        if (this._currentLine.length > 0) {
+            this._lines.push(this._alignLine(this._currentLine));
+            this._currentLine = [];
         }
     }
-    alignLine(line) {
-        line = this.verticallyAlign(line);
-        line = this.horizontallyAlign(line);
+    _alignLine(line) {
+        line = this._verticallyAlign(line);
+        line = this._horizontallyAlign(line);
         return line;
     }
-    horizontallyAlign(line) {
-        if (this.horizontalAlignment === 'left') {
+    _horizontallyAlign(line) {
+        if (this._horizontalAlignment === 'left') {
             return line;
         }
-        let linePositionEnd = this.linePosition.y + this.currentLineHeight;
-        let lineStart = this.getLineStart(this.linePosition.y, linePositionEnd);
-        let lineEnd = this.getLineEnd(this.linePosition.y, linePositionEnd);
+        let linePositionEnd = this._linePosition.y + this._currentLineHeight;
+        let lineStart = this._getLineStart(this._linePosition.y, linePositionEnd);
+        let lineEnd = this._getLineEnd(this._linePosition.y, linePositionEnd);
         let lineWidth = lineEnd - lineStart;
         let totalWidth = Math.min(lineWidth, line.reduce((acc, chunk) => acc + chunk.chunk.style.width, 0));
         let offset;
-        if (this.horizontalAlignment === 'center') {
+        if (this._horizontalAlignment === 'center') {
             offset = (lineWidth - totalWidth) / 2;
         }
         else {
@@ -94,12 +94,12 @@ class RichTextTypewriter {
             return positionedChunk;
         });
     }
-    verticallyAlign(line) {
+    _verticallyAlign(line) {
         let maxAscent = Math.max(...line.map(chunk => chunk.chunk.style.ascent));
         let maxDescent = Math.max(...line.map(chunk => chunk.chunk.style.descent));
         return line.map(positionedChunk => {
             let offset;
-            switch (this.verticalAlignment) {
+            switch (this._verticalAlignment) {
                 case 'top':
                     offset = maxDescent - positionedChunk.chunk.style.descent;
                     break;
@@ -117,31 +117,31 @@ class RichTextTypewriter {
             return positionedChunk;
         });
     }
-    getLineStart(heightStart, heightEnd) {
-        if (this.cut) {
-            if (this.cut.direction === 'topLeft' || this.cut.direction === 'bottomLeft') {
-                let intersectingWithCut = this.cut.rectangle.isPointInside(new helpers_lib_1.Vector(0, heightStart), { includeEdges: false }) ||
-                    this.cut.rectangle.isPointInside(new helpers_lib_1.Vector(0, heightEnd), { includeEdges: false });
+    _getLineStart(heightStart, heightEnd) {
+        if (this._cut) {
+            if (this._cut.direction === 'topLeft' || this._cut.direction === 'bottomLeft') {
+                let intersectingWithCut = this._cut.rectangle.isPointInside(new helpers_lib_1.Vector(0, heightStart), { includeEdges: false }) ||
+                    this._cut.rectangle.isPointInside(new helpers_lib_1.Vector(0, heightEnd), { includeEdges: false });
                 if (intersectingWithCut) {
-                    return this.cut.rectangle.bottomRight.x;
+                    return this._cut.rectangle.bottomRight.x;
                 }
             }
         }
         return 0;
     }
-    getLineEnd(heightStart, heightEnd) {
-        if (this.cut) {
-            if (this.cut.direction === 'topRight' || this.cut.direction === 'bottomRight') {
-                let intersectingWithCut = this.cut.rectangle.isPointInside(new helpers_lib_1.Vector(this.wordWrapWidth, heightStart), { includeEdges: false }) ||
-                    this.cut.rectangle.isPointInside(new helpers_lib_1.Vector(this.wordWrapWidth, heightEnd), { includeEdges: false });
+    _getLineEnd(heightStart, heightEnd) {
+        if (this._cut) {
+            if (this._cut.direction === 'topRight' || this._cut.direction === 'bottomRight') {
+                let intersectingWithCut = this._cut.rectangle.isPointInside(new helpers_lib_1.Vector(this._wordWrapWidth, heightStart), { includeEdges: false }) ||
+                    this._cut.rectangle.isPointInside(new helpers_lib_1.Vector(this._wordWrapWidth, heightEnd), { includeEdges: false });
                 if (intersectingWithCut) {
-                    return this.cut.rectangle.topLeft.x;
+                    return this._cut.rectangle.topLeft.x;
                 }
             }
         }
-        return this.wordWrapWidth;
+        return this._wordWrapWidth;
     }
-    convertRectangleCut(rectangleCut) {
+    _convertRectangleCut(rectangleCut) {
         let topLeft;
         let bottomRight;
         switch (rectangleCut.direction) {

package/dist/pixi/display-object/objects/text/helpers/process-steps/2-wrapping-text/rich-text-typewriter.test.js

@@ -30,12 +30,12 @@ const rich_text_typewriter_1 = require("./rich-text-typewriter");
             typewriter.newLine();
             typewriter.insertWord((0, rich_text_to_plane_text_test_1.CreateSampleChunkData)('123', { fontSize: 15 }));
             typewriter.newLine();
-            (0, vitest_1.expect)(typewriter['linePosition']).toEqual(new helpers_lib_1.Vector(0, 35));
+            (0, vitest_1.expect)(typewriter['_linePosition']).toEqual(new helpers_lib_1.Vector(0, 35));
         });
         (0, vitest_1.test)('insertWord should insert word even if it does not fit', () => {
             const Chunk = (0, rich_text_to_plane_text_test_1.CreateSampleChunkData)('01234567890123456789');
             typewriter.insertWord(Chunk);
-            (0, vitest_1.expect)(typewriter['currentLine']).toEqual([
+            (0, vitest_1.expect)(typewriter['_currentLine']).toEqual([
                 { chunk: (0, rich_text_to_plane_text_test_1.CreateSampleChunkData)('01234567890123456789'), position: new helpers_lib_1.Vector(0, 0) }
             ]);
         });