@effindomv2/fui-as 0.1.36 → 0.1.39

package/src/core/File.ts

@@ -23,6 +23,7 @@ const FUNCTION_SAVE_TEXT_WITH = "FileSaveRequest.saveTextWith";
 const FUNCTION_SAVE_BYTES_WITH = "FileSaveRequest.saveBytesWith";
 const FUNCTION_CREATE_WRITER_WITH = "FileSaveRequest.createWriterWith";
 const FUNCTION_FILE_WORKER_PROCESS_START = "FileWorkerProcessRequest.start";
+const FUNCTION_FILE_WORKER_PROCESS_WORKER = "FileWorkerProcessRequest.worker";
 const FUNCTION_WRITE_TEXT_CHUNK_WITH = "BrowserFileWriter.writeTextChunkWith";
 const FUNCTION_WRITE_BYTES_CHUNK_WITH = "BrowserFileWriter.writeBytesChunkWith";
 const FUNCTION_FINISH_WITH = "BrowserFileWriter.finishWith";
@@ -70,9 +71,9 @@ function describeFileFailure(status: u32, fallback: string): string {
   return fallback;
 }
 
-function dispatchFileError(binding: Callback1<string> | null, message: string): void {
+function dispatchFileError(binding: Callback1<FileErrorEventArgs> | null, message: string): void {
   if (binding !== null) {
-    binding.invoke(message);
+    binding.invoke(new FileErrorEventArgs(message));
     return;
   }
   warn("File", message);
@@ -163,43 +164,43 @@ class FileRequestDisposable implements Disposable {
 
 class PendingOpenRequest {
   constructor(
-    readonly completeBinding: Callback1<Array<BrowserFile>>,
-    readonly errorBinding: Callback1<string> | null,
+    readonly completeBinding: Callback1<FileOpenEventArgs>,
+    readonly errorBinding: Callback1<FileErrorEventArgs> | null,
   ) {}
 }
 
 class PendingReadRequest {
   constructor(
     readonly completeBinding: Callback1<FileReadChunk>,
-    readonly errorBinding: Callback1<string> | null,
+    readonly errorBinding: Callback1<FileErrorEventArgs> | null,
   ) {}
 }
 
 class PendingSaveRequest {
   constructor(
     readonly completeBinding: Callback1<FileSaveResult>,
-    readonly errorBinding: Callback1<string> | null,
+    readonly errorBinding: Callback1<FileErrorEventArgs> | null,
   ) {}
 }
 
 class PendingWriterCreateRequest {
   constructor(
     readonly completeBinding: Callback1<BrowserFileWriter>,
-    readonly errorBinding: Callback1<string> | null,
+    readonly errorBinding: Callback1<FileErrorEventArgs> | null,
   ) {}
 }
 
 class PendingWriterWriteRequest {
   constructor(
     readonly completeBinding: Callback1<FileWriteProgress>,
-    readonly errorBinding: Callback1<string> | null,
+    readonly errorBinding: Callback1<FileErrorEventArgs> | null,
   ) {}
 }
 
 class PendingWriterFinishRequest {
   constructor(
     readonly completeBinding: Callback1<FileSaveResult>,
-    readonly errorBinding: Callback1<string> | null,
+    readonly errorBinding: Callback1<FileErrorEventArgs> | null,
   ) {}
 }
 
@@ -228,6 +229,22 @@ export class FileCapabilities {
   }
 }
 
+export class FileOpenEventArgs {
+  readonly files: Array<BrowserFile>;
+
+  constructor(files: Array<BrowserFile>) {
+    this.files = files;
+  }
+}
+
+export class FileErrorEventArgs {
+  readonly message: string;
+
+  constructor(message: string) {
+    this.message = message;
+  }
+}
+
 export class FileReadChunk {
   readonly offsetBytes: u64;
   readonly fileSizeBytes: u64;
@@ -314,14 +331,14 @@ export class BrowserFile {
     offsetBytes: u64,
     maxBytes: u32,
     handler: Handler1<Owner, FileReadChunk>,
-    errorHandler: Handler1<Owner, string> | null = null,
+    errorHandler: Handler1<Owner, FileErrorEventArgs> | null = null,
   ): Disposable {
     if (changetype<usize>(handler) == 0) {
       throwNullArgument(FUNCTION_READ_BYTES_CHUNK_WITH, "handler");
     }
     if (maxBytes == 0) {
       dispatchFileError(
-        errorHandler === null ? null : bind1<Owner, string>(owner, errorHandler),
+        errorHandler === null ? null : bind1<Owner, FileErrorEventArgs>(owner, errorHandler),
         "BrowserFile.readBytesChunkWith: maxBytes must be greater than zero.",
       );
       return new FileRequestDisposable(REQUEST_KIND_READ, 0);
@@ -329,7 +346,7 @@ export class BrowserFile {
     const fileIdBytes = encodeUtf8(this.id);
     const requestId = registerPendingReadRequest(new PendingReadRequest(
       bind1<Owner, FileReadChunk>(owner, handler),
-      errorHandler === null ? null : bind1<Owner, string>(owner, errorHandler),
+      errorHandler === null ? null : bind1<Owner, FileErrorEventArgs>(owner, errorHandler),
     ));
     fui_file_read_chunk(
       requestId,
@@ -344,13 +361,15 @@ export class BrowserFile {
 
 export class FileWorkerProcessRequest implements Disposable {
   private readonly file: BrowserFile;
+  private workerWasmPathValue: string = "";
+  private workerEntryNameValue: string = "";
   private suggestedNameValue: string;
   private saveToPickedFileEnabled: bool = false;
   private chunkBytesValue: u32 = 64 * 1024;
   private chunkBinding: Callback1<FileReadChunk> | null = null;
   private progressBinding: Callback1<FileWorkerProcessProgress> | null = null;
   private completeBinding: Callback1<FileWorkerProcessResult> | null = null;
-  private errorBinding: Callback1<string> | null = null;
+  private errorBinding: Callback1<FileErrorEventArgs> | null = null;
   private requestId: u32 = 0;
   private started: bool = false;
   private finished: bool = false;
@@ -368,6 +387,18 @@ export class FileWorkerProcessRequest implements Disposable {
     return this;
   }
 
+  worker(wasmPath: string, entryName: string): this {
+    if (changetype<usize>(wasmPath) == 0) {
+      throwNullArgument(FUNCTION_FILE_WORKER_PROCESS_WORKER, "wasmPath");
+    }
+    if (changetype<usize>(entryName) == 0) {
+      throwNullArgument(FUNCTION_FILE_WORKER_PROCESS_WORKER, "entryName");
+    }
+    this.workerWasmPathValue = wasmPath;
+    this.workerEntryNameValue = entryName;
+    return this;
+  }
+
   saveToPickedFile(value: string): this {
     this.saveToPickedFileEnabled = true;
     return this.suggestedName(value);
@@ -414,15 +445,15 @@ export class FileWorkerProcessRequest implements Disposable {
     return this.onComplete<Owner>(owner, handler);
   }
 
-  onError<Owner>(owner: Owner, handler: Handler1<Owner, string>): this {
+  onError<Owner>(owner: Owner, handler: Handler1<Owner, FileErrorEventArgs>): this {
     if (changetype<usize>(handler) == 0) {
       throwNullArgument("FileWorkerProcessRequest.onError", "handler");
     }
-    this.errorBinding = bind1<Owner, string>(owner, handler);
+    this.errorBinding = bind1<Owner, FileErrorEventArgs>(owner, handler);
     return this;
   }
 
-  onErrorWith<Owner>(owner: Owner, handler: Handler1<Owner, string>): this {
+  onErrorWith<Owner>(owner: Owner, handler: Handler1<Owner, FileErrorEventArgs>): this {
     return this.onError<Owner>(owner, handler);
   }
 
@@ -439,16 +470,26 @@ export class FileWorkerProcessRequest implements Disposable {
       dispatchFileError(this.errorBinding, "FileWorkerProcessRequest.start: chunkBytes must be greater than zero.");
       return this;
     }
+    if (this.workerWasmPathValue.length == 0 || this.workerEntryNameValue.length == 0) {
+      dispatchFileError(this.errorBinding, "FileWorkerProcessRequest.start: worker(wasmPath, entryName) is required.");
+      return this;
+    }
     if (!this.saveToPickedFileEnabled && this.chunkBinding === null) {
       dispatchFileError(this.errorBinding, "FileWorkerProcessRequest.start: either saveToPickedFile(...) or onChunk(...) is required.");
       return this;
     }
+    const workerWasmPathBytes = encodeUtf8(this.workerWasmPathValue);
+    const workerEntryNameBytes = encodeUtf8(this.workerEntryNameValue);
     const fileIdBytes = encodeUtf8(this.file.id);
     const suggestedNameBytes = encodeUtf8(this.suggestedNameValue);
     this.requestId = registerPendingWorkerProcessRequest(this);
     this.started = true;
     fui_file_process_worker_start(
       this.requestId,
+      workerWasmPathBytes.length > 0 ? workerWasmPathBytes.dataStart : 0,
+      <u32>workerWasmPathBytes.length,
+      workerEntryNameBytes.length > 0 ? workerEntryNameBytes.dataStart : 0,
+      <u32>workerEntryNameBytes.length,
       fileIdBytes.length > 0 ? fileIdBytes.dataStart : 0,
       <u32>fileIdBytes.length,
       suggestedNameBytes.length > 0 ? suggestedNameBytes.dataStart : 0,
@@ -550,7 +591,7 @@ export class BrowserFileWriter {
     owner: Owner,
     text: string,
     handler: Handler1<Owner, FileWriteProgress>,
-    errorHandler: Handler1<Owner, string> | null = null,
+    errorHandler: Handler1<Owner, FileErrorEventArgs> | null = null,
   ): Disposable {
     if (changetype<usize>(text) == 0) {
       throwNullArgument(FUNCTION_WRITE_TEXT_CHUNK_WITH, "text");
@@ -562,7 +603,7 @@ export class BrowserFileWriter {
     const textBytes = encodeUtf8(text);
     const requestId = registerPendingWriterWriteRequest(new PendingWriterWriteRequest(
       bind1<Owner, FileWriteProgress>(owner, handler),
-      errorHandler === null ? null : bind1<Owner, string>(owner, errorHandler),
+      errorHandler === null ? null : bind1<Owner, FileErrorEventArgs>(owner, errorHandler),
     ));
     fui_file_writer_write_text(
       requestId,
@@ -578,7 +619,7 @@ export class BrowserFileWriter {
     owner: Owner,
     bytes: Uint8Array,
     handler: Handler1<Owner, FileWriteProgress>,
-    errorHandler: Handler1<Owner, string> | null = null,
+    errorHandler: Handler1<Owner, FileErrorEventArgs> | null = null,
   ): Disposable {
     if (changetype<usize>(bytes) == 0) {
       throwNullArgument(FUNCTION_WRITE_BYTES_CHUNK_WITH, "bytes");
@@ -589,7 +630,7 @@ export class BrowserFileWriter {
     const writerIdBytes = encodeUtf8(this.writerId);
     const requestId = registerPendingWriterWriteRequest(new PendingWriterWriteRequest(
       bind1<Owner, FileWriteProgress>(owner, handler),
-      errorHandler === null ? null : bind1<Owner, string>(owner, errorHandler),
+      errorHandler === null ? null : bind1<Owner, FileErrorEventArgs>(owner, errorHandler),
     ));
     fui_file_writer_write_bytes(
       requestId,
@@ -604,7 +645,7 @@ export class BrowserFileWriter {
   finishWith<Owner>(
     owner: Owner,
     handler: Handler1<Owner, FileSaveResult>,
-    errorHandler: Handler1<Owner, string> | null = null,
+    errorHandler: Handler1<Owner, FileErrorEventArgs> | null = null,
   ): Disposable {
     if (changetype<usize>(handler) == 0) {
       throwNullArgument(FUNCTION_FINISH_WITH, "handler");
@@ -612,7 +653,7 @@ export class BrowserFileWriter {
     const writerIdBytes = encodeUtf8(this.writerId);
     const requestId = registerPendingWriterFinishRequest(new PendingWriterFinishRequest(
       bind1<Owner, FileSaveResult>(owner, handler),
-      errorHandler === null ? null : bind1<Owner, string>(owner, errorHandler),
+      errorHandler === null ? null : bind1<Owner, FileErrorEventArgs>(owner, errorHandler),
     ));
     fui_file_writer_finish(
       requestId,
@@ -642,16 +683,16 @@ export class FileOpenRequest {
 
   pickWith<Owner>(
     owner: Owner,
-    handler: Handler1<Owner, Array<BrowserFile>>,
-    errorHandler: Handler1<Owner, string> | null = null,
+    handler: Handler1<Owner, FileOpenEventArgs>,
+    errorHandler: Handler1<Owner, FileErrorEventArgs> | null = null,
   ): Disposable {
     if (changetype<usize>(handler) == 0) {
       throwNullArgument(FUNCTION_PICK_WITH, "handler");
     }
     const acceptBytes = encodeUtf8(this.acceptValue);
     const requestId = registerPendingOpenRequest(new PendingOpenRequest(
-      bind1<Owner, Array<BrowserFile>>(owner, handler),
-      errorHandler === null ? null : bind1<Owner, string>(owner, errorHandler),
+      bind1<Owner, FileOpenEventArgs>(owner, handler),
+      errorHandler === null ? null : bind1<Owner, FileErrorEventArgs>(owner, errorHandler),
     ));
     fui_file_pick(
       requestId,
@@ -696,7 +737,7 @@ export class FileSaveRequest {
     owner: Owner,
     text: string,
     handler: Handler1<Owner, FileSaveResult>,
-    errorHandler: Handler1<Owner, string> | null = null,
+    errorHandler: Handler1<Owner, FileErrorEventArgs> | null = null,
   ): Disposable {
     if (changetype<usize>(text) == 0) {
       throwNullArgument(FUNCTION_SAVE_TEXT_WITH, "text");
@@ -710,7 +751,7 @@ export class FileSaveRequest {
     const textBytes = encodeUtf8(text);
     const requestId = registerPendingSaveRequest(new PendingSaveRequest(
       bind1<Owner, FileSaveResult>(owner, handler),
-      errorHandler === null ? null : bind1<Owner, string>(owner, errorHandler),
+      errorHandler === null ? null : bind1<Owner, FileErrorEventArgs>(owner, errorHandler),
     ));
     fui_file_save_text(
       requestId,
@@ -730,7 +771,7 @@ export class FileSaveRequest {
     owner: Owner,
     bytes: Uint8Array,
     handler: Handler1<Owner, FileSaveResult>,
-    errorHandler: Handler1<Owner, string> | null = null,
+    errorHandler: Handler1<Owner, FileErrorEventArgs> | null = null,
   ): Disposable {
     if (changetype<usize>(bytes) == 0) {
       throwNullArgument(FUNCTION_SAVE_BYTES_WITH, "bytes");
@@ -743,7 +784,7 @@ export class FileSaveRequest {
     const extensionBytes = encodeUtf8(this.fileExtensionValue);
     const requestId = registerPendingSaveRequest(new PendingSaveRequest(
       bind1<Owner, FileSaveResult>(owner, handler),
-      errorHandler === null ? null : bind1<Owner, string>(owner, errorHandler),
+      errorHandler === null ? null : bind1<Owner, FileErrorEventArgs>(owner, errorHandler),
     ));
     fui_file_save_bytes(
       requestId,
@@ -762,7 +803,7 @@ export class FileSaveRequest {
   createWriterWith<Owner>(
     owner: Owner,
     handler: Handler1<Owner, BrowserFileWriter>,
-    errorHandler: Handler1<Owner, string> | null = null,
+    errorHandler: Handler1<Owner, FileErrorEventArgs> | null = null,
   ): Disposable {
     if (changetype<usize>(handler) == 0) {
       throwNullArgument(FUNCTION_CREATE_WRITER_WITH, "handler");
@@ -772,7 +813,7 @@ export class FileSaveRequest {
     const extensionBytes = encodeUtf8(this.fileExtensionValue);
     const requestId = registerPendingWriterCreateRequest(new PendingWriterCreateRequest(
       bind1<Owner, BrowserFileWriter>(owner, handler),
-      errorHandler === null ? null : bind1<Owner, string>(owner, errorHandler),
+      errorHandler === null ? null : bind1<Owner, FileErrorEventArgs>(owner, errorHandler),
     ));
     fui_file_create_writer(
       requestId,
@@ -842,7 +883,7 @@ export function handleFilePickResult(requestId: u32, status: u32, files: Array<B
     return;
   }
   if (status == FILE_STATUS_SUCCESS) {
-    request.completeBinding.invoke(files);
+    request.completeBinding.invoke(new FileOpenEventArgs(files));
     return;
   }
   dispatchFileError(request.errorBinding, message === null ? describeFileFailure(status, "File picker failed.") : message);
@@ -998,7 +1039,7 @@ export function disposeAllFileRequests(): void {
   pendingWorkerProcessRequests.clear();
 }
 
-export function __resetFileForTests(): void {
+export function resetFileRuntime(): void {
   disposeAllFileRequests();
   browserFiles.clear();
   nextFileRequestId = 1;

package/src/core/FocusAdornerManager.ts

@@ -1,5 +1,5 @@
 import * as ui from "../bindings/ui";
-import { BorderStyle, Unit } from "./ffi";
+import { Unit } from "./ffi";
 import { Node } from "./Node";
 import { activeTheme } from "./Theme";
 import { Portal, FlexBox } from "../nodes";
@@ -53,7 +53,7 @@ export class FocusAdornerManager {
     const ringNode = new FlexBox()
       .positionAbsolute()
       .bgColor(0x00000000)
-      .border(STANDARD_FOCUS_RING_WIDTH, 0x00000000, BorderStyle.Solid);
+      .border(STANDARD_FOCUS_RING_WIDTH, 0x00000000);
     const hostRoot = new Portal()
       .positionAbsolute()
       .position(0.0, 0.0)
@@ -168,7 +168,7 @@ export class FocusAdornerManager {
       style.bottomLeftRadius != this.lastBottomLeftRadius
     ) {
       ringNode.corners(style.topLeftRadius, style.topRightRadius, style.bottomRightRadius, style.bottomLeftRadius);
-      ringNode.border(STANDARD_FOCUS_RING_WIDTH, color, BorderStyle.Solid);
+      ringNode.border(STANDARD_FOCUS_RING_WIDTH, color);
       this.lastColor = color;
       this.lastTopLeftRadius = style.topLeftRadius;
       this.lastTopRightRadius = style.topRightRadius;

package/src/core/FocusVisibility.ts

@@ -17,6 +17,10 @@ function hasNonShiftModifier(modifiers: u32): bool {
   return (modifiers & (KeyModifier.Ctrl | KeyModifier.Alt | KeyModifier.Meta)) != 0;
 }
 
+function isCaretNavigationKey(key: string): bool {
+  return key == "ArrowLeft" || key == "ArrowRight" || key == "ArrowUp" || key == "ArrowDown" || key == "Home" || key == "End" || key == "PageUp" || key == "PageDown";
+}
+
 export function showKeyboardFocusForKeyEvent(eventType: KeyEventType, key: string, modifiers: u32 = 0): void {
   if (eventType != KeyEventType.Down || isModifierKey(key)) {
     return;
@@ -24,6 +28,9 @@ export function showKeyboardFocusForKeyEvent(eventType: KeyEventType, key: strin
   if (hasNonShiftModifier(modifiers)) {
     return;
   }
+  if (isCaretNavigationKey(key)) {
+    return;
+  }
   if (key == "Escape") {
     keyboardFocusVisible.value = false;
     return;

package/src/core/FrameScheduler.ts

@@ -2,6 +2,71 @@ import * as ui from "../bindings/ui";
 
 let needsCommit: bool = false;
 let flushScheduled: bool = false;
+let didFirstCommit: bool = false;
+const nextCommitCallbacks = new Array<() => void>();
+export type AfterCommitHandler<Owner> = (owner: Owner) => void;
+abstract class NextCommitRegistration {
+  abstract invoke(): void;
+}
+
+class NextCommitCallbackRegistration extends NextCommitRegistration {
+  constructor(private readonly callback: () => void) {
+    super();
+  }
+
+  invoke(): void {
+    this.callback();
+  }
+}
+
+class NextCommitHandlerRegistration<Owner> extends NextCommitRegistration {
+  constructor(
+    private readonly owner: Owner,
+    private readonly handler: AfterCommitHandler<Owner>,
+  ) {
+    super();
+  }
+
+  invoke(): void {
+    this.handler(this.owner);
+  }
+}
+
+export class LoadedEventArgs {
+  static readonly Empty: LoadedEventArgs = new LoadedEventArgs();
+}
+
+// WPF-style Loaded event — fires once after the tree is built and mounted.
+export type LoadedHandler<Owner> = (owner: Owner, event: LoadedEventArgs) => void;
+
+abstract class LoadedRegistration {
+  abstract invoke(): void;
+}
+
+class LoadedCallbackRegistration extends LoadedRegistration {
+  constructor(private readonly callback: (event: LoadedEventArgs) => void) {
+    super();
+  }
+
+  invoke(): void {
+    this.callback(LoadedEventArgs.Empty);
+  }
+}
+
+class LoadedHandlerRegistration<Owner> extends LoadedRegistration {
+  constructor(
+    private readonly owner: Owner,
+    private readonly handler: LoadedHandler<Owner>,
+  ) {
+    super();
+  }
+
+  invoke(): void {
+    this.handler(this.owner, LoadedEventArgs.Empty);
+  }
+}
+
+const loadedCallbacks = new Array<LoadedRegistration>();
 
 export function markNeedsCommit(): void {
   needsCommit = true;
@@ -12,6 +77,50 @@ export function markNeedsCommit(): void {
   ui.requestRender();
 }
 
+/**
+ * Register a callback that fires once after the page has been mounted and
+ * the first frame has been committed.  Safe to call during `buildPage()` —
+ * timers started here survive `cancelAllTimers()` in `Application.mount()`.
+ */
+export function onLoaded(cb: (event: LoadedEventArgs) => void): void {
+  if (didFirstCommit) {
+    cb(LoadedEventArgs.Empty);
+    return;
+  }
+  loadedCallbacks.push(new LoadedCallbackRegistration(cb));
+}
+
+export function onLoadedWith<Owner>(owner: Owner, handler: LoadedHandler<Owner>): void {
+  if (didFirstCommit) {
+    handler(owner, LoadedEventArgs.Empty);
+    return;
+  }
+  loadedCallbacks.push(new LoadedHandlerRegistration<Owner>(owner, handler));
+}
+
+export function onLoadedFor<Owner>(owner: Owner, handler: LoadedHandler<Owner>): void {
+  onLoadedWith<Owner>(owner, handler);
+}
+
+export function fireLoadedCallbacks(): void {
+  if (didFirstCommit) return;
+  didFirstCommit = true;
+  for (let i: i32 = 0; i < loadedCallbacks.length; i++) {
+    unchecked(loadedCallbacks[i]).invoke();
+  }
+  loadedCallbacks.length = 0;
+}
+
+export function afterNextCommit(callback: () => void): void {
+  nextCommitCallbacks.push(callback);
+}
+
+const nextCommitRegistrations = new Array<NextCommitRegistration>();
+
+export function afterNextCommitWith<Owner>(owner: Owner, handler: AfterCommitHandler<Owner>): void {
+  nextCommitRegistrations.push(new NextCommitHandlerRegistration<Owner>(owner, handler));
+}
+
 export function flushCommit(): bool {
   flushScheduled = false;
   if (!needsCommit) {
@@ -19,10 +128,27 @@ export function flushCommit(): bool {
   }
   needsCommit = false;
   ui.commitFrame();
+  if (nextCommitCallbacks.length > 0) {
+    const callbacks = nextCommitCallbacks.slice();
+    nextCommitCallbacks.length = 0;
+    for (let i: i32 = 0; i < callbacks.length; i++) {
+      unchecked(callbacks[i])();
+    }
+  }
+  if (nextCommitRegistrations.length > 0) {
+    const registrations = nextCommitRegistrations.slice();
+    nextCommitRegistrations.length = 0;
+    for (let i: i32 = 0; i < registrations.length; i++) {
+      unchecked(registrations[i]).invoke();
+    }
+  }
   return true;
 }
 
 export function resetCommitState(): void {
   needsCommit = false;
   flushScheduled = false;
+  didFirstCommit = false;
+  nextCommitCallbacks.length = 0;
+  nextCommitRegistrations.length = 0;
 }

package/src/core/ImageSampling.ts

@@ -0,0 +1,43 @@
+import { ImageSamplingKind } from "./ffi";
+
+export class ImageSampling {
+  private static LINEAR: ImageSampling = new ImageSampling(ImageSamplingKind.Linear, 0);
+  private static NEAREST: ImageSampling = new ImageSampling(ImageSamplingKind.Nearest, 0);
+  private static LINEAR_MIPMAP_NEAREST: ImageSampling = new ImageSampling(ImageSamplingKind.LinearMipmapNearest, 0);
+  private static LINEAR_MIPMAP_LINEAR: ImageSampling = new ImageSampling(ImageSamplingKind.LinearMipmapLinear, 0);
+  private static CUBIC_MITCHELL: ImageSampling = new ImageSampling(ImageSamplingKind.CubicMitchell, 0);
+  private static CUBIC_CATMULL_ROM: ImageSampling = new ImageSampling(ImageSamplingKind.CubicCatmullRom, 0);
+
+  static linear(): ImageSampling {
+    return ImageSampling.LINEAR;
+  }
+
+  static nearest(): ImageSampling {
+    return ImageSampling.NEAREST;
+  }
+
+  static linearMipmapNearest(): ImageSampling {
+    return ImageSampling.LINEAR_MIPMAP_NEAREST;
+  }
+
+  static linearMipmapLinear(): ImageSampling {
+    return ImageSampling.LINEAR_MIPMAP_LINEAR;
+  }
+
+  static cubicMitchell(): ImageSampling {
+    return ImageSampling.CUBIC_MITCHELL;
+  }
+
+  static cubicCatmullRom(): ImageSampling {
+    return ImageSampling.CUBIC_CATMULL_ROM;
+  }
+
+  static anisotropic(maxAniso: u32 = 8): ImageSampling {
+    return new ImageSampling(ImageSamplingKind.Anisotropic, maxAniso);
+  }
+
+  private constructor(
+    public readonly kind: ImageSamplingKind,
+    public readonly maxAniso: u32,
+  ) {}
+}

package/src/core/Logger.ts

@@ -63,6 +63,8 @@ export function describePointerEventType(eventType: PointerEventType): string {
       return "enter";
     case PointerEventType.Leave:
       return "leave";
+    case PointerEventType.Cancel:
+      return "cancel";
     default:
       return "pointer(" + (<u32>eventType).toString() + ")";
   }