@hexze/mctext 1.0.3 → 1.1.0

package/README.md

@@ -12,10 +12,11 @@ Minecraft text formatting, parsing, and rendering library. Features all the exac
 
 ## Features
 
-- **Text Parsing** - Parse legacy `§` formatting codes and JSON chat components
+- **Builder API** - Fluent interface for constructing formatted text
 - **Color Support** - All 16 named Minecraft colors plus RGB hex colors
 - **Style Handling** - Bold, italic, underlined, strikethrough, obfuscated
 - **Font Rendering** - Measure and render text with authentic Minecraft fonts
+- **Legacy Support** - Parse `§` formatting codes and JSON chat components
 
 ## Font Showcase
 
@@ -42,9 +43,13 @@ mctext = { version = "1.0", features = ["legacy-fonts"] }
 ```
 
 ```rust
-use mctext::McText;
+use mctext::{MCText, NamedColor};
+
+let text = MCText::new()
+    .add("Red ").color(NamedColor::Red)
+    .then("Bold").color(NamedColor::Red).bold()
+    .build();
 
-let text = McText::parse("§cRed §lBold");
 for span in text.spans() {
     println!("{}: {:?}", span.text, span.color);
 }
@@ -59,7 +64,8 @@ pip install mctext
 ```python
 import mctext
 
-text = mctext.parse("§cRed §lBold")
+text = mctext.MCText().add("Red ").color("red").then("Bold").color("red").bold().build()
+
 for span in text.spans():
     print(f"{span.text}: {span.color}")
 ```
@@ -71,9 +77,12 @@ npm install @hexze/mctext
 ```
 
 ```javascript
-import { McText } from '@hexze/mctext';
+import init, { MCText } from '@hexze/mctext';
+
+await init();
+
+let text = new MCText().add("Red ").color("red").then("Bold").color("red").bold().build();
 
-const text = McText.parse("§cRed §lBold");
 for (const span of text.spans()) {
     console.log(`${span.text}: ${span.color}`);
 }

package/mctext_wasm.d.ts

@@ -17,17 +17,16 @@ export class LayoutOptions {
   constructor(size: number);
 }
 
-export class McText {
+export class MCText {
   free(): void;
   [Symbol.dispose](): void;
-  charCount(): number;
-  static parseJson(json: string): McText;
+  static parseJson(json: string): MCText;
   plainText(): string;
+  add(text: string): SpanBuilder;
   constructor();
-  static parse(text: string): McText;
+  static parse(text: string): MCText;
   spans(): any;
   toJson(): string;
-  isEmpty(): boolean;
   toLegacy(): string;
 }
 
@@ -40,11 +39,25 @@ export class RenderResult {
   height(): number;
 }
 
+export class SpanBuilder {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  obfuscated(): SpanBuilder;
+  underlined(): SpanBuilder;
+  strikethrough(): SpanBuilder;
+  bold(): SpanBuilder;
+  then(text: string): SpanBuilder;
+  build(): MCText;
+  color(color: string): SpanBuilder;
+  italic(): SpanBuilder;
+}
+
 export function countVisibleChars(text: string): number;
 
 export function namedColors(): any;
 
-export function render(font_system: FontSystem, text: string, width: number, height: number, options: LayoutOptions): RenderResult;
+export function render(font_system: FontSystem, text: MCText, width: number, height: number, options: LayoutOptions): RenderResult;
 
 export function stripCodes(text: string): string;
 
@@ -53,9 +66,9 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembl
 export interface InitOutput {
   readonly memory: WebAssembly.Memory;
   readonly __wbg_mctext_free: (a: number, b: number) => void;
+  readonly __wbg_spanbuilder_free: (a: number, b: number) => void;
   readonly countVisibleChars: (a: number, b: number) => number;
-  readonly mctext_charCount: (a: number) => number;
-  readonly mctext_isEmpty: (a: number) => number;
+  readonly mctext_add: (a: number, b: number, c: number) => number;
   readonly mctext_new: () => number;
   readonly mctext_parse: (a: number, b: number) => number;
   readonly mctext_parseJson: (a: number, b: number) => [number, number, number];
@@ -64,6 +77,14 @@ export interface InitOutput {
   readonly mctext_toJson: (a: number) => [number, number];
   readonly mctext_toLegacy: (a: number) => [number, number];
   readonly namedColors: () => any;
+  readonly spanbuilder_bold: (a: number) => number;
+  readonly spanbuilder_build: (a: number) => number;
+  readonly spanbuilder_color: (a: number, b: number, c: number) => number;
+  readonly spanbuilder_italic: (a: number) => number;
+  readonly spanbuilder_obfuscated: (a: number) => number;
+  readonly spanbuilder_strikethrough: (a: number) => number;
+  readonly spanbuilder_then: (a: number, b: number, c: number) => number;
+  readonly spanbuilder_underlined: (a: number) => number;
   readonly stripCodes: (a: number, b: number) => [number, number];
   readonly __wbg_fontsystem_free: (a: number, b: number) => void;
   readonly __wbg_layoutoptions_free: (a: number, b: number) => void;
@@ -73,7 +94,7 @@ export interface InitOutput {
   readonly layoutoptions_new: (a: number) => number;
   readonly layoutoptions_withMaxWidth: (a: number, b: number) => number;
   readonly layoutoptions_withShadow: (a: number, b: number) => number;
-  readonly render: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+  readonly render: (a: number, b: number, c: number, d: number, e: number) => number;
   readonly renderresult_data: (a: number) => [number, number];
   readonly renderresult_height: (a: number) => number;
   readonly renderresult_width: (a: number) => number;

package/mctext_wasm.js

@@ -119,7 +119,7 @@ const LayoutOptionsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_layoutoptions_free(ptr >>> 0, 1));
 
-const McTextFinalization = (typeof FinalizationRegistry === 'undefined')
+const MCTextFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_mctext_free(ptr >>> 0, 1));
 
@@ -127,6 +127,10 @@ const RenderResultFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_renderresult_free(ptr >>> 0, 1));
 
+const SpanBuilderFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_spanbuilder_free(ptr >>> 0, 1));
+
 export class FontSystem {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
@@ -214,34 +218,27 @@ export class LayoutOptions {
 }
 if (Symbol.dispose) LayoutOptions.prototype[Symbol.dispose] = LayoutOptions.prototype.free;
 
-export class McText {
+export class MCText {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(McText.prototype);
+        const obj = Object.create(MCText.prototype);
         obj.__wbg_ptr = ptr;
-        McTextFinalization.register(obj, obj.__wbg_ptr, obj);
+        MCTextFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        McTextFinalization.unregister(this);
+        MCTextFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_mctext_free(ptr, 0);
     }
-    /**
-     * @returns {number}
-     */
-    charCount() {
-        const ret = wasm.mctext_charCount(this.__wbg_ptr);
-        return ret >>> 0;
-    }
     /**
      * @param {string} json
-     * @returns {McText}
+     * @returns {MCText}
      */
     static parseJson(json) {
         const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -250,7 +247,7 @@ export class McText {
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return McText.__wrap(ret[0]);
+        return MCText.__wrap(ret[0]);
     }
     /**
      * @returns {string}
@@ -267,21 +264,32 @@ export class McText {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * @param {string} text
+     * @returns {SpanBuilder}
+     */
+    add(text) {
+        const ptr = this.__destroy_into_raw();
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.mctext_add(ptr, ptr0, len0);
+        return SpanBuilder.__wrap(ret);
+    }
     constructor() {
         const ret = wasm.mctext_new();
         this.__wbg_ptr = ret >>> 0;
-        McTextFinalization.register(this, this.__wbg_ptr, this);
+        MCTextFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
     /**
      * @param {string} text
-     * @returns {McText}
+     * @returns {MCText}
      */
     static parse(text) {
         const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.mctext_parse(ptr0, len0);
-        return McText.__wrap(ret);
+        return MCText.__wrap(ret);
     }
     /**
      * @returns {any}
@@ -305,13 +313,6 @@ export class McText {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
-    /**
-     * @returns {boolean}
-     */
-    isEmpty() {
-        const ret = wasm.mctext_isEmpty(this.__wbg_ptr);
-        return ret !== 0;
-    }
     /**
      * @returns {string}
      */
@@ -328,7 +329,7 @@ export class McText {
         }
     }
 }
-if (Symbol.dispose) McText.prototype[Symbol.dispose] = McText.prototype.free;
+if (Symbol.dispose) MCText.prototype[Symbol.dispose] = MCText.prototype.free;
 
 export class RenderResult {
     static __wrap(ptr) {
@@ -374,6 +375,97 @@ export class RenderResult {
 }
 if (Symbol.dispose) RenderResult.prototype[Symbol.dispose] = RenderResult.prototype.free;
 
+export class SpanBuilder {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(SpanBuilder.prototype);
+        obj.__wbg_ptr = ptr;
+        SpanBuilderFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SpanBuilderFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_spanbuilder_free(ptr, 0);
+    }
+    /**
+     * @returns {SpanBuilder}
+     */
+    obfuscated() {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.spanbuilder_obfuscated(ptr);
+        return SpanBuilder.__wrap(ret);
+    }
+    /**
+     * @returns {SpanBuilder}
+     */
+    underlined() {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.spanbuilder_underlined(ptr);
+        return SpanBuilder.__wrap(ret);
+    }
+    /**
+     * @returns {SpanBuilder}
+     */
+    strikethrough() {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.spanbuilder_strikethrough(ptr);
+        return SpanBuilder.__wrap(ret);
+    }
+    /**
+     * @returns {SpanBuilder}
+     */
+    bold() {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.spanbuilder_bold(ptr);
+        return SpanBuilder.__wrap(ret);
+    }
+    /**
+     * @param {string} text
+     * @returns {SpanBuilder}
+     */
+    then(text) {
+        const ptr = this.__destroy_into_raw();
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.spanbuilder_then(ptr, ptr0, len0);
+        return SpanBuilder.__wrap(ret);
+    }
+    /**
+     * @returns {MCText}
+     */
+    build() {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.spanbuilder_build(ptr);
+        return MCText.__wrap(ret);
+    }
+    /**
+     * @param {string} color
+     * @returns {SpanBuilder}
+     */
+    color(color) {
+        const ptr = this.__destroy_into_raw();
+        const ptr0 = passStringToWasm0(color, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.spanbuilder_color(ptr, ptr0, len0);
+        return SpanBuilder.__wrap(ret);
+    }
+    /**
+     * @returns {SpanBuilder}
+     */
+    italic() {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.spanbuilder_italic(ptr);
+        return SpanBuilder.__wrap(ret);
+    }
+}
+if (Symbol.dispose) SpanBuilder.prototype[Symbol.dispose] = SpanBuilder.prototype.free;
+
 /**
  * @param {string} text
  * @returns {number}
@@ -395,7 +487,7 @@ export function namedColors() {
 
 /**
  * @param {FontSystem} font_system
- * @param {string} text
+ * @param {MCText} text
  * @param {number} width
  * @param {number} height
  * @param {LayoutOptions} options
@@ -403,10 +495,9 @@ export function namedColors() {
  */
 export function render(font_system, text, width, height, options) {
     _assertClass(font_system, FontSystem);
-    const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
+    _assertClass(text, MCText);
     _assertClass(options, LayoutOptions);
-    const ret = wasm.render(font_system.__wbg_ptr, ptr0, len0, width, height, options.__wbg_ptr);
+    const ret = wasm.render(font_system.__wbg_ptr, text.__wbg_ptr, width, height, options.__wbg_ptr);
     return RenderResult.__wrap(ret);
 }
 

package/package.json

@@ -2,7 +2,7 @@
   "name": "@hexze/mctext",
   "type": "module",
   "description": "Minecraft text formatting for JavaScript/WASM",
-  "version": "1.0.3",
+  "version": "1.1.0",
   "license": "MIT",
   "repository": {
     "type": "git",