@effindomv2/fui-as 0.1.0

package/src/core/PersistedState.ts

@@ -0,0 +1,102 @@
+import { Node } from "./Node";
+
+export abstract class PersistedStateAdapter {
+  readonly kind: string;
+  readonly version: u32;
+
+  constructor(kind: string, version: u32 = 1) {
+    if (kind.length == 0) {
+      throw new Error("PersistedStateAdapter requires a non-empty kind.");
+    }
+    this.kind = kind;
+    this.version = version;
+  }
+
+  abstract capture(node: Node): string | null;
+  abstract restore(node: Node, payload: string, version: u32): void;
+}
+
+export abstract class PersistedNodeState<TNode extends Node> extends PersistedStateAdapter {
+  capture(node: Node): string | null {
+    return this.captureSerialized(changetype<TNode>(node));
+  }
+
+  restore(node: Node, payload: string, version: u32): void {
+    this.restoreSerialized(changetype<TNode>(node), payload, version);
+  }
+
+  protected abstract captureSerialized(node: TNode): string | null;
+  protected abstract restoreSerialized(node: TNode, payload: string, version: u32): void;
+}
+
+export abstract class PersistedStateCodec<TValue> {
+  abstract encode(value: TValue): string;
+  abstract decode(payload: string, version: u32): TValue;
+}
+
+export abstract class PersistedValueState<TNode extends Node, TValue> extends PersistedNodeState<TNode> {
+  protected readonly codec: PersistedStateCodec<TValue>;
+
+  constructor(kind: string, codec: PersistedStateCodec<TValue>, version: u32 = 1) {
+    super(kind, version);
+    this.codec = codec;
+  }
+
+  protected shouldCaptureValue(_node: TNode): bool {
+    return true;
+  }
+
+  protected captureSerialized(node: TNode): string | null {
+    if (!this.shouldCaptureValue(node)) {
+      return null;
+    }
+    return this.codec.encode(this.captureValue(node));
+  }
+
+  protected restoreSerialized(node: TNode, payload: string, version: u32): void {
+    this.restoreValue(node, this.codec.decode(payload, version));
+  }
+
+  protected abstract captureValue(node: TNode): TValue;
+  protected abstract restoreValue(node: TNode, value: TValue): void;
+}
+
+export class PersistedStringCodec extends PersistedStateCodec<string> {
+  encode(value: string): string {
+    return value;
+  }
+
+  decode(payload: string, _version: u32): string {
+    return payload;
+  }
+}
+
+export class PersistedBoolCodec extends PersistedStateCodec<bool> {
+  encode(value: bool): string {
+    return value.toString();
+  }
+
+  decode(payload: string, _version: u32): bool {
+    return bool.parse(payload);
+  }
+}
+
+export class PersistedInt32Codec extends PersistedStateCodec<i32> {
+  encode(value: i32): string {
+    return value.toString();
+  }
+
+  decode(payload: string, _version: u32): i32 {
+    return i32.parse(payload);
+  }
+}
+
+export class PersistedFloat32Codec extends PersistedStateCodec<f32> {
+  encode(value: f32): string {
+    return value.toString();
+  }
+
+  decode(payload: string, _version: u32): f32 {
+    return f32.parse(payload);
+  }
+}

package/src/core/PersistedUiState.ts

@@ -0,0 +1,142 @@
+import {
+  fui_copy_persisted_state,
+  fui_set_persisted_scroll_offset,
+  fui_set_persisted_state,
+  fui_try_get_persisted_scroll_offset,
+} from "./ffi";
+import { __fui_text_buffer, __fui_text_buffer_size } from "./event_exports";
+import { ScrollState } from "../nodes/ScrollState";
+
+export class PersistedScrollOffset {
+  constructor(
+    readonly x: f32,
+    readonly y: f32,
+  ) {}
+}
+
+export class PersistedTextState {
+  constructor(
+    readonly version: u32,
+    readonly payload: string,
+  ) {}
+}
+
+const persistedScrollRestoreBuffer = new Float32Array(2);
+const persistedTextStateVersionBuffer = new Uint32Array(1);
+
+function encodeUtf8(text: string): Uint8Array {
+  return Uint8Array.wrap(String.UTF8.encode(text, false));
+}
+
+function axisRestoreReady(desiredOffset: f32, contentSize: f32, viewportSize: f32, enabled: bool): bool {
+  if (!enabled || desiredOffset == 0.0) {
+    return true;
+  }
+  return viewportSize > 0.0 && contentSize > viewportSize;
+}
+
+function clampAxisOffset(offset: f32, contentSize: f32, viewportSize: f32, enabled: bool): f32 {
+  if (!enabled) {
+    return 0.0;
+  }
+  const maxOffset = contentSize > viewportSize ? contentSize - viewportSize : 0.0;
+  if (offset < 0.0) {
+    return 0.0;
+  }
+  if (offset > maxOffset) {
+    return maxOffset;
+  }
+  return offset;
+}
+
+export function storePersistedScrollOffset(nodeId: string, x: f32, y: f32): void {
+  const bytes = encodeUtf8(nodeId);
+  fui_set_persisted_scroll_offset(bytes.length > 0 ? bytes.dataStart : 0, <u32>bytes.length, x, y);
+}
+
+export function storePersistedTextState(nodeId: string, kind: string, version: u32, payload: string): void {
+  const nodeIdBytes = encodeUtf8(nodeId);
+  const kindBytes = encodeUtf8(kind);
+  const payloadBytes = encodeUtf8(payload);
+  fui_set_persisted_state(
+    nodeIdBytes.length > 0 ? nodeIdBytes.dataStart : 0,
+    <u32>nodeIdBytes.length,
+    kindBytes.length > 0 ? kindBytes.dataStart : 0,
+    <u32>kindBytes.length,
+    version,
+    payloadBytes.length > 0 ? payloadBytes.dataStart : 0,
+    <u32>payloadBytes.length,
+  );
+}
+
+export function tryLoadPersistedScrollOffset(nodeId: string): PersistedScrollOffset | null {
+  const bytes = encodeUtf8(nodeId);
+  const basePtr = persistedScrollRestoreBuffer.dataStart;
+  if (!fui_try_get_persisted_scroll_offset(
+    bytes.length > 0 ? bytes.dataStart : 0,
+    <u32>bytes.length,
+    basePtr,
+    basePtr + sizeof<f32>(),
+  )) {
+    return null;
+  }
+  return new PersistedScrollOffset(
+    persistedScrollRestoreBuffer[0],
+    persistedScrollRestoreBuffer[1],
+  );
+}
+
+export function tryLoadPersistedTextState(nodeId: string, kind: string): PersistedTextState | null {
+  const nodeIdBytes = encodeUtf8(nodeId);
+  const kindBytes = encodeUtf8(kind);
+  const versionPtr = persistedTextStateVersionBuffer.dataStart;
+  const payloadPtr = __fui_text_buffer();
+  const payloadCapacity = __fui_text_buffer_size();
+  const copied = fui_copy_persisted_state(
+    nodeIdBytes.length > 0 ? nodeIdBytes.dataStart : 0,
+    <u32>nodeIdBytes.length,
+    kindBytes.length > 0 ? kindBytes.dataStart : 0,
+    <u32>kindBytes.length,
+    versionPtr,
+    payloadPtr,
+    payloadCapacity,
+  );
+  if (copied < 0) {
+    return null;
+  }
+  if (<u32>copied > payloadCapacity) {
+    throw new Error(
+      "Persisted state payload for " +
+      kind +
+      " on " +
+      nodeId +
+      " exceeded the shared text buffer capacity.",
+    );
+  }
+  return new PersistedTextState(
+    persistedTextStateVersionBuffer[0],
+    copied == 0 ? "" : String.UTF8.decodeUnsafe(payloadPtr, <usize>copied, false),
+  );
+}
+
+export function canRestorePersistedScrollOffset(
+  state: ScrollState,
+  offset: PersistedScrollOffset,
+  enableX: bool,
+  enableY: bool,
+): bool {
+  return axisRestoreReady(offset.x, state.contentWidth.value, state.viewportWidth.value, enableX) &&
+    axisRestoreReady(offset.y, state.contentHeight.value, state.viewportHeight.value, enableY);
+}
+
+export function clampPersistedScrollOffset(
+  state: ScrollState,
+  offset: PersistedScrollOffset,
+  enableX: bool,
+  enableY: bool,
+): PersistedScrollOffset {
+  return new PersistedScrollOffset(
+    clampAxisOffset(offset.x, state.contentWidth.value, state.viewportWidth.value, enableX),
+    clampAxisOffset(offset.y, state.contentHeight.value, state.viewportHeight.value, enableY),
+  );
+}

package/src/core/Platform.ts

@@ -0,0 +1,219 @@
+import { fui_get_platform_family, fui_is_coarse_pointer, KeyModifier } from "./ffi";
+
+export enum PlatformFamily {
+  Unknown = 0,
+  Apple = 1,
+  Windows = 2,
+  Linux = 3,
+}
+
+const detectedPlatformFamily = <PlatformFamily>fui_get_platform_family();
+
+class KeyboardPolicy {
+  constructor(
+    readonly primaryShortcutModifier: u32,
+    readonly wordNavigationModifier: u32,
+    readonly lineBoundaryModifier: u32,
+    readonly documentBoundaryModifier: u32,
+    readonly redoUsesPrimaryY: bool,
+    readonly redoUsesShiftedPrimaryZ: bool,
+  ) {}
+}
+
+const APPLE_KEYBOARD_POLICY = new KeyboardPolicy(
+  KeyModifier.Meta,
+  KeyModifier.Alt,
+  KeyModifier.Meta,
+  KeyModifier.Meta,
+  false,
+  true,
+);
+const DEFAULT_KEYBOARD_POLICY = new KeyboardPolicy(
+  KeyModifier.Ctrl,
+  KeyModifier.Ctrl,
+  0,
+  KeyModifier.Ctrl,
+  true,
+  true,
+);
+
+function resolveKeyboardPolicy(platformFamily: PlatformFamily = detectedPlatformFamily): KeyboardPolicy {
+  if (platformFamily == PlatformFamily.Apple) {
+    return APPLE_KEYBOARD_POLICY;
+  }
+  return DEFAULT_KEYBOARD_POLICY;
+}
+
+function matchesShortcutKey(key: string, expected: string): bool {
+  return key.length == expected.length && key.toLowerCase() == expected;
+}
+
+function formatShortcutKeyToken(key: string, platformFamily: PlatformFamily): string {
+  if (key == "ArrowLeft") {
+    return platformFamily == PlatformFamily.Apple ? "←" : "Left";
+  }
+  if (key == "ArrowRight") {
+    return platformFamily == PlatformFamily.Apple ? "→" : "Right";
+  }
+  if (key == "ArrowUp") {
+    return platformFamily == PlatformFamily.Apple ? "↑" : "Up";
+  }
+  if (key == "ArrowDown") {
+    return platformFamily == PlatformFamily.Apple ? "↓" : "Down";
+  }
+  if (key == "PageUp") {
+    return "PgUp";
+  }
+  if (key == "PageDown") {
+    return "PgDn";
+  }
+  if (key.length == 1) {
+    return key.toUpperCase();
+  }
+  return key;
+}
+
+function appendShortcutModifierTokens(tokens: Array<string>, modifiers: u32, platformFamily: PlatformFamily): void {
+  if (platformFamily == PlatformFamily.Apple) {
+    if ((modifiers & KeyModifier.Ctrl) != 0) {
+      tokens.push("⌃");
+    }
+    if ((modifiers & KeyModifier.Alt) != 0) {
+      tokens.push("⌥");
+    }
+    if ((modifiers & KeyModifier.Shift) != 0) {
+      tokens.push("⇧");
+    }
+    if ((modifiers & KeyModifier.Meta) != 0) {
+      tokens.push("⌘");
+    }
+    return;
+  }
+
+  if ((modifiers & KeyModifier.Ctrl) != 0) {
+    tokens.push("Ctrl");
+  }
+  if ((modifiers & KeyModifier.Alt) != 0) {
+    tokens.push("Alt");
+  }
+  if ((modifiers & KeyModifier.Shift) != 0) {
+    tokens.push("Shift");
+  }
+  if ((modifiers & KeyModifier.Meta) != 0) {
+    tokens.push("Meta");
+  }
+}
+
+export function getPlatformFamily(): PlatformFamily {
+  return detectedPlatformFamily;
+}
+
+export function isCoarsePointer(): bool {
+  return fui_is_coarse_pointer();
+}
+
+export function resolvePrimaryShortcutModifier(platformFamily: PlatformFamily): u32 {
+  return resolveKeyboardPolicy(platformFamily).primaryShortcutModifier;
+}
+
+export function hasPrimaryShortcutModifier(
+  modifiers: u32,
+  platformFamily: PlatformFamily = detectedPlatformFamily,
+): bool {
+  return (modifiers & resolvePrimaryShortcutModifier(platformFamily)) != 0;
+}
+
+export function resolveWordNavigationModifier(platformFamily: PlatformFamily = detectedPlatformFamily): u32 {
+  return resolveKeyboardPolicy(platformFamily).wordNavigationModifier;
+}
+
+export function hasWordNavigationModifier(
+  modifiers: u32,
+  platformFamily: PlatformFamily = detectedPlatformFamily,
+): bool {
+  return (modifiers & resolveWordNavigationModifier(platformFamily)) != 0;
+}
+
+export function resolveLineBoundaryModifier(platformFamily: PlatformFamily = detectedPlatformFamily): u32 {
+  return resolveKeyboardPolicy(platformFamily).lineBoundaryModifier;
+}
+
+export function hasLineBoundaryModifier(
+  modifiers: u32,
+  platformFamily: PlatformFamily = detectedPlatformFamily,
+): bool {
+  const modifier = resolveLineBoundaryModifier(platformFamily);
+  return modifier != 0 && (modifiers & modifier) != 0;
+}
+
+export function resolveDocumentBoundaryModifier(platformFamily: PlatformFamily = detectedPlatformFamily): u32 {
+  return resolveKeyboardPolicy(platformFamily).documentBoundaryModifier;
+}
+
+export function hasDocumentBoundaryModifier(
+  modifiers: u32,
+  platformFamily: PlatformFamily = detectedPlatformFamily,
+): bool {
+  return (modifiers & resolveDocumentBoundaryModifier(platformFamily)) != 0;
+}
+
+export function isUndoShortcut(
+  key: string,
+  modifiers: u32,
+  platformFamily: PlatformFamily = detectedPlatformFamily,
+): bool {
+  return (modifiers & KeyModifier.Shift) == 0 &&
+    hasPrimaryShortcutModifier(modifiers, platformFamily) &&
+    matchesShortcutKey(key, "z");
+}
+
+export function isRedoShortcut(
+  key: string,
+  modifiers: u32,
+  platformFamily: PlatformFamily = detectedPlatformFamily,
+): bool {
+  const policy = resolveKeyboardPolicy(platformFamily);
+  const hasPrimaryModifier = hasPrimaryShortcutModifier(modifiers, platformFamily);
+  if (!hasPrimaryModifier) {
+    return false;
+  }
+  if (policy.redoUsesPrimaryY && matchesShortcutKey(key, "y")) {
+    return true;
+  }
+  return policy.redoUsesShiftedPrimaryZ &&
+    (modifiers & KeyModifier.Shift) != 0 &&
+    matchesShortcutKey(key, "z");
+}
+
+export function formatShortcutLabel(
+  key: string,
+  modifiers: u32,
+  platformFamily: PlatformFamily = detectedPlatformFamily,
+): string {
+  const tokens = new Array<string>();
+  appendShortcutModifierTokens(tokens, modifiers, platformFamily);
+  tokens.push(formatShortcutKeyToken(key, platformFamily));
+  if (platformFamily == PlatformFamily.Apple) {
+    return tokens.join("");
+  }
+  return tokens.join("+");
+}
+
+export function formatPrimaryShortcutLabel(
+  key: string,
+  platformFamily: PlatformFamily = detectedPlatformFamily,
+): string {
+  return formatShortcutLabel(key, resolvePrimaryShortcutModifier(platformFamily), platformFamily);
+}
+
+export function formatUndoShortcutLabel(platformFamily: PlatformFamily = detectedPlatformFamily): string {
+  return formatPrimaryShortcutLabel("z", platformFamily);
+}
+
+export function formatRedoShortcutLabel(platformFamily: PlatformFamily = detectedPlatformFamily): string {
+  const policy = resolveKeyboardPolicy(platformFamily);
+  if (policy.redoUsesPrimaryY) {
+    return formatPrimaryShortcutLabel("y", platformFamily);
+  }
+  return formatShortcutLabel("z", policy.primaryShortcutModifier | KeyModifier.Shift, platformFamily);
+}

package/src/core/Signal.ts

@@ -0,0 +1,89 @@
+import { Action, CallbackAction, HandlerAction, SignalHandler } from "./Action";
+import { markNeedsCommit } from "./FrameScheduler";
+import { describeValue, log } from "./Logger";
+
+export class Signal<T> {
+  private currentValue: T;
+  private head: Action<T> | null = null;
+
+  constructor(initial: T) {
+    this.currentValue = initial;
+  }
+
+  get value(): T {
+    return this.currentValue;
+  }
+
+  set value(next: T) {
+    this.set(next);
+  }
+
+  set(next: T): bool {
+    if (this.currentValue === next) {
+      return false;
+    }
+    this.currentValue = next;
+    log("Signal", "value changed to " + describeValue<T>(next));
+    const notified = this.head !== null;
+    let current = this.head;
+    while (current !== null) {
+      const nextAction = current.next;
+      log("Action", current.debugName() + " invoked with " + describeValue<T>(next));
+      changetype<Action<T>>(current).invoke(next);
+      current = nextAction;
+    }
+    if (notified) {
+      markNeedsCommit();
+    }
+    return true;
+  }
+
+  hasListeners(): bool {
+    return this.head !== null;
+  }
+
+  addAction(action: Action<T>): Action<T> {
+    if (action._isAttachedTo(this)) {
+      return action;
+    }
+    action.dispose();
+    action.next = null;
+    if (this.head === null) {
+      this.head = action;
+    } else {
+      let current = changetype<Action<T>>(this.head);
+      while (current.next !== null) {
+        current = changetype<Action<T>>(current.next);
+      }
+      current.next = action;
+    }
+    action._attach(this);
+    return action;
+  }
+
+  bind<Owner>(owner: Owner, handler: SignalHandler<Owner, T>): Action<T> {
+    return this.addAction(new HandlerAction<Owner, T>(owner, handler));
+  }
+
+  subscribe(callback: () => void): Action<T> {
+    return this.addAction(new CallbackAction<T>(callback));
+  }
+
+  removeAction(target: Action<T>): void {
+    let previous: Action<T> | null = null;
+    let current = this.head;
+    while (current !== null) {
+      if (current === target) {
+        if (previous === null) {
+          this.head = current.next;
+        } else {
+          previous.next = current.next;
+        }
+        target._detach();
+        return;
+      }
+      previous = current;
+      current = current.next;
+    }
+  }
+}