@swf2es/player 0.0.0-stage → 0.1.1

package/src/playerglobal/flash/display/Loader.ts

@@ -0,0 +1,126 @@
+// flash.display.Loader: a container whose one child is the root of the SWF
+// it loaded. Its loads complete in a later frame (Loads.completeLoads),
+// but an AVM1 SWF's from bytes, at the end of the frame (Loads.requestLoad).
+import { avm2 } from "@swf2es/runtime";
+import type { Scripting } from "../../../scripting.js";
+import { uncaughtErrorEvents } from "./LoaderInfo.js";
+
+type AsObject = avm2.AsObject;
+type Value = avm2.Value;
+
+/** A copy of a ByteArray's bytes, as they are now. */
+function copyOf(s: Scripting, v: Value): Uint8Array {
+  if (!v) {
+    throw s.rt.error("TypeError", 2007, "bytes");
+  }
+
+  const b = avm2.bytesOf(s.rt, v);
+  return new Uint8Array(b.buffer.subarray(0, b.length));
+}
+
+/**
+ * A LoaderContext's parameters, which take the place of the content's URL
+ * query in its loaderInfo.parameters: null when none were set. Flash
+ * refuses any value that is not a String, null and undefined among them,
+ * with Error #2196 at the call; an object that is not one, such as a
+ * String, has no names and gives none.
+ */
+function contextParameters(s: Scripting, v: Value): Map<string, string> | null {
+  if (v === null || v === undefined) {
+    return null;
+  }
+
+  const parameters = new Map<string, string>();
+  for (let i = s.rt.hasNext(v, 0); i !== 0; i = s.rt.hasNext(v, i)) {
+    const value = s.rt.nextValue(v, i);
+    if (typeof value !== "string") {
+      throw s.rt.error("flash.errors::IllegalOperationError", 2196, "LoaderContext.parameters");
+    }
+
+    parameters.set(String(s.rt.nextName(v, i)), value);
+  }
+
+  return parameters;
+}
+
+export function loaderNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+
+  class LoaderNatives {
+    declare $content: AsObject | null | undefined;
+    declare $loaderInfo: AsObject | undefined;
+    declare $uncaught: AsObject | undefined;
+    declare $generation: number | undefined;
+    declare $abort: AbortController | null | undefined;
+
+    get content(): Value {
+      return this.$content ?? null;
+    }
+
+    get contentLoaderInfo(): Value {
+      if (!this.$loaderInfo) {
+        this.$loaderInfo = s.loads.loaderInfo(this);
+      }
+
+      return this.$loaderInfo;
+    }
+
+    // Both take the LoaderContext's fields after the source: checkPolicyFile,
+    // applicationDomain, securityDomain, requestedContentParent, parameters,
+    // the JPEG deblocking, allowCodeImport and imageDecodingPolicy. Only
+    // applicationDomain, for where the content's code loads, and parameters
+    // are read.
+    "flash.display:Loader::_loadBytes"(
+      bytes: Value,
+      _checkPolicyFile: Value,
+      applicationDomain: Value,
+      _securityDomain: Value,
+      _requestedContentParent: Value,
+      parameters: Value,
+    ): void {
+      const copy = copyOf(s, bytes);
+      const given = contextParameters(s, parameters);
+      s.loads.requestLoad(this, copy, s.loads.loadDomain(applicationDomain), given);
+    }
+
+    "flash.display:Loader::_load"(
+      request: Value,
+      _checkPolicyFile: Value,
+      applicationDomain: Value,
+      _securityDomain: Value,
+      _requestedContentParent: Value,
+      parameters: Value,
+    ): void {
+      const given = contextParameters(s, parameters);
+      s.loads.requestLoadUrl(
+        this,
+        request as AsObject,
+        s.loads.loadDomain(applicationDomain),
+        given,
+      );
+    }
+
+    "flash.display:Loader::_unload"(stopAllMovieClips: Value, _gc: Value): void {
+      s.loads.unload(this, !!stopAllMovieClips);
+    }
+
+    "flash.display:Loader::_getJPEGLoaderContextdeblockingfilter"(_context: Value): number {
+      return 0;
+    }
+
+    "flash.display:Loader::_close"(): void {
+      s.loads.closeLoad(this);
+    }
+
+    "flash.display:Loader::_getUncaughtErrorEvents"(): Value {
+      return uncaughtErrorEvents(s, this);
+    }
+
+    "flash.display:Loader::_setUncaughtErrorEvents"(v: Value): void {
+      this.$uncaught = v;
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.display::Loader", LoaderNatives);
+  return natives;
+}

package/src/playerglobal/flash/display/LoaderInfo.ts

@@ -0,0 +1,205 @@
+// flash.display.LoaderInfo: what is known of a SWF or image, the main one's or a
+// Loader's; Loads.loaderInfo makes one and keeps its facts on it.
+import { avm2 } from "@swf2es/runtime";
+import type { Scripting } from "../../../scripting.js";
+
+type AsObject = avm2.AsObject;
+type Value = avm2.Value;
+
+interface SwfFacts {
+  version: number;
+  frameRate: number;
+  width: number;
+  height: number;
+  as3: boolean;
+}
+
+interface ImageFacts {
+  width: number;
+  height: number;
+  contentType: string;
+}
+
+/** A LoaderInfo's facts about its SWF, which Flash refuses to tell before the SWF is loaded: Error #2099. */
+function factsOf(
+  s: Scripting,
+  info: { $swf: SwfFacts | null; $image: ImageFacts | null },
+): SwfFacts {
+  if (info.$image) {
+    throw s.rt.error("Error", 2098);
+  }
+
+  if (!info.$swf) {
+    throw s.rt.error("Error", 2099);
+  }
+
+  return info.$swf;
+}
+
+/** The UncaughtErrorEvents of `owner`, a Loader or the main SWF's LoaderInfo, made when first asked for. */
+export function uncaughtErrorEvents(s: Scripting, owner: AsObject): AsObject {
+  if (!owner.$uncaught) {
+    owner.$uncaught = s.rt.construct(s.rt.classNamed("flash.events::UncaughtErrorEvents"));
+  }
+
+  return owner.$uncaught;
+}
+
+export function loaderInfoNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+
+  class LoaderInfoNatives {
+    declare $loader: AsObject | null;
+    declare $content: AsObject | null;
+    declare $bytes: Uint8Array | null;
+    declare $swf: SwfFacts | null;
+    declare $image: ImageFacts | null;
+    declare $url: string | null;
+    /** What `parameters` tells (Loads.loaderInfo): its LoaderContext's, its URL's query, or the main SWF's flashvars. */
+    declare $params: ReadonlyMap<string, string>;
+    /** The application domain its content loads into, as its load chose it; unset for the main SWF's. */
+    declare $domain: avm2.Domain | undefined;
+    /** The URL the content gets when it is placed, for a load from bytes. */
+    declare $dynamic: string | undefined;
+    /** The URL of the SWF the Loader belongs to, even before its first load. */
+    declare $loaderURL: string | null;
+    declare $loaded: number;
+    declare $total: number;
+    declare $shared: AsObject | undefined;
+    declare $uncaught: AsObject | undefined;
+
+    get loader(): Value {
+      return this.$loader;
+    }
+
+    get content(): Value {
+      return this.$content;
+    }
+
+    get url(): Value {
+      return this.$url;
+    }
+
+    get loaderURL(): Value {
+      return this.$loaderURL;
+    }
+
+    get isURLInaccessible(): boolean {
+      return false;
+    }
+
+    get bytesLoaded(): number {
+      return this.$loaded;
+    }
+
+    get bytesTotal(): number {
+      return this.$total;
+    }
+
+    // The domain its load chose (Loads.loadDomain), or the main SWF's.
+    get applicationDomain(): Value {
+      return this.$domain || this.$swf
+        ? s.code.applicationDomainOf(this.$domain ?? s.mainDomain)
+        : null;
+    }
+
+    get swfVersion(): number {
+      return factsOf(s, this).version;
+    }
+
+    get actionScriptVersion(): number {
+      return factsOf(s, this).as3 ? 3 : 2;
+    }
+
+    get frameRate(): number {
+      return factsOf(s, this).frameRate;
+    }
+
+    get width(): number {
+      return (this.$image ?? factsOf(s, this)).width;
+    }
+
+    get height(): number {
+      return (this.$image ?? factsOf(s, this)).height;
+    }
+
+    get contentType(): Value {
+      return this.$image?.contentType ?? (this.$swf ? "application/x-shockwave-flash" : null);
+    }
+
+    get sharedEvents(): Value {
+      if (!this.$shared) {
+        this.$shared = s.rt.construct(s.rt.classNamed("flash.events::EventDispatcher"));
+      }
+
+      return this.$shared;
+    }
+
+    get sameDomain(): boolean {
+      return true;
+    }
+
+    get childAllowsParent(): boolean {
+      return true;
+    }
+
+    get parentAllowsChild(): boolean {
+      return true;
+    }
+
+    get parentSandboxBridge(): Value {
+      return null;
+    }
+
+    set parentSandboxBridge(_v: Value) {
+      // One sandbox.
+    }
+
+    get childSandboxBridge(): Value {
+      return null;
+    }
+
+    set childSandboxBridge(_v: Value) {
+      // One sandbox.
+    }
+
+    /** The SWF's bytes as a ByteArray, when they are known. */
+    get bytes(): Value {
+      if (!this.$bytes) {
+        return null;
+      }
+
+      const array = s.rt.construct(s.rt.classNamed("flash.utils::ByteArray")) as AsObject;
+      const b = avm2.bytesOf(s.rt, array);
+      b.write(this.$bytes);
+      b.position = 0;
+      return array;
+    }
+
+    // A new object at each ask, as Flash's: a script that changes one changes no other.
+    "flash.display:LoaderInfo::_getArgs"(): Value {
+      const args = s.rt.objectTraits.instance();
+      for (const [name, value] of this.$params) {
+        s.rt.setProperty(args, s.rt.publicName(name), value);
+      }
+
+      return args;
+    }
+
+    /** The Loader's and its LoaderInfo's uncaughtErrorEvents are one dispatcher. */
+    "flash.display:LoaderInfo::_getUncaughtErrorEvents"(): Value {
+      return uncaughtErrorEvents(s, this.$loader ?? this);
+    }
+
+    "flash.display:LoaderInfo::_setUncaughtErrorEvents"(v: Value): void {
+      (this.$loader ?? this).$uncaught = v;
+    }
+
+    static getLoaderInfoByDefinition(_object: Value): Value {
+      return null;
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.display::LoaderInfo", LoaderInfoNatives);
+  return natives;
+}

package/src/playerglobal/flash/display/MovieClip.ts

@@ -0,0 +1,245 @@
+// flash.display.MovieClip and FrameLabel: the timeline from a script, its
+// scenes and labels. Frame scripts registered with addFrameScript run when
+// their frame is entered, in the frame's script phase; a goto takes the
+// next phase there.
+import { avm2 } from "@swf2es/runtime";
+import type { MovieClip } from "../../../display/display.js";
+import type { FrameName } from "../../../display/timeline.js";
+import type { Scripting } from "../../../scripting.js";
+
+type Value = avm2.Value;
+
+export function movieClipNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+  // s.rt at call time: the natives are made before the runtime that holds them is.
+  /** The scene the clip's frame is in, by its index in the timeline's scenes. */
+  const sceneIndex = (clip: MovieClip): number => {
+    const scenes = clip.timeline.scenes;
+    const frame = Math.max(1, clip.currentFrame);
+    let i = 0;
+    while (i + 1 < scenes.length && scenes[i + 1].frame <= frame) {
+      i++;
+    }
+
+    return i;
+  };
+  /** A scene's first frame, and the first after it. */
+  const sceneFrames = (clip: MovieClip, i: number): [number, number] => {
+    const scenes = clip.timeline.scenes;
+    return [scenes[i].frame, i + 1 < scenes.length ? scenes[i + 1].frame : clip.totalFrames + 1];
+  };
+  /** Labels in a scene; the last scene's run on past the last frame, as a label after it may. */
+  const inScene = (clip: MovieClip, i: number, labels: FrameName[]): FrameName[] => {
+    const [first, after] = sceneFrames(clip, i);
+    const last = i + 1 === clip.timeline.scenes.length;
+    return labels.filter((l) => l.frame >= first && (last || l.frame < after));
+  };
+  /** A flash.display.Scene, made anew on each read as Flash does: its labels' frames count from its first. */
+  const sceneObject = (clip: MovieClip, i: number): Value => {
+    const [first, after] = sceneFrames(clip, i);
+    const labelClass = s.rt.classNamed("flash.display::FrameLabel");
+    const labels = inScene(clip, i, clip.timeline.labels).map((l) =>
+      s.rt.construct(labelClass, l.name, l.frame - first + 1),
+    );
+    return s.rt.construct(
+      s.rt.classNamed("flash.display::Scene"),
+      clip.timeline.scenes[i].name,
+      s.rt.array(labels),
+      after - first,
+    );
+  };
+  /**
+   * The frame a goto names, on the whole timeline: a number counts from the
+   * scene's first frame, the named scene's or the clip's own, and a label is
+   * looked for in that scene alone. A scene of that name must exist (2108),
+   * and in a named scene, or one of several, as only scene data makes, a
+   * label in it (2109); in a timeline's one unnamed scene an unknown label
+   * is a number, 0, which takes Flash to frame 1.
+   */
+  const frameOf = (clip: MovieClip, frame: Value, scene: Value): number => {
+    const scenes = clip.timeline.scenes;
+    let i = sceneIndex(clip);
+    if (scene !== null && scene !== undefined) {
+      const name = s.rt.toString(scene);
+      i = scenes.findIndex((x) => x.name === name);
+      if (i < 0) {
+        throw s.rt.error("ArgumentError", 2108, name);
+      }
+    }
+
+    const first = sceneFrames(clip, i)[0];
+    if (typeof frame === "string" && !/^\d+$/.test(frame)) {
+      const label = inScene(clip, i, clip.timeline.gotoLabels).find((l) => l.name === frame);
+      if (label) {
+        return label.frame;
+      }
+
+      if (scenes[i].name !== "" || scenes.length > 1) {
+        throw s.rt.error("ArgumentError", 2109, frame, scenes[i].name);
+      }
+    }
+
+    return first + s.rt.toInt(frame) - 1;
+  };
+  /**
+   * Jump to `frame`, playing or stopped: at once, or when the frame script
+   * asking returns, as Flash defers a goto from one. The clip plays or stops
+   * as the goto happens, before the landing frame's script runs, so a
+   * stop() or play() there has the last word, and one the asking script
+   * calls after a deferred goto has none (`goto-stops`).
+   */
+  const goto = (clip: MovieClip, frame: number, play: boolean) => {
+    if ((clip.library.version ?? 10) <= 9) {
+      clip.skipsAfter = s.frames;
+    }
+
+    if (s.inFrameScript === clip) {
+      clip.queuedGoto = frame;
+      clip.queuedPlay = play;
+    } else {
+      clip.playing = play;
+      clip.gotoFrame(frame);
+      s.gotoCycle(clip);
+    }
+  };
+
+  class MovieClipNatives {
+    declare $display: MovieClip;
+    declare $enabled: boolean | undefined;
+
+    addFrameScript(...args: Value[]): void {
+      const clip = this.$display;
+      for (let i = 0; i + 1 < args.length; i += 2) {
+        clip.setFrameScript(s.rt.toInt(args[i]) + 1, args[i + 1]);
+      }
+    }
+
+    /** The frame in its scene, 1 the scene's first. */
+    get currentFrame(): number {
+      const clip = this.$display;
+      return Math.max(1, clip.currentFrame) - sceneFrames(clip, sceneIndex(clip))[0] + 1;
+    }
+
+    get totalFrames(): number {
+      return this.$display.totalFrames;
+    }
+
+    get framesLoaded(): number {
+      return this.$display.totalFrames;
+    }
+
+    /** The nearest label at or before the frame, whatever scene it is in. */
+    get currentLabel(): Value {
+      const clip = this.$display;
+      let label: string | null = null;
+      for (const l of clip.timeline.labels) {
+        if (l.frame > clip.currentFrame) {
+          break;
+        }
+
+        label = l.name;
+      }
+
+      return label;
+    }
+
+    /** A FrameLabel tag on this very frame, which Flash reads even where the scene data has none. */
+    get currentFrameLabel(): Value {
+      return this.$display.timeline.frameLabels.get(this.$display.currentFrame) ?? null;
+    }
+
+    get scenes(): Value {
+      const clip = this.$display;
+      return s.rt.array(clip.timeline.scenes.map((_, i) => sceneObject(clip, i)));
+    }
+
+    get currentScene(): Value {
+      const clip = this.$display;
+      return sceneObject(clip, sceneIndex(clip));
+    }
+
+    /** The scene before's first frame, playing; in the first scene, its own. */
+    prevScene(): void {
+      const clip = this.$display;
+      goto(clip, sceneFrames(clip, Math.max(0, sceneIndex(clip) - 1))[0], true);
+    }
+
+    /** The next scene's first frame, playing; in the last scene, its own. */
+    nextScene(): void {
+      const clip = this.$display;
+      const i = sceneIndex(clip);
+      goto(clip, sceneFrames(clip, Math.min(clip.timeline.scenes.length - 1, i + 1))[0], true);
+    }
+
+    get isPlaying(): boolean {
+      return this.$display.playing;
+    }
+
+    play(): void {
+      this.$display.playing = true;
+    }
+
+    stop(): void {
+      this.$display.playing = false;
+    }
+
+    nextFrame(): void {
+      const clip = this.$display;
+      goto(clip, clip.currentFrame + 1, false);
+    }
+
+    prevFrame(): void {
+      const clip = this.$display;
+      goto(clip, clip.currentFrame - 1, false);
+    }
+
+    gotoAndPlay(frame: Value, scene: Value = null): void {
+      const clip = this.$display;
+      goto(clip, frameOf(clip, frame, scene), true);
+    }
+
+    gotoAndStop(frame: Value, scene: Value = null): void {
+      const clip = this.$display;
+      goto(clip, frameOf(clip, frame, scene), false);
+    }
+
+    get enabled(): boolean {
+      return this.$enabled ?? true;
+    }
+
+    set enabled(v: Value) {
+      this.$enabled = !!v;
+    }
+
+    get trackAsMenu(): boolean {
+      return false;
+    }
+
+    set trackAsMenu(_v: Value) {
+      // No menus.
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.display::MovieClip", MovieClipNatives);
+
+  class FrameLabelNatives {
+    declare $name: string;
+    declare $frame: number;
+
+    "flash.display:FrameLabel::ctor"(name: Value, frame: Value): void {
+      this.$name = s.rt.toString(name);
+      this.$frame = s.rt.toInt(frame);
+    }
+
+    get name(): string {
+      return this.$name;
+    }
+
+    get frame(): number {
+      return this.$frame;
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.display::FrameLabel", FrameLabelNatives);
+  return natives;
+}