@effindomv2/fui-as 0.1.36 → 0.1.39

package/src/text/DynamicTextLayout.ts

@@ -0,0 +1,275 @@
+import * as ui from "../bindings/ui";
+import { TextOverflow } from "../core/ffi";
+import { FontFamily, FontStack, FontStyle, FontWeight } from "../core/Typography";
+import { TextAlign, TextVerticalAlign, Unit } from "../core/ffi";
+import { TextLayout, TextLayoutReadyEventArgs, TextLayoutReadyHandler } from "./TextLayout";
+
+export enum DynamicTextOverflow {
+  Reject = 0,
+  FallbackShape = 1,
+}
+
+export type DynamicTextLayoutReadyHandler<Owner> = TextLayoutReadyHandler<Owner>;
+
+/**
+ * Short, single-style text resource for labels that change frequently.
+ *
+ * Stage 4 keeps the public API and validation contract separate from the
+ * retained text node backing used by `TextLayout`. A later core resource pass
+ * can replace the backing without changing call sites.
+ */
+export class DynamicTextLayout extends TextLayout {
+  private charsetValue: string = "";
+  private overflowValue: DynamicTextOverflow = DynamicTextOverflow.FallbackShape;
+  private currentTextValue: string = "";
+  private numericMode: bool = false;
+  private numericPrecisionValue: i32 = -1;
+  private numericPrefixValue: string = "";
+  private numericSuffixValue: string = "";
+  private hasNumericValue: bool = false;
+  private numericValue: f64 = 0.0;
+
+  constructor(charset: string = "") {
+    super("");
+    this.charsetValue = charset;
+  }
+
+  static fixedCharset(charset: string): DynamicTextLayout {
+    return new DynamicTextLayout(charset);
+  }
+
+  static numeric(): DynamicTextLayout {
+    const layout = new DynamicTextLayout("0123456789.-");
+    layout.numericMode = true;
+    return layout;
+  }
+
+  get currentText(): string {
+    return this.currentTextValue;
+  }
+
+  /** @internal */
+  _prepareNow(): void {
+    ui.setDynamicTextCharset(this._drawNode().builtHandle, this.charsetValue);
+    super._prepareNow();
+  }
+
+  setText(value: string): bool {
+    if (!this.supportsText(value)) {
+      if (this.overflowValue == DynamicTextOverflow.Reject) {
+        return false;
+      }
+    }
+    const wasReady = this.isReady;
+    this.currentTextValue = value;
+    super.text(value);
+    if (wasReady) {
+      this._prepareNow();
+    }
+    return true;
+  }
+
+  overflow(mode: DynamicTextOverflow): this {
+    this.overflowValue = mode;
+    return this;
+  }
+
+  precision(digits: i32): this {
+    this.numericMode = true;
+    this.numericPrecisionValue = digits < 0 ? 0 : digits;
+    this.refreshNumericText();
+    return this;
+  }
+
+  prefix(value: string): this {
+    this.numericMode = true;
+    this.numericPrefixValue = value;
+    this.includeInCharset(value);
+    this.refreshNumericText();
+    return this;
+  }
+
+  suffix(value: string): this {
+    this.numericMode = true;
+    this.numericSuffixValue = value;
+    this.includeInCharset(value);
+    this.refreshNumericText();
+    return this;
+  }
+
+  setValue(value: f64): bool {
+    this.numericMode = true;
+    this.hasNumericValue = true;
+    this.numericValue = value;
+    return this.setText(this.composeNumericText(value));
+  }
+
+  textOverflow(mode: TextOverflow): this {
+    super.overflow(mode);
+    return this;
+  }
+
+  onReady(callback: (event: TextLayoutReadyEventArgs) => void): this {
+    super.onReady(callback);
+    return this;
+  }
+
+  onReadyWith<Owner>(owner: Owner, handler: TextLayoutReadyHandler<Owner>): this {
+    super.onReadyWith<Owner>(owner, handler);
+    return this;
+  }
+
+  width(value: f32, unit: Unit = Unit.Pixel): this {
+    super.width(value, unit);
+    return this;
+  }
+
+  height(value: f32, unit: Unit = Unit.Pixel): this {
+    super.height(value, unit);
+    return this;
+  }
+
+  fontStack(stack: FontStack, size: f32): this {
+    super.fontStack(stack, size);
+    return this;
+  }
+
+  fontFamily(family: FontFamily): this {
+    super.fontFamily(family);
+    return this;
+  }
+
+  fontWeight(weight: FontWeight): this {
+    super.fontWeight(weight);
+    return this;
+  }
+
+  fontStyle(style: FontStyle): this {
+    super.fontStyle(style);
+    return this;
+  }
+
+  fontSize(size: f32): this {
+    super.fontSize(size);
+    return this;
+  }
+
+  lineHeight(px: f32): this {
+    super.lineHeight(px);
+    return this;
+  }
+
+  color(color: u32): this {
+    super.color(color);
+    return this;
+  }
+
+  textColor(color: u32): this {
+    super.textColor(color);
+    return this;
+  }
+
+  textAlign(align: TextAlign): this {
+    super.textAlign(align);
+    return this;
+  }
+
+  verticalAlign(align: TextVerticalAlign): this {
+    super.verticalAlign(align);
+    return this;
+  }
+
+  maxLines(lines: i32): this {
+    super.maxLines(lines);
+    return this;
+  }
+
+  textLimits(maxChars: i32, maxLines: i32): this {
+    super.textLimits(maxChars, maxLines);
+    return this;
+  }
+
+  wrap(flag: bool = true): this {
+    super.wrap(flag);
+    return this;
+  }
+
+  wrapping(flag: bool = true): this {
+    super.wrapping(flag);
+    return this;
+  }
+
+  private supportsText(value: string): bool {
+    if (this.charsetValue.length == 0) {
+      return true;
+    }
+    for (let i = 0; i < value.length; i++) {
+      if (!this.charsetContains(value.charCodeAt(i))) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  private charsetContains(code: i32): bool {
+    for (let i = 0; i < this.charsetValue.length; i++) {
+      if (this.charsetValue.charCodeAt(i) == code) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  private includeInCharset(value: string): void {
+    for (let i = 0; i < value.length; i++) {
+      const code = value.charCodeAt(i);
+      if (!this.charsetContains(code)) {
+        this.charsetValue += value.charAt(i);
+      }
+    }
+  }
+
+  private refreshNumericText(): void {
+    if (!this.numericMode || !this.hasNumericValue) {
+      return;
+    }
+    this.setText(this.composeNumericText(this.numericValue));
+  }
+
+  private composeNumericText(value: f64): string {
+    this.includeInCharset(this.numericPrefixValue);
+    this.includeInCharset(this.numericSuffixValue);
+    return this.numericPrefixValue + this.formatNumericValue(value) + this.numericSuffixValue;
+  }
+
+  private formatNumericValue(value: f64): string {
+    if (value != value || !isFinite(value) || this.numericPrecisionValue < 0) {
+      return value.toString();
+    }
+
+    let scale: i64 = 1;
+    for (let i = 0; i < this.numericPrecisionValue; i++) {
+      scale *= 10;
+    }
+
+    const negative = value < 0.0;
+    const absValue = negative ? -value : value;
+    const scaled = <i64>Math.round(absValue * <f64>scale);
+    const whole = scaled / scale;
+    const fraction = scaled % scale;
+
+    let text = whole.toString();
+    if (this.numericPrecisionValue > 0) {
+      let fractionText = fraction.toString();
+      while (fractionText.length < this.numericPrecisionValue) {
+        fractionText = "0" + fractionText;
+      }
+      text += "." + fractionText;
+    }
+
+    if (negative) {
+      text = "-" + text;
+    }
+    return text;
+  }
+}

package/src/text/TextLayout.ts

@@ -0,0 +1,308 @@
+import * as ui from "../bindings/ui";
+import { LoadedEventArgs, onLoadedWith } from "../core/FrameScheduler";
+import { error } from "../core/Logger";
+import { Node } from "../core/Node";
+import { FontFace, FontFamily, FontStack, FontStyle, FontWeight, FontsLoadedEventArgs } from "../core/Typography";
+import { TextAlign, TextOverflow, TextVerticalAlign, Unit } from "../core/ffi";
+import { RichText, RichTextSpan } from "../nodes/RichText";
+import { Text } from "../nodes/Text";
+
+export class TextLayoutReadyEventArgs {
+  readonly layout: TextLayout;
+
+  constructor(layout: TextLayout) {
+    this.layout = layout;
+  }
+}
+
+export type TextLayoutReadyHandler<Owner> = (owner: Owner, event: TextLayoutReadyEventArgs) => void;
+
+export class TextMetrics {
+  constructor(
+    readonly width: f32 = 0.0,
+    readonly height: f32 = 0.0,
+    readonly baseline: f32 = 0.0,
+    readonly lineCount: i32 = 0,
+    readonly maxLineWidth: f32 = 0.0,
+  ) {}
+}
+
+class TextLayoutReadyCallback {
+  constructor(
+    private readonly layout: TextLayout,
+    private readonly callback: (event: TextLayoutReadyEventArgs) => void,
+  ) {}
+
+  handleReady(): void {
+    onLoadedWith<TextLayoutReadyCallback>(this, handleTextLayoutLoaded);
+  }
+
+  handleLoaded(): void {
+    this.layout._ensureBuiltForReady();
+    FontFace.whenFontsLoadedWith<TextLayoutReadyCallback>(
+      this.layout._requiredFontIdsForReady(),
+      this,
+      handleTextLayoutFontsReady,
+    );
+  }
+
+  handleFontsReady(): void {
+    this.layout._prepareNow();
+    this.callback(new TextLayoutReadyEventArgs(this.layout));
+  }
+}
+
+class TextLayoutReadyHandlerAction<Owner> {
+  constructor(
+    private readonly layout: TextLayout,
+    private readonly owner: Owner,
+    private readonly handler: TextLayoutReadyHandler<Owner>,
+  ) {}
+
+  handleReady(): void {
+    onLoadedWith<TextLayoutReadyHandlerAction<Owner>>(
+      this,
+      (action: TextLayoutReadyHandlerAction<Owner>, _event: LoadedEventArgs): void => {
+        action.handleLoaded();
+      },
+    );
+  }
+
+  handleLoaded(): void {
+    this.layout._ensureBuiltForReady();
+    FontFace.whenFontsLoadedWith<TextLayoutReadyHandlerAction<Owner>>(
+      this.layout._requiredFontIdsForReady(),
+      this,
+      (action: TextLayoutReadyHandlerAction<Owner>, _event: FontsLoadedEventArgs): void => {
+        action.handleFontsReady();
+      },
+    );
+  }
+
+  handleFontsReady(): void {
+    this.layout._prepareNow();
+    this.handler(this.owner, new TextLayoutReadyEventArgs(this.layout));
+  }
+}
+
+function handleTextLayoutReady(callback: TextLayoutReadyCallback): void {
+  callback.handleReady();
+}
+
+function handleTextLayoutLoaded(callback: TextLayoutReadyCallback, _event: LoadedEventArgs): void {
+  callback.handleLoaded();
+}
+
+function handleTextLayoutFontsReady(callback: TextLayoutReadyCallback, _event: FontsLoadedEventArgs): void {
+  callback.handleFontsReady();
+}
+
+/**
+ * Immediate-mode formatted text resource.
+ *
+ * Stage 3 backs this with the existing retained text preparation pipeline so it
+ * shares HarfBuzz shaping, fallback fonts, RichText style runs, and core glyph
+ * rendering with `Text`/`RichText`.
+ */
+export class TextLayout {
+  private readonly nodeValue: Text;
+  private readyValue: bool = false;
+  private metricsValue: TextMetrics = new TextMetrics();
+
+  constructor(text: string = "", node: Text | null = null) {
+    this.nodeValue = node === null ? new Text(text) : changetype<Text>(node);
+  }
+
+  static text(text: string): TextLayout {
+    return new TextLayout(text);
+  }
+
+  static rich(fragments: Array<RichTextSpan>): TextLayout {
+    return new TextLayout("", new RichText(fragments));
+  }
+
+  get isReady(): bool {
+    return this.readyValue;
+  }
+
+  /** @internal */
+  _drawNode(): Node {
+    this.ensureBuilt();
+    return this.nodeValue;
+  }
+
+  /** @internal */
+  _prepareNow(): void {
+    this.ensureBuilt();
+    const prepared = ui.prepareNode(this.nodeValue.builtHandle);
+    if (prepared == 0) {
+      this.readyValue = false;
+      this.metricsValue = new TextMetrics();
+      return;
+    }
+    const metrics = ui.tryGetTextMetrics(this.nodeValue.builtHandle);
+    if (metrics === null) {
+      this.metricsValue = new TextMetrics();
+    } else {
+      this.metricsValue = new TextMetrics(
+        unchecked(metrics[0]),
+        unchecked(metrics[1]),
+        unchecked(metrics[2]),
+        <i32>unchecked(metrics[3]),
+        unchecked(metrics[4]),
+      );
+    }
+    this.readyValue = true;
+  }
+
+  measure(): TextMetrics {
+    if (!this.readyValue) {
+      error("TextLayout", "TextLayout.measure() called before the TextLayout was ready; register onReady/onReadyWith and measure after the callback.");
+      return new TextMetrics();
+    }
+    return this.metricsValue;
+  }
+
+  get measuredWidth(): f32 {
+    return this.measure().width;
+  }
+
+  get measuredHeight(): f32 {
+    return this.measure().height;
+  }
+
+  onReady(callback: (event: TextLayoutReadyEventArgs) => void): this {
+    const ready = new TextLayoutReadyCallback(this, callback);
+    handleTextLayoutReady(ready);
+    return this;
+  }
+
+  onReadyWith<Owner>(owner: Owner, handler: TextLayoutReadyHandler<Owner>): this {
+    const ready = new TextLayoutReadyHandlerAction<Owner>(this, owner, handler);
+    ready.handleReady();
+    return this;
+  }
+
+  text(value: string): this {
+    this.nodeValue.text(value);
+    this.markDirty();
+    return this;
+  }
+
+  width(value: f32, unit: Unit = Unit.Pixel): this {
+    this.nodeValue.width(value, unit);
+    this.markDirty();
+    return this;
+  }
+
+  height(value: f32, unit: Unit = Unit.Pixel): this {
+    this.nodeValue.height(value, unit);
+    this.markDirty();
+    return this;
+  }
+
+  fontStack(stack: FontStack, size: f32): this {
+    this.nodeValue.fontStack(stack, size);
+    this.markDirty();
+    return this;
+  }
+
+  fontFamily(family: FontFamily): this {
+    this.nodeValue.fontFamily(family);
+    this.markDirty();
+    return this;
+  }
+
+  fontWeight(weight: FontWeight): this {
+    this.nodeValue.fontWeight(weight);
+    this.markDirty();
+    return this;
+  }
+
+  fontStyle(style: FontStyle): this {
+    this.nodeValue.fontStyle(style);
+    this.markDirty();
+    return this;
+  }
+
+  fontSize(size: f32): this {
+    this.nodeValue.fontSize(size);
+    this.markDirty();
+    return this;
+  }
+
+  lineHeight(px: f32): this {
+    this.nodeValue.lineHeight(px);
+    this.markDirty();
+    return this;
+  }
+
+  color(color: u32): this {
+    this.nodeValue.textColor(color);
+    this.markDirty();
+    return this;
+  }
+
+  textColor(color: u32): this {
+    return this.color(color);
+  }
+
+  textAlign(align: TextAlign): this {
+    this.nodeValue.textAlign(align);
+    this.markDirty();
+    return this;
+  }
+
+  verticalAlign(align: TextVerticalAlign): this {
+    this.nodeValue.verticalAlign(align);
+    this.markDirty();
+    return this;
+  }
+
+  maxLines(lines: i32): this {
+    this.nodeValue.maxLines(lines);
+    this.markDirty();
+    return this;
+  }
+
+  textLimits(maxChars: i32, maxLines: i32): this {
+    this.nodeValue.textLimits(maxChars, maxLines);
+    this.markDirty();
+    return this;
+  }
+
+  wrap(flag: bool = true): this {
+    this.nodeValue.wrapping(flag);
+    this.markDirty();
+    return this;
+  }
+
+  wrapping(flag: bool = true): this {
+    return this.wrap(flag);
+  }
+
+  overflow(mode: TextOverflow): this {
+    this.nodeValue.overflow(mode);
+    this.markDirty();
+    return this;
+  }
+
+  private ensureBuilt(): void {
+    this.nodeValue.build();
+  }
+
+  /** @internal */
+  _ensureBuiltForReady(): void {
+    this.ensureBuilt();
+  }
+
+  /** @internal */
+  _requiredFontIdsForReady(): Array<u32> {
+    return this.nodeValue._requiredFontIds();
+  }
+
+  private markDirty(): void {
+    this.readyValue = false;
+    this.metricsValue = new TextMetrics();
+  }
+}

package/src/worker/Worker.ts

@@ -1,8 +1,6 @@
 import {
   fui_worker_complete_string,
-  fui_worker_copy_input,
   fui_worker_fail,
-  fui_worker_input_length,
   fui_worker_is_cancelled,
   fui_worker_request_yield,
   fui_worker_request_yield_delay,
@@ -10,45 +8,21 @@ import {
 } from "./ffi";
 import { handleFetchComplete, handleFetchError } from "../core/Fetch";
 
-let inputRead = false;
-let inputCache = "";
 let terminalSent = false;
-let testInputOverride: string | null = null;
 const WORKER_CALLBACK_BUFFER = new Uint8Array(1024 * 1024);
 
 function encodeUtf8(text: string): Uint8Array {
   return Uint8Array.wrap(String.UTF8.encode(text, false));
 }
 
-function readInputMessage(): string {
-  if (testInputOverride !== null) {
-    return changetype<string>(testInputOverride);
-  }
-  const byteLength = fui_worker_input_length();
-  if (byteLength == 0) {
-    return "";
-  }
-  const bytes = new Uint8Array(byteLength);
-  const copied = fui_worker_copy_input(bytes.dataStart, <u32>bytes.length);
-  if (copied == 0) {
-    return "";
-  }
-  return String.UTF8.decodeUnsafe(bytes.dataStart, <usize>copied, false);
-}
-
 function sendText(text: string, callback: (ptr: usize, len: u32) => void): void {
   const bytes = encodeUtf8(text);
   callback(bytes.length > 0 ? bytes.dataStart : 0, <u32>bytes.length);
 }
 
 export class Worker {
-  static receiveMessage(): string {
-    if (inputRead) {
-      return inputCache;
-    }
-    inputCache = readInputMessage();
-    inputRead = true;
-    return inputCache;
+  static entry(inputPtr: usize, inputLen: u32, handler: (input: string) => void): void {
+    handler(inputPtr == 0 || inputLen == 0 ? "" : String.UTF8.decodeUnsafe(inputPtr, <usize>inputLen, false));
   }
 
   static reportProgress(progress: string): void {
@@ -157,13 +131,6 @@ export function __fui_on_fetch_error(requestId: u32, payloadPtr: usize, payloadL
   );
 }
 
-export function __resetWorkerRuntimeForTests(): void {
-  inputRead = false;
-  inputCache = "";
+export function resetWorkerRuntime(): void {
   terminalSent = false;
-  testInputOverride = null;
-}
-
-export function __setWorkerInputForTests(value: string): void {
-  testInputOverride = value;
 }

package/src/worker/WorkerJob.ts

@@ -4,8 +4,8 @@ export abstract class WorkerJob {
   private started: bool = false;
   private finished: bool = false;
 
-  static resume<T extends WorkerJob>(job: T): T | null {
-    job.ensureStarted();
+  static resume<T extends WorkerJob>(job: T, input: string = ""): T | null {
+    job.ensureStarted(input);
     if (job.finished) {
       return null;
     }
@@ -13,14 +13,10 @@ export abstract class WorkerJob {
     return job.finished ? null : job;
   }
 
-  protected onStart(): void {}
+  protected onStart(input: string): void {}
 
   abstract run(): void;
 
-  protected receiveMessage(): string {
-    return Worker.receiveMessage();
-  }
-
   protected reportProgress(progress: string): void {
     if (this.finished) {
       return;
@@ -55,11 +51,11 @@ export abstract class WorkerJob {
     return Worker.yield(delayMs);
   }
 
-  private ensureStarted(): void {
+  private ensureStarted(input: string): void {
     if (this.started) {
       return;
     }
     this.started = true;
-    this.onStart();
+    this.onStart(input);
   }
 }

package/src/worker/ffi.ts

@@ -1,9 +1,3 @@
-@external("fui_worker_host", "fui_worker_input_length")
-export declare function fui_worker_input_length(): u32;
-
-@external("fui_worker_host", "fui_worker_copy_input")
-export declare function fui_worker_copy_input(ptr: usize, capacity: u32): u32;
-
 @external("fui_worker_host", "fui_worker_report_progress")
 export declare function fui_worker_report_progress(ptr: usize, len: u32): void;