@swf2es/player 0.0.0-stage → 0.1.1

package/src/playerglobal/flash/events/Event.ts

@@ -0,0 +1,85 @@
+// flash.events.Event's natives, which Flash Player's playerglobal has:
+// its constructor's private native ctor keeps the type and flags, and
+// dispatch sets the target, current target and phase in the fields they
+// read (scripting/events.ts's eventFields). Ours keeps them all in AS3.
+import { avm2 } from "@swf2es/runtime";
+import { AT_TARGET } from "../../../scripting/events.js";
+import type { Scripting } from "../../../scripting.js";
+
+type Value = avm2.Value;
+
+export function eventNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+
+  class EventNatives {
+    declare $type: string;
+    declare $bubbles: boolean;
+    declare $cancelable: boolean;
+    declare $target: Value;
+    declare $currentTarget: Value;
+    declare $phase: number;
+    /** 0 running, 1 propagation stopped, 2 stopped at once. */
+    declare $stopped: number;
+    declare $prevented: boolean;
+
+    "flash.events:Event::ctor"(type: Value, bubbles: Value, cancelable: Value): void {
+      if (type == null) {
+        throw s.rt.error("TypeError", 2007, "type");
+      }
+
+      this.$type = String(type);
+      this.$bubbles = !!bubbles;
+      this.$cancelable = !!cancelable;
+      this.$target = null;
+      this.$currentTarget = null;
+      this.$phase = AT_TARGET;
+      this.$stopped = 0;
+      this.$prevented = false;
+    }
+
+    get type(): string {
+      return this.$type;
+    }
+
+    get bubbles(): boolean {
+      return this.$bubbles;
+    }
+
+    get cancelable(): boolean {
+      return this.$cancelable;
+    }
+
+    get target(): Value {
+      return this.$target;
+    }
+
+    get currentTarget(): Value {
+      return this.$currentTarget;
+    }
+
+    get eventPhase(): number {
+      return this.$phase;
+    }
+
+    stopPropagation(): void {
+      this.$stopped = Math.max(this.$stopped, 1);
+    }
+
+    stopImmediatePropagation(): void {
+      this.$stopped = 2;
+    }
+
+    preventDefault(): void {
+      if (this.$cancelable) {
+        this.$prevented = true;
+      }
+    }
+
+    isDefaultPrevented(): boolean {
+      return this.$prevented;
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.events::Event", EventNatives);
+  return natives;
+}

package/src/playerglobal/flash/events/EventDispatcher.ts

@@ -0,0 +1,143 @@
+// flash.events.EventDispatcher: listeners by type on the object itself,
+// which the player's dispatch (scripting/events.ts) calls along a display
+// object's parent chain. The player broadcasts its frame and activation
+// events through it.
+import { avm2 } from "@swf2es/runtime";
+import { dispatchEvent, displayOf, type Listener } from "../../../scripting/events.js";
+import type { Scripting } from "../../../scripting.js";
+
+type AsObject = avm2.AsObject;
+type Value = avm2.Value;
+
+/** The events Flash broadcasts to every display object that listens, on the display list or not, target only. */
+const BROADCAST = new Set(["enterFrame", "frameConstructed", "exitFrame", "render"]);
+/**
+ * The events Flash broadcasts to every EventDispatcher that listens, display
+ * object or not, target only: the player's activation, which, unlike a
+ * frame's events, holds no listener alive (Scripting.activationTargets).
+ */
+const ACTIVATION = new Set(["activate", "deactivate"]);
+
+function listeners(o: AsObject): Map<string, Listener[]> {
+  if (!o.$listeners) {
+    o.$listeners = new Map<string, Listener[]>();
+  }
+
+  return o.$listeners;
+}
+
+/** An event type, declared String: refused as null, as Flash refuses it. */
+function eventType(s: Scripting, type: Value): string {
+  if (type === null || type === undefined) {
+    throw s.rt.error("TypeError", 2007, "type");
+  }
+
+  return type as string;
+}
+
+/** `fn` added to `o`'s listeners for `type`, as EventDispatcher.addEventListener adds it; whether it was new. */
+export function addListener(
+  s: Scripting,
+  o: AsObject,
+  type: Value,
+  fn: Value,
+  useCapture: Value,
+  priority: Value,
+): boolean {
+  const key = eventType(s, type);
+  if (typeof fn !== "object" && typeof fn !== "function") {
+    return false;
+  }
+
+  const list = listeners(o).get(key) ?? [];
+  const capture = !!useCapture;
+  if (list.some((l) => l.fn === fn && l.capture === capture)) {
+    return false;
+  }
+
+  const listener = { fn, capture, priority: Number(priority) | 0 };
+  // Higher priority first; the same priority in the order added.
+  let at = list.length;
+  while (at > 0 && list[at - 1].priority < listener.priority) {
+    at--;
+  }
+
+  list.splice(at, 0, listener);
+  listeners(o).set(key, list);
+  // A display object listening for a frame event is broadcast to, wherever it is; any
+  // dispatcher listening for activation is, held weakly.
+  if (BROADCAST.has(key) && o.$display) {
+    s.broadcastTargets(key).add(o);
+  } else if (ACTIVATION.has(key)) {
+    s.activationTargets(key).add(o);
+  }
+
+  return true;
+}
+
+/** `fn` taken from `o`'s listeners for `type`, as EventDispatcher.removeEventListener takes it. */
+export function removeListener(
+  s: Scripting,
+  o: AsObject,
+  type: Value,
+  fn: Value,
+  useCapture: Value,
+): void {
+  const key = eventType(s, type);
+  const list = o.$listeners?.get(key);
+  const at = list?.findIndex((l: Listener) => l.fn === fn && l.capture === !!useCapture) ?? -1;
+  if (list && at >= 0) {
+    list.splice(at, 1);
+    if (list.length === 0 && BROADCAST.has(key)) {
+      s.broadcastTargets(key).delete(o);
+    } else if (list.length === 0 && ACTIVATION.has(key)) {
+      s.activationTargets(key).delete(o);
+    }
+  }
+}
+
+export function eventDispatcherNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+  const typeOf = (type: Value) => eventType(s, type);
+
+  class EventDispatcherNatives {
+    /** The IEventDispatcher a composed dispatcher stands in for, as events' target. */
+    declare $target: Value;
+    declare $listeners: Map<string, Listener[]> | undefined;
+    declare $display: AsObject | undefined;
+
+    "flash.events:EventDispatcher::ctor"(target: Value): void {
+      this.$target = target ?? null;
+    }
+
+    addEventListener(type: Value, fn: Value, useCapture: Value, priority: Value): void {
+      addListener(s, this, type, fn, useCapture, priority);
+    }
+
+    removeEventListener(type: Value, fn: Value, useCapture: Value): void {
+      removeListener(s, this, type, fn, useCapture);
+    }
+
+    hasEventListener(type: Value): boolean {
+      return (this.$listeners?.get(typeOf(type))?.length ?? 0) > 0;
+    }
+
+    willTrigger(type: Value): boolean {
+      const key = typeOf(type);
+      for (let o: AsObject | null = this; o; o = displayOf(o)?.parent?.object ?? null) {
+        if ((o.$listeners?.get(key)?.length ?? 0) > 0) {
+          return true;
+        }
+      }
+
+      return false;
+    }
+
+    "flash.events:EventDispatcher::dispatchEventFunction"(event: Value): boolean {
+      return dispatchEvent(s, this, event);
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.events::EventDispatcher", EventDispatcherNatives);
+  return natives;
+}

package/src/playerglobal/flash/events/GestureEvent.ts

@@ -0,0 +1,49 @@
+// flash.events.GestureEvent's natives, its subclasses' included: the
+// stage point, and the local point Flash Player's playerglobal keeps in
+// natives, which ours keeps in AS3 with the rest. Scripts make and dispatch gesture
+// events of their own: the player recognizes no gestures yet.
+import { avm2 } from "@swf2es/runtime";
+import type { Scripting } from "../../../scripting.js";
+import { stagePoint } from "./MouseEvent.js";
+
+type Value = avm2.Value;
+
+export function gestureEventNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+
+  class GestureEventNatives {
+    declare $gestureX: number | undefined;
+    declare $gestureY: number | undefined;
+
+    updateAfterEvent(): void {
+      s.updates++;
+    }
+
+    get localX(): number {
+      return this.$gestureX ?? Number.NaN;
+    }
+
+    set localX(value: Value) {
+      this.$gestureX = s.rt.toNumber(value);
+    }
+
+    get localY(): number {
+      return this.$gestureY ?? Number.NaN;
+    }
+
+    set localY(value: Value) {
+      this.$gestureY = s.rt.toNumber(value);
+    }
+
+    "flash.events:GestureEvent::getStageX"(x?: number, y?: number): number {
+      return stagePoint(s, this, x ?? this.$gestureX, y ?? this.$gestureY)[0];
+    }
+
+    "flash.events:GestureEvent::getStageY"(x?: number, y?: number): number {
+      return stagePoint(s, this, x ?? this.$gestureX, y ?? this.$gestureY)[1];
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.events::GestureEvent", GestureEventNatives);
+  return natives;
+}

package/src/playerglobal/flash/events/HTTPStatusEvent.ts

@@ -0,0 +1,12 @@
+// AIR's playerglobal ABC keeps the response fields in slots, but asks the VM
+// for their bodyless accessors. URLLoader reads them while forwarding status.
+import type { avm2 } from "@swf2es/runtime";
+
+export const httpStatusHooks: Record<string, avm2.ClassHook> = {
+  "flash.events::HTTPStatusEvent": {
+    setOnlySlots: {
+      responseURL: "$2",
+      responseHeaders: "$1",
+    },
+  },
+};

package/src/playerglobal/flash/events/KeyboardEvent.ts

@@ -0,0 +1,75 @@
+// flash.events.KeyboardEvent's natives: a redraw, and the character and
+// modifier keys Flash Player's playerglobal keeps in natives, which ours
+// keeps in AS3; and TextEvent's one native, which a clone copies IME data
+// through.
+import { avm2 } from "@swf2es/runtime";
+import type { Scripting } from "../../../scripting.js";
+
+type Value = avm2.Value;
+
+export function keyboardEventNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+
+  class KeyboardEventNatives {
+    declare $charCode: number | undefined;
+    declare $ctrlKey: boolean | undefined;
+    declare $altKey: boolean | undefined;
+    declare $shiftKey: boolean | undefined;
+    declare $commandKey: boolean | undefined;
+
+    get charCode(): number {
+      return this.$charCode ?? 0;
+    }
+
+    set charCode(value: Value) {
+      this.$charCode = s.rt.toUint(value);
+    }
+
+    get ctrlKey(): boolean {
+      return this.$ctrlKey ?? false;
+    }
+
+    set ctrlKey(value: Value) {
+      this.$ctrlKey = !!value;
+    }
+
+    get altKey(): boolean {
+      return this.$altKey ?? false;
+    }
+
+    set altKey(value: Value) {
+      this.$altKey = !!value;
+    }
+
+    get shiftKey(): boolean {
+      return this.$shiftKey ?? false;
+    }
+
+    set shiftKey(value: Value) {
+      this.$shiftKey = !!value;
+    }
+
+    get commandKey(): boolean {
+      return this.$commandKey ?? false;
+    }
+
+    set commandKey(value: Value) {
+      this.$commandKey = !!value;
+    }
+
+    updateAfterEvent(): void {
+      s.updates++;
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.events::KeyboardEvent", KeyboardEventNatives);
+
+  class TextEventNatives {
+    "flash.events:TextEvent::copyNativeData"(_from: Value): void {
+      // A text input's IME data, which the player has none of.
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.events::TextEvent", TextEventNatives);
+  return natives;
+}

package/src/playerglobal/flash/events/MouseEvent.ts

@@ -0,0 +1,88 @@
+// flash.events.MouseEvent's natives. Playerglobal keeps its fields in AS3;
+// its stage point follows its target. The local point's accessors are
+// Flash Player's playerglobal's natives, kept for it.
+import { avm2 } from "@swf2es/runtime";
+import { toStage } from "../../../display/bounds.js";
+import { apply } from "../../../display/geometry.js";
+import { eventFields } from "../../../scripting/events.js";
+import type { Scripting } from "../../../scripting.js";
+
+type AsObject = avm2.AsObject;
+type Value = avm2.Value;
+
+/**
+ * The stage point of an event's local point, (x, y) on its target where
+ * that is on the display list; TouchEvent and GestureEvent read theirs so.
+ */
+export function stagePoint(
+  s: Scripting,
+  event: AsObject,
+  x = Number.NaN,
+  y = Number.NaN,
+): [number, number] {
+  const target = (event[eventFields(s).target] as AsObject | null)?.$display;
+  if (target) {
+    return apply(toStage(target, s.stage), x, y);
+  }
+
+  return [Number.isNaN(x) ? Number.NaN : 0, Number.isNaN(y) ? Number.NaN : 0];
+}
+
+export function mouseEventNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+
+  class MouseEventNatives {
+    declare $mouseX: number | undefined;
+    declare $mouseY: number | undefined;
+    declare $movementX: number | undefined;
+    declare $movementY: number | undefined;
+
+    updateAfterEvent(): void {
+      s.updates++;
+    }
+
+    get localX(): number {
+      return this.$mouseX ?? Number.NaN;
+    }
+
+    set localX(value: Value) {
+      this.$mouseX = s.rt.toNumber(value);
+    }
+
+    get localY(): number {
+      return this.$mouseY ?? Number.NaN;
+    }
+
+    set localY(value: Value) {
+      this.$mouseY = s.rt.toNumber(value);
+    }
+
+    // Ours passes its local point; Flash Player's keeps it in the natives above.
+    "flash.events:MouseEvent::getStageX"(x?: number, y?: number): number {
+      return stagePoint(s, this, x ?? this.$mouseX, y ?? this.$mouseY)[0];
+    }
+
+    "flash.events:MouseEvent::getStageY"(x?: number, y?: number): number {
+      return stagePoint(s, this, x ?? this.$mouseX, y ?? this.$mouseY)[1];
+    }
+
+    get movementX(): number {
+      return this.$movementX ?? 0;
+    }
+
+    set movementX(value: Value) {
+      this.$movementX = s.rt.toNumber(value);
+    }
+
+    get movementY(): number {
+      return this.$movementY ?? 0;
+    }
+
+    set movementY(value: Value) {
+      this.$movementY = s.rt.toNumber(value);
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.events::MouseEvent", MouseEventNatives);
+  return natives;
+}

package/src/playerglobal/flash/events/PressAndTapGestureEvent.ts

@@ -0,0 +1,48 @@
+// flash.events.PressAndTapGestureEvent's natives: the tap's stage point,
+// on the target as GestureEvent's own point is, and its local point, which
+// Flash Player's playerglobal keeps in natives and ours in AS3.
+import { avm2 } from "@swf2es/runtime";
+import type { Scripting } from "../../../scripting.js";
+import { stagePoint } from "./MouseEvent.js";
+
+type Value = avm2.Value;
+
+export function pressAndTapGestureEventNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+
+  class PressAndTapGestureEventNatives {
+    declare $tapX: number | undefined;
+    declare $tapY: number | undefined;
+
+    get tapLocalX(): number {
+      return this.$tapX ?? Number.NaN;
+    }
+
+    set tapLocalX(value: Value) {
+      this.$tapX = s.rt.toNumber(value);
+    }
+
+    get tapLocalY(): number {
+      return this.$tapY ?? Number.NaN;
+    }
+
+    set tapLocalY(value: Value) {
+      this.$tapY = s.rt.toNumber(value);
+    }
+
+    "flash.events:PressAndTapGestureEvent::getTapStageX"(x?: number, y?: number): number {
+      return stagePoint(s, this, x ?? this.$tapX, y ?? this.$tapY)[0];
+    }
+
+    "flash.events:PressAndTapGestureEvent::getTapStageY"(x?: number, y?: number): number {
+      return stagePoint(s, this, x ?? this.$tapX, y ?? this.$tapY)[1];
+    }
+  }
+
+  avm2.registerNativeClass(
+    natives,
+    "flash.events::PressAndTapGestureEvent",
+    PressAndTapGestureEventNatives,
+  );
+  return natives;
+}

package/src/playerglobal/flash/events/TimerEvent.ts

@@ -0,0 +1,20 @@
+// flash.events.TimerEvent's one native: updateAfterEvent, which asks for a
+// redraw, as MouseEvent's and KeyboardEvent's do. A timer that fires
+// between frames has the stage render after its listeners, RENDER and all,
+// as Flash does; in a frame, the frame's own drawing answers it.
+import { avm2 } from "@swf2es/runtime";
+import type { Scripting } from "../../../scripting.js";
+
+export function timerEventNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+
+  class TimerEventNatives {
+    updateAfterEvent(): void {
+      s.updates++;
+      s.timers.renderAsked = true;
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.events::TimerEvent", TimerEventNatives);
+  return natives;
+}

package/src/playerglobal/flash/events/TouchEvent.ts

@@ -0,0 +1,64 @@
+// flash.events.TouchEvent's natives: the stage point, which follows the
+// target as MouseEvent's does, and the local point Flash Player's
+// playerglobal keeps in natives, which ours keeps in AS3 with the rest.
+// No device the player knows records a stylus's samples, so there are none
+// to get, and no tool button is down.
+import { avm2 } from "@swf2es/runtime";
+import type { Scripting } from "../../../scripting.js";
+import { stagePoint } from "./MouseEvent.js";
+
+type Value = avm2.Value;
+
+export function touchEventNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+
+  class TouchEventNatives {
+    declare $touchX: number | undefined;
+    declare $touchY: number | undefined;
+
+    updateAfterEvent(): void {
+      s.updates++;
+    }
+
+    get localX(): number {
+      return this.$touchX ?? Number.NaN;
+    }
+
+    set localX(value: Value) {
+      this.$touchX = s.rt.toNumber(value);
+    }
+
+    get localY(): number {
+      return this.$touchY ?? Number.NaN;
+    }
+
+    set localY(value: Value) {
+      this.$touchY = s.rt.toNumber(value);
+    }
+
+    "flash.events:TouchEvent::getStageX"(x?: number, y?: number): number {
+      return stagePoint(s, this, x ?? this.$touchX, y ?? this.$touchY)[0];
+    }
+
+    "flash.events:TouchEvent::getStageY"(x?: number, y?: number): number {
+      return stagePoint(s, this, x ?? this.$touchX, y ?? this.$touchY)[1];
+    }
+
+    isToolButtonDown(): boolean {
+      return false;
+    }
+
+    getSamples(): number {
+      return 0;
+    }
+
+    "flash.events:TouchEvent::privateGetSamples"(): number {
+      return 0;
+    }
+
+    "flash.events:TouchEvent::setSamples"(): void {}
+  }
+
+  avm2.registerNativeClass(natives, "flash.events::TouchEvent", TouchEventNatives);
+  return natives;
+}

package/src/playerglobal/flash/external/ExternalInterface.ts

@@ -0,0 +1,104 @@
+// playerglobal's private ExternalInterface natives use the optional host
+// given to Scripting. Without one, available is false and calls throw #2067.
+import { avm2 } from "@swf2es/runtime";
+import type { Scripting } from "../../../scripting.js";
+
+type Value = avm2.Value;
+
+export function externalInterfaceNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+  // The host, if it lets the calling SWF use it; if the caller cannot be
+  // told, only if it lets every SWF ever loaded (Code.securityUrls). Called
+  // straight from the natives: 2 counts this and the native as the player's.
+  const bridge = () => {
+    const host = s.externalInterface;
+    const allows = host?.allows;
+    return host && (!allows || s.code.securityUrls(2).every((url) => allows.call(host, url)))
+      ? host
+      : null;
+  };
+
+  class ExternalInterfaceNatives {
+    static get available(): boolean {
+      return bridge() !== null;
+    }
+
+    static get objectID(): Value {
+      return bridge()?.objectID ?? null;
+    }
+
+    static "flash.external:ExternalInterface::_initJS"(): void {
+      // The host supplies the bridge; playerglobal's JavaScript shim needs no installation.
+    }
+
+    static "flash.external:ExternalInterface::_getPropNames"(object: Value): Value {
+      const names: Value[] = [];
+      let index = s.rt.hasNext(object, 0);
+      while (index !== 0) {
+        names.push(s.rt.nextName(object, index));
+        index = s.rt.hasNext(object, index);
+      }
+
+      return s.rt.array(names);
+    }
+
+    static get "flash.external:ExternalInterface::activeX"(): boolean {
+      return false;
+    }
+
+    static "flash.external:ExternalInterface::_addCallback"(
+      name: Value,
+      closure: Value,
+      remove: Value,
+    ): void {
+      const host = bridge();
+      if (!host) {
+        throw s.rt.error("Error", 2067);
+      }
+
+      host.addCallback(
+        s.rt.toString(name),
+        remove || closure === null || closure === undefined
+          ? null
+          : (request, args) => {
+              s.hostCalls++;
+              return s.rt.callValue(
+                closure,
+                null,
+                [request, args === null ? null : s.rt.array(args)],
+                null,
+              );
+            },
+      );
+    }
+
+    static "flash.external:ExternalInterface::_evalJS"(source: Value): Value {
+      const host = bridge();
+      if (!host) {
+        throw s.rt.error("Error", 2067);
+      }
+
+      return host.evalJS?.(s.rt.toString(source)) ?? null;
+    }
+
+    static "flash.external:ExternalInterface::_callOut"(request: Value): Value {
+      const host = bridge();
+      if (!host) {
+        throw s.rt.error("Error", 2067);
+      }
+
+      return host.callOut(s.rt.toString(request));
+    }
+
+    static "flash.external:ExternalInterface::_quotedStringFromString"(value: Value): string {
+      return JSON.stringify(s.rt.toString(value));
+    }
+
+    static "flash.external:ExternalInterface::_quotedStringFromError"(error: Value): string {
+      return JSON.stringify(s.rt.toString(error));
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.external::ExternalInterface", ExternalInterfaceNatives);
+  return natives;
+}