@effindomv2/fui-as 0.1.37 → 0.1.41

package/src/core/Worker.ts

@@ -6,7 +6,8 @@ import { warn } from "./Logger";
 import { bind1 } from "./bind";
 
 const FUNCTION_START = "Worker.start";
-const FUNCTION_SEND_STRING = "Worker.sendString";
+const FUNCTION_CONSTRUCTOR = "Worker.constructor";
+const MAX_WORKER_START_INPUT_BYTES: i32 = 1024 * 1024;
 
 const activeWorkers = new Map<u32, Worker>();
 let nextWorkerId: u32 = 1;
@@ -15,6 +16,10 @@ function encodeUtf8(text: string): Uint8Array {
   return Uint8Array.wrap(String.UTF8.encode(text, false));
 }
 
+function isWorkerStartInputWithinLimit(inputByteLength: i32): bool {
+  return inputByteLength <= MAX_WORKER_START_INPUT_BYTES;
+}
+
 function unregisterWorker(workerId: u32): void {
   activeWorkers.delete(workerId);
 }
@@ -23,75 +28,106 @@ function findWorker(workerId: u32): Worker | null {
   return activeWorkers.has(workerId) ? unchecked(activeWorkers.get(workerId)) : null;
 }
 
+export class WorkerProgressEventArgs {
+  readonly message: string;
+
+  constructor(message: string) {
+    this.message = message;
+  }
+}
+
+export class WorkerCompletedEventArgs {
+  readonly result: string;
+
+  constructor(result: string) {
+    this.result = result;
+  }
+}
+
+export class WorkerErrorEventArgs {
+  readonly message: string;
+
+  constructor(message: string) {
+    this.message = message;
+  }
+}
+
 export class Worker implements Disposable {
   private readonly workerId: u32;
+  private readonly wasmPath: string;
   private readonly entryName: string;
-  private progressBinding: Callback1<string> | null = null;
-  private completeBinding: Callback1<string> | null = null;
-  private errorBinding: Callback1<string> | null = null;
+  private progressBinding: Callback1<WorkerProgressEventArgs> | null = null;
+  private completeBinding: Callback1<WorkerCompletedEventArgs> | null = null;
+  private errorBinding: Callback1<WorkerErrorEventArgs> | null = null;
   private started: bool = false;
   private finished: bool = false;
   private cancelRequested: bool = false;
 
-  private constructor(workerId: u32, entryName: string) {
-    this.workerId = workerId;
-    this.entryName = entryName;
-  }
-
-  static start(entryName: string): Worker {
+  constructor(wasmPath: string, entryName: string) {
+    if (changetype<usize>(wasmPath) == 0) {
+      throwNullArgument(FUNCTION_CONSTRUCTOR, "wasmPath");
+    }
     if (changetype<usize>(entryName) == 0) {
-      throwNullArgument(FUNCTION_START, "entryName");
+      throwNullArgument(FUNCTION_CONSTRUCTOR, "entryName");
     }
-    const workerId = nextWorkerId++;
-    const worker = new Worker(workerId, entryName);
-    activeWorkers.set(workerId, worker);
-    return worker;
+    this.workerId = nextWorkerId++;
+    this.wasmPath = wasmPath;
+    this.entryName = entryName;
+    activeWorkers.set(this.workerId, this);
   }
 
-  onProgress<Owner>(owner: Owner, handler: Handler1<Owner, string>): this {
-    this.progressBinding = bind1<Owner, string>(owner, handler);
+  onProgress<Owner>(owner: Owner, handler: Handler1<Owner, WorkerProgressEventArgs>): this {
+    this.progressBinding = bind1<Owner, WorkerProgressEventArgs>(owner, handler);
     return this;
   }
 
-  onProgressWith<Owner>(owner: Owner, handler: Handler1<Owner, string>): this {
+  onProgressWith<Owner>(owner: Owner, handler: Handler1<Owner, WorkerProgressEventArgs>): this {
     return this.onProgress<Owner>(owner, handler);
   }
 
-  onComplete<Owner>(owner: Owner, handler: Handler1<Owner, string>): this {
-    this.completeBinding = bind1<Owner, string>(owner, handler);
+  onComplete<Owner>(owner: Owner, handler: Handler1<Owner, WorkerCompletedEventArgs>): this {
+    this.completeBinding = bind1<Owner, WorkerCompletedEventArgs>(owner, handler);
     return this;
   }
 
-  onCompleteWith<Owner>(owner: Owner, handler: Handler1<Owner, string>): this {
+  onCompleteWith<Owner>(owner: Owner, handler: Handler1<Owner, WorkerCompletedEventArgs>): this {
     return this.onComplete<Owner>(owner, handler);
   }
 
-  onError<Owner>(owner: Owner, handler: Handler1<Owner, string>): this {
-    this.errorBinding = bind1<Owner, string>(owner, handler);
+  onError<Owner>(owner: Owner, handler: Handler1<Owner, WorkerErrorEventArgs>): this {
+    this.errorBinding = bind1<Owner, WorkerErrorEventArgs>(owner, handler);
     return this;
   }
 
-  onErrorWith<Owner>(owner: Owner, handler: Handler1<Owner, string>): this {
+  onErrorWith<Owner>(owner: Owner, handler: Handler1<Owner, WorkerErrorEventArgs>): this {
     return this.onError<Owner>(owner, handler);
   }
 
-  sendString(input: string): this {
+  start(input: string): this {
     if (changetype<usize>(input) == 0) {
-      throwNullArgument(FUNCTION_SEND_STRING, "input");
+      throwNullArgument(FUNCTION_START, "input");
     }
     if (this.finished) {
-      warn("Worker", "sendString ignored after the worker already finished.");
+      warn("Worker", "start ignored after the worker already finished.");
       return this;
     }
     if (this.started) {
-      warn("Worker", "sendString ignored because one-shot workers only accept one input.");
+      warn("Worker", "start ignored because one-shot workers only accept one input.");
       return this;
     }
-    this.started = true;
+    const wasmPathBytes = encodeUtf8(this.wasmPath);
     const entryBytes = encodeUtf8(this.entryName);
     const inputBytes = encodeUtf8(input);
+    if (!isWorkerStartInputWithinLimit(inputBytes.length)) {
+      this.started = true;
+      this.dispatchError("Worker.start input exceeds the maximum UTF-8 payload size.");
+      return this;
+    }
+    this.started = true;
     fui_worker_start_string(
       this.workerId,
+      wasmPathBytes.length > 0 ? wasmPathBytes.dataStart : 0,
+      <u32>wasmPathBytes.length,
       entryBytes.length > 0 ? entryBytes.dataStart : 0,
       <u32>entryBytes.length,
       inputBytes.length > 0 ? inputBytes.dataStart : 0,
@@ -121,7 +157,7 @@ export class Worker implements Disposable {
     }
     const binding = this.progressBinding;
     if (binding !== null) {
-      binding.invoke(message);
+      binding.invoke(new WorkerProgressEventArgs(message));
     }
   }
 
@@ -132,7 +168,7 @@ export class Worker implements Disposable {
     const binding = this.completeBinding;
     this.finish();
     if (binding !== null) {
-      binding.invoke(result);
+      binding.invoke(new WorkerCompletedEventArgs(result));
     }
   }
 
@@ -143,7 +179,7 @@ export class Worker implements Disposable {
     const binding = this.errorBinding;
     this.finish();
     if (binding !== null) {
-      binding.invoke(message);
+      binding.invoke(new WorkerErrorEventArgs(message));
     }
   }
 
@@ -190,7 +226,7 @@ export function disposeAllWorkers(): void {
   }
 }
 
-export function __resetWorkerControllersForTests(): void {
+export function resetWorkerControllers(): void {
   disposeAllWorkers();
   nextWorkerId = 1;
 }

package/src/core/event_exports.ts

@@ -25,7 +25,7 @@ import {
   registerBrowserFile,
 } from "./File";
 import { handleRouteChanged } from "./Navigation";
-import { handleSystemDarkModeChanged } from "./Theme";
+import { handleSystemAccentColorChanged, handleSystemDarkModeChanged } from "./Theme";
 import { handleTimer } from "./Timers";
 import { handleWorkerComplete, handleWorkerError, handleWorkerProgress } from "./Worker";
 import { tickAnimations } from "./Animation";
@@ -39,7 +39,7 @@ import {
   warn,
 } from "./Logger";
 import { Signal } from "./Signal";
-import { DragDropEffects, ExternalDropItemInfo, ExternalDropItemKind } from "./Node";
+import { DragDropEffects, ExternalDropItemInfo, ExternalDropItemKind, GestureEventKind, GestureEventPhase, PointerType, WheelDeltaMode } from "./Node";
 
 const KEY_BUFFER = new Uint8Array(256);
 const TEXT_BUFFER = new Uint8Array(1024 * 1024);
@@ -60,17 +60,120 @@ export function __fui_text_buffer_size(): u32 {
   return <u32>TEXT_BUFFER.length;
 }
 
-export function __fui_on_pointer_event(eventType: u32, handle: u64, x: f32, y: f32, modifiers: u32 = 0): void {
+export function __fui_on_pointer_event_with_metadata(
+  eventType: u32,
+  handle: u64,
+  x: f32,
+  y: f32,
+  modifiers: u32,
+  pointerId: i32,
+  pointerType: u32,
+  button: i32,
+  buttons: u32,
+  pressure: f32,
+  width: f32,
+  height: f32,
+  clickCount: i32,
+): bool {
   log(
     "Event",
     "pointer type=" + describePointerEventType(<PointerEventType>eventType) +
       " handle=" + describeHandle(handle) +
       " x=" + x.toString() +
       " y=" + y.toString() +
-      " modifiers=" + modifiers.toString(),
+      " modifiers=" + modifiers.toString() +
+      " pointerId=" + pointerId.toString() +
+      " pointerType=" + pointerType.toString() +
+      " button=" + button.toString() +
+      " buttons=" + buttons.toString() +
+      " pressure=" + pressure.toString() +
+      " width=" + width.toString() +
+      " height=" + height.toString() +
+      " clickCount=" + clickCount.toString(),
   );
   ContextMenuManager.trackPointerEvent(<PointerEventType>eventType, handle);
-  EventRouter.dispatchPointerEvent(handle, <PointerEventType>eventType, x, y, modifiers);
+  return EventRouter.dispatchPointerEvent(
+    handle,
+    <PointerEventType>eventType,
+    x,
+    y,
+    modifiers,
+    pointerId,
+    <PointerType>pointerType,
+    button,
+    buttons,
+    pressure,
+    width,
+    height,
+    clickCount,
+  );
+}
+
+export function __fui_on_wheel_event(
+  handle: u64,
+  x: f32,
+  y: f32,
+  deltaX: f32,
+  deltaY: f32,
+  deltaMode: u32,
+  modifiers: u32,
+): bool {
+  log(
+    "Event",
+    "wheel handle=" + describeHandle(handle) +
+      " x=" + x.toString() +
+      " y=" + y.toString() +
+      " deltaX=" + deltaX.toString() +
+      " deltaY=" + deltaY.toString() +
+      " modifiers=" + modifiers.toString(),
+  );
+  return EventRouter.dispatchWheelEvent(handle, x, y, deltaX, deltaY, <WheelDeltaMode>deltaMode, modifiers);
+}
+
+export function __fui_resolve_gesture_owner(handle: u64): u64 {
+  return EventRouter.resolveGestureOwner(handle);
+}
+
+export function __fui_get_gesture_intent(handle: u64): u32 {
+  return <u32>EventRouter.getGestureIntent(handle);
+}
+
+export function __fui_resolve_long_press_owner(handle: u64): u64 {
+  return EventRouter.resolveLongPressOwner(handle);
+}
+
+export function __fui_get_long_press_minimum_duration_ms(handle: u64): i32 {
+  return EventRouter.getLongPressMinimumDurationMs(handle);
+}
+
+export function __fui_get_long_press_movement_tolerance(handle: u64): f32 {
+  return EventRouter.getLongPressMovementTolerance(handle);
+}
+
+export function __fui_on_gesture_event(
+  handle: u64,
+  phase: u32,
+  kind: u32,
+  x: f32,
+  y: f32,
+  deltaX: f32,
+  deltaY: f32,
+  scale: f32,
+  pointerCount: i32,
+): bool {
+  return EventRouter.dispatchGestureEvent(handle, <GestureEventPhase>phase, <GestureEventKind>kind, x, y, deltaX, deltaY, scale, pointerCount);
+}
+
+export function __fui_on_long_press_event(
+  handle: u64,
+  x: f32,
+  y: f32,
+  pointerId: i32,
+  pointerType: u32,
+  modifiers: u32,
+  durationMs: i32,
+): bool {
+  return EventRouter.dispatchLongPressEvent(handle, x, y, pointerId, <PointerType>pointerType, modifiers, durationMs);
 }
 
 export function __fui_on_viewport_changed(w: f32, h: f32): void {
@@ -402,6 +505,11 @@ export function __fui_on_system_dark_mode_changed(isDark: bool): void {
   handleSystemDarkModeChanged(isDark);
 }
 
+export function __fui_on_system_accent_color_changed(color: u32): void {
+  log("Event", "system accent color changed=" + color.toString());
+  handleSystemAccentColorChanged(color);
+}
+
 export function __fui_on_route_changed(routePtr: usize, routeLen: u32): void {
   const route = String.UTF8.decodeUnsafe(routePtr, <usize>routeLen, false);
   log("Event", "route changed=" + route);
@@ -451,6 +559,10 @@ export function __fui_on_context_menu(handle: u64, x: f32, y: f32): void {
   ContextMenuManager.showForCurrentSelection(handle, x, y);
 }
 
+export function __fui_can_show_context_menu(handle: u64): bool {
+  return ContextMenuManager.canShowForHandle(handle);
+}
+
 export function __fui_hide_active_context_menu(): void {
   ContextMenuManager.hideActiveMenu();
 }
@@ -608,3 +720,9 @@ export function __fui_on_external_drag_event(
   );
   return <u32>effect;
 }
+
+import { FontFace } from "./Typography";
+
+export function __fui_on_font_loaded(fontId: u32): void {
+  FontFace._dispatchFontLoaded(fontId);
+}