@swf2es/player 0.0.0-stage → 0.1.1

package/src/avm1/bindings.ts

@@ -0,0 +1,257 @@
+// Text fields bound to AVM1 variables, as Ruffle's (https://github.com/
+// ruffle-rs/ruffle) core/src/display_object/edit_text.rs
+// (try_bind_text_field_variable, propagate_text_binding, set_variable) and
+// display_object.rs (Avm1TextFieldBinding) have them: MIT OR Apache-2.0,
+// Copyright (c) 2018-2022 Ruffle LLC and Ruffle contributors. A field's
+// variable is a name, or a path and a name, from the clip the field is in.
+// Where it names a display object's property, the field is bound: a set of
+// the property shows in the field. A field's text set by a script sets the
+// variable, wherever its path leads then. A field whose variable has no
+// object yet waits, and is tried again as a display object is made whose
+// name is a step of its path, the only kind that can give it one.
+import { avm1 } from "@swf2es/runtime";
+import {
+  ButtonObject,
+  CONTENT,
+  type DisplayObject,
+  MovieClip,
+  TextObject,
+} from "../display/display.js";
+import { htmlTextOf, setHtmlText, stateOf } from "./globals/TextField.js";
+
+/** What the bindings need of the movie. */
+export interface BindingHost {
+  readonly version: number;
+  /** `body` run in an activation of `d`, as `d`'s code would run; not where the movie has halted. */
+  inActivation(d: DisplayObject, body: (cx: avm1.Activation) => void): void;
+}
+
+export class VariableBindings {
+  /** The fields bound to each display object's properties, by the property's name. */
+  private readonly bound = new WeakMap<DisplayObject, { field: TextObject; name: string }[]>();
+  /** What each bound field is bound to. */
+  private readonly boundTo = new WeakMap<TextObject, DisplayObject>();
+  /** How many fields are bound, which a property set looks for none while there are none. */
+  private count = 0;
+  /** The fields whose variable's object is not there yet, each with its path's steps in lower case. */
+  private waiting: { field: TextObject; steps: Set<string> }[] = [];
+  /** The fields whose text their variable is taking. */
+  private readonly propagating = new Set<TextObject>();
+
+  constructor(private readonly host: BindingHost) {}
+
+  /** A field made: bound, taking its variable's value, or waiting. */
+  made(field: TextObject): void {
+    if (!this.bind(field, true)) {
+      this.wait(field);
+    }
+  }
+
+  /** `d` made: the fields waiting with its name a step of their path tried again. */
+  retry(d: DisplayObject): void {
+    if (this.waiting.length === 0 || d.name === "") {
+      return;
+    }
+
+    const name = d.name.toLowerCase();
+    this.waiting = this.waiting.filter(
+      (waiting) => !waiting.steps.has(name) || !this.bind(waiting.field, false),
+    );
+  }
+
+  /** `field` waiting for its variable's object; not one without a path, whose object is its parent. */
+  private wait(field: TextObject): void {
+    const variable = stateOf(field).variable;
+    const separator = variable === null ? -1 : lastSeparator(variable);
+    if (variable === null || separator < 0) {
+      return;
+    }
+
+    const steps = variable.slice(0, separator).toLowerCase().split(/[.:/]/);
+    this.waiting.push({ field, steps: new Set(steps) });
+  }
+
+  /**
+   * A field's text changed by a script: the variable takes it, as HTML,
+   * its path resolved again; not again while it is taking it.
+   */
+  textChanged(field: TextObject): void {
+    const variable = stateOf(field).variable;
+    const parent = parentOf(field);
+    if (variable === null || parent === null || this.propagating.has(field)) {
+      return;
+    }
+
+    this.propagating.add(field);
+    try {
+      this.host.inActivation(parent, (cx) => {
+        const found = variablePath(cx, parent, variable, this.host.version);
+        if (found !== null) {
+          avm1.set(found[0], found[1], htmlTextOf(field), this.host.version);
+        }
+      });
+    } finally {
+      this.propagating.delete(field);
+    }
+  }
+
+  /**
+   * A field's variable set: its binding cleared, its text its tag's again,
+   * and bound where it can be now. One that cannot does not wait, as in
+   * Ruffle's set_variable, which leaves it off the unbound list.
+   */
+  variableChanged(field: TextObject): void {
+    this.unbindField(field);
+    field.model.setText(field.definition?.definition?.text ?? "");
+    field.invalidate(CONTENT);
+    field.fit();
+    this.bind(field, true);
+  }
+
+  /** A property of `d`'s AVM1 object set: the fields bound to it by the name show the value. */
+  propertyChanged(d: DisplayObject, name: string, value: avm1.Value, version: number): void {
+    const list = this.count === 0 ? undefined : this.bound.get(d);
+    if (list === undefined) {
+      return;
+    }
+
+    const key = version > 6 ? name : avm1.fold(name);
+    for (const { field, name: bound } of [...list]) {
+      if ((version > 6 ? bound : avm1.fold(bound)) === key) {
+        setHtmlText(field, avm1.stringOf(value, version));
+      }
+    }
+  }
+
+  /**
+   * `d` unloaded: a field no longer bound nor waiting, and the fields bound
+   * to `d`'s properties waiting again, for an object at its path.
+   */
+  unloaded(d: DisplayObject): void {
+    if (d instanceof TextObject) {
+      this.unbindField(d);
+    }
+
+    const list = this.bound.get(d);
+    if (list !== undefined) {
+      this.bound.delete(d);
+      this.count -= list.length;
+      for (const { field } of list) {
+        this.boundTo.delete(field);
+        this.wait(field);
+      }
+    }
+  }
+
+  /**
+   * Bind a field to its variable: where `initial`, the field takes the
+   * variable's value, or, where it has none, a field with text gives it
+   * its text. Whether it is bound, which it is only to a display object's
+   * property; a field without a variable is as good as bound.
+   */
+  private bind(field: TextObject, initial: boolean): boolean {
+    const variable = stateOf(field).variable;
+    if (variable === null) {
+      return true;
+    }
+
+    const parent = parentOf(field);
+    if (parent === null) {
+      return false;
+    }
+
+    let bound = false;
+    const version = this.host.version;
+    this.host.inActivation(parent, (cx) => {
+      const found = variablePath(cx, parent, variable, version);
+      if (found === null) {
+        return;
+      }
+
+      const [object, name] = found;
+      if (initial) {
+        if (avm1.has(object, name, version)) {
+          setHtmlText(field, avm1.stringOf(avm1.get(object, name, version), version));
+        } else if (field.model.text !== "") {
+          avm1.set(object, name, field.model.text, version);
+        }
+      }
+
+      const target = object.display?.target as DisplayObject | undefined;
+      if (target !== undefined) {
+        let list = this.bound.get(target);
+        if (list === undefined) {
+          list = [];
+          this.bound.set(target, list);
+        }
+
+        list.push({ field, name });
+        this.count++;
+        this.boundTo.set(field, target);
+        bound = true;
+      }
+    });
+    return bound;
+  }
+
+  /** A field's binding cleared, and the field no longer waiting for one. */
+  private unbindField(field: TextObject): void {
+    const target = this.boundTo.get(field);
+    if (target !== undefined) {
+      this.boundTo.delete(field);
+      const list = this.bound.get(target);
+      if (list !== undefined) {
+        const rest = list.filter((b) => b.field !== field);
+        this.count -= list.length - rest.length;
+        this.bound.set(target, rest);
+      }
+    }
+
+    const at = this.waiting.findIndex((waiting) => waiting.field === field);
+    if (at >= 0) {
+      this.waiting.splice(at, 1);
+    }
+  }
+}
+
+/** The clip a field's variable is resolved from: its parent, past any button. */
+function parentOf(field: TextObject): DisplayObject | null {
+  let parent: DisplayObject | null = field.parent;
+  while (parent instanceof ButtonObject) {
+    parent = parent.parent;
+  }
+
+  return parent instanceof MovieClip && parent.avm1 !== null ? parent : null;
+}
+
+/**
+ * A variable's object and name: a path's object, up to its last `.` or
+ * `:`, resolved along the scope chain, and the name after it; a name
+ * alone is `parent`'s (Ruffle's resolve_variable_path).
+ */
+function variablePath(
+  cx: avm1.Activation,
+  parent: DisplayObject,
+  path: string,
+  version: number,
+): [avm1.Avm1Object, string] | null {
+  const separator = lastSeparator(path);
+  if (separator < 0) {
+    return parent.avm1 === null ? null : [parent.avm1, path];
+  }
+
+  const name = path.slice(separator + 1);
+  for (let s: avm1.Scope | null = cx.scope; s !== null; s = s.parent) {
+    const object = avm1.targetPath(cx, s.object, path.slice(0, separator), true, true, version);
+    if (object !== null) {
+      return [object, name];
+    }
+  }
+
+  return null;
+}
+
+/** Where a variable's last `.` or `:` is, which ends its path; -1 for a name alone. */
+function lastSeparator(variable: string): number {
+  return Math.max(variable.lastIndexOf(":"), variable.lastIndexOf("."));
+}

package/src/avm1/classes.ts

@@ -0,0 +1,85 @@
+// Object.registerClass's classes: the constructor a symbol's clips are
+// constructed as, bound by the symbol's export name for every SWF, and
+// the name each was registered by, which SharedObject types objects by.
+import { avm1 } from "@swf2es/runtime";
+import { type DisplayObject, MovieClip } from "../display/display.js";
+import type { Avm1 } from "./avm1.js";
+
+type Value = avm1.Value;
+
+/** A symbol name as registerClass keys it, by a SWF of `version`: in its case from SWF 7. */
+function classKey(name: string, version: number): string {
+  return version > 6 ? name : avm1.fold(name);
+}
+
+/** The classes Object.registerClass bound, by symbol name. */
+export class RegisteredClasses {
+  /**
+   * Object.registerClass's classes, by symbol name, one for every SWF:
+   * named in its case from SWF 7, folded up to SWF 6, by the code that
+   * registers and by the SWF of the clip it is looked up for (the
+   * corpus's register_class).
+   */
+  private readonly registered = new Map<string, avm1.Avm1Function>();
+  /**
+   * The name each key was last registered by, in the case it was given,
+   * which AMF0 writes, and when: a constructor of two names is the later's.
+   */
+  private readonly spelled = new Map<string, { name: string; at: number }>();
+  private registrations = 0;
+
+  constructor(private readonly movie: Avm1) {}
+
+  /**
+   * The class Object.registerClass bound to `d`'s character's export name
+   * in its SWF, null for none.
+   */
+  classOf(d: DisplayObject): avm1.Avm1Function | null {
+    // A sprite's only: a button's symbol stays a Button (the corpus's register_class).
+    const id = d instanceof MovieClip ? d.character?.id : undefined;
+    const swf = this.movie.swfOf(d);
+    const name = id === undefined ? undefined : swf.exportNames.get(id);
+    return name === undefined ? null : (this.registered.get(classKey(name, swf.version)) ?? null);
+  }
+
+  /** The name Object.registerClass gave `constr`, as SharedObject's AMF0 types an object; null for none. */
+  registeredName(constr: Value): string | null {
+    if (!(constr instanceof avm1.Avm1Function)) {
+      return null;
+    }
+
+    let found: { name: string; at: number } | null = null;
+    for (const [key, registered] of this.registered) {
+      const spelled = this.spelled.get(key) ?? { name: key, at: -1 };
+      if (registered === constr && (found === null || spelled.at > found.at)) {
+        found = spelled;
+      }
+    }
+
+    return found?.name ?? null;
+  }
+
+  /** Object.registerClass(name, constructor): true where it binds or unbinds (null) the name. */
+  registerClass(args: Value[], version: number): Value {
+    if (args.length < 2) {
+      return false;
+    }
+
+    const constr = args[1];
+    if (constr !== undefined && constr !== null && !(constr instanceof avm1.Avm1Function)) {
+      return false;
+    }
+
+    const name = avm1.stringOf(args[0], version);
+    const key = classKey(name, version);
+    if (constr instanceof avm1.Avm1Function) {
+      this.registered.set(key, constr);
+      this.spelled.set(key, { name, at: this.registrations++ });
+    } else {
+      this.registered.delete(key);
+      this.spelled.delete(key);
+    }
+
+    return true;
+  }
+}

package/src/avm1/clips.ts

@@ -0,0 +1,305 @@
+// The display objects an AVM1 movie's scripts make and take away:
+// attachMovie's, createEmptyMovieClip's, createTextField's and
+// duplicateMovieClip's, each placed and made at once, constructed as its
+// registered class with its init object's properties, and removeMovieClip's
+// removal of what is at a depth scripts place at.
+// The depths and the order of construction follow Ruffle's
+// (https://github.com/ruffle-rs/ruffle) construct_as_avm1_object: MIT OR
+// Apache-2.0, Copyright (c) 2018-2022 Ruffle LLC and Ruffle contributors.
+import { ClipEvent } from "@swf2es/format";
+import { avm1 } from "@swf2es/runtime";
+import {
+  Container,
+  construct,
+  type DisplayObject,
+  displayFor,
+  EMPTY_TIMELINE,
+  MovieClip,
+  TextObject,
+} from "../display/display.js";
+import type { DisplayCharacter } from "../display/timeline.js";
+import type { Avm1 } from "./avm1.js";
+import { ClipNative, DEPTH_BIAS, nativeOf } from "./globals/MovieClip.js";
+import { asciiLower } from "./paths.js";
+import { BLOCK, CONSTRUCT, NO_ARGS, Queued } from "./queue.js";
+import { NO_HANDLERS } from "./swf.js";
+
+/** The highest timeline depth scripts place at, 2^31 - 16777220, as Ruffle has it. */
+const MAX_DEPTH = 2130706428;
+/** The depth from which removeMovieClip removes nothing. */
+const MAX_REMOVE_DEPTH = 2130706416;
+
+/** The blocks of a clip's construct events. */
+export function constructBlocks(native: ClipNative): number[] {
+  const blocks: number[] = [];
+  for (const h of native.handlers ?? NO_HANDLERS) {
+    if (h.events & ClipEvent.construct) {
+      blocks.push(h.block);
+    }
+  }
+
+  return blocks;
+}
+
+/** Whether a character is one a timeline places. */
+function isDisplayCharacter(c: unknown): c is DisplayCharacter {
+  const type = (c as { type?: string } | null | undefined)?.type;
+  return (
+    type === "sprite" ||
+    type === "shape" ||
+    type === "morph" ||
+    type === "button" ||
+    type === "text" ||
+    type === "static" ||
+    type === "bitmap"
+  );
+}
+
+/** What the movie's scripts place on and take off the display list. */
+export class ScriptClips {
+  /** The display object a script is making, which it constructs itself; its children are the timeline's. */
+  scripted: DisplayObject | null = null;
+
+  constructor(private readonly movie: Avm1) {}
+
+  /**
+   * attachMovie: the character exported as `name` placed in `parent` at
+   * AVM1 depth `depth` as `instance`, made as a script makes one; null
+   * where there is no such character or the depth is out of range.
+   */
+  attachMovie(
+    parent: MovieClip,
+    name: string,
+    instance: string,
+    depth: number,
+    init: avm1.Avm1Object | null,
+  ): DisplayObject | null {
+    const timelineDepth = (depth + DEPTH_BIAS) | 0;
+    if (timelineDepth < 0 || timelineDepth > MAX_DEPTH) {
+      return null;
+    }
+
+    const swf = this.movie.swfOf(parent);
+    const id = swf.exports.get(asciiLower(name));
+    const character = id === undefined ? undefined : swf.library?.characters.get(id);
+    if (!isDisplayCharacter(character)) {
+      return null;
+    }
+
+    const child = displayFor(character, parent.library);
+    return this.scriptPlace(parent, child, character, instance, timelineDepth, init);
+  }
+
+  /** createEmptyMovieClip: an empty clip in `parent` at AVM1 depth `depth` as `instance`. */
+  createEmptyMovieClip(parent: MovieClip, instance: string, depth: number): DisplayObject {
+    const child = new MovieClip(EMPTY_TIMELINE, parent.library);
+    return this.scriptPlace(parent, child, null, instance, (depth + DEPTH_BIAS) | 0, null);
+  }
+
+  /** createTextField: an empty field in `parent` at AVM1 depth `depth` as `instance`. */
+  createTextField(
+    parent: MovieClip,
+    instance: string,
+    depth: number,
+    [x, y, width, height]: [number, number, number, number],
+  ): DisplayObject {
+    const field = new TextObject(null);
+    field.fonts = parent.library.fonts;
+    field.width = width;
+    field.height = height;
+    field.matrix = { ...field.matrix, tx: x, ty: y };
+    return this.scriptPlace(parent, field, null, instance, (depth + DEPTH_BIAS) | 0, null);
+  }
+
+  /**
+   * duplicateMovieClip and CloneSprite: a new one of `d`'s character, or an
+   * empty clip for a script's, beside it at timeline depth `depth` as
+   * `name`, with its matrix, colour and clip actions; null where `d` has
+   * no clip for a parent or the depth is out of range.
+   */
+  duplicate(
+    d: DisplayObject,
+    name: string,
+    depth: number,
+    init: avm1.Avm1Object | null,
+  ): DisplayObject | null {
+    const parent = this.movie.levelOf(d) !== null ? null : d.parent;
+    if (!(parent instanceof MovieClip) || this.movie.removed(d) || depth < 0 || depth > MAX_DEPTH) {
+      return null;
+    }
+
+    const character = d.character as DisplayCharacter | null;
+    let child: DisplayObject;
+    if (isDisplayCharacter(character)) {
+      child = displayFor(character, parent.library);
+    } else if (d instanceof MovieClip) {
+      child = new MovieClip(EMPTY_TIMELINE, parent.library);
+    } else {
+      return null;
+    }
+
+    child.matrix = { ...d.matrix };
+    child.colorTransform = d.colorTransform === null ? null : { ...d.colorTransform };
+    const native = nativeOf(d);
+    if (native !== null && native.handlers !== null) {
+      this.handed.set(child, native);
+    }
+
+    return this.scriptPlace(
+      parent,
+      child,
+      isDisplayCharacter(character) ? character : null,
+      name,
+      depth,
+      init,
+    );
+  }
+
+  /** The clips a duplicate takes the clip actions of, until it is made. */
+  readonly handed = new WeakMap<DisplayObject, ClipNative>();
+
+  /**
+   * removeMovieClip and RemoveSprite: `d` removed, where it is at a depth
+   * scripts place at (a timeline's clip swapped there too), as Flash
+   * removes only those.
+   */
+  remove(d: DisplayObject): void {
+    const parent = this.movie.levelOf(d) !== null ? null : d.parent;
+    const depth = d.depth;
+    if (
+      !(parent instanceof Container) ||
+      depth === null ||
+      depth < DEPTH_BIAS ||
+      depth >= MAX_REMOVE_DEPTH ||
+      this.movie.removed(d)
+    ) {
+      return;
+    }
+
+    parent.removeAtDepth(depth);
+  }
+
+  /**
+   * A display object a script made, put in `parent` at timeline depth
+   * `depth` as `name` and made: its first frame entered, its children
+   * placed, its load queued; then its construct events, its init
+   * object's properties, before them up to SWF 6, its class's constructor
+   * and its onConstruct at once, its initialize events queued as it was
+   * made (adl:
+   * Ruffle runs neither event, and onConstruct only for
+   * createEmptyMovieClip's).
+   */
+  private scriptPlace(
+    parent: MovieClip,
+    child: DisplayObject,
+    character: DisplayCharacter | null,
+    name: string,
+    depth: number,
+    init: avm1.Avm1Object | null,
+  ): DisplayObject {
+    child.name = name;
+    parent.placeAtDepth(child, depth);
+    const outer = this.scripted;
+    this.scripted = child;
+    try {
+      if (character !== null) {
+        construct(child, character, parent.library);
+      } else {
+        this.movie.made(child);
+        if (child instanceof MovieClip) {
+          child.enterFirstFrame();
+        }
+      }
+    } finally {
+      this.scripted = outer;
+    }
+
+    const face = child.avm1;
+    const native = face?.display;
+    if (face === null || !(native instanceof ClipNative)) {
+      return child;
+    }
+
+    const version = this.movie.swfOf(child).version;
+    const constr = this.movie.classes.classOf(child);
+    if (constr !== null) {
+      face.define(
+        "__proto__",
+        avm1.get(constr, "prototype", version),
+        avm1.DONT_ENUM | avm1.DONT_DELETE,
+      );
+    }
+
+    // It is constructed as the queue's constructions are: a function returning in it
+    // runs only initializations queued (the corpus's register_and_init_order).
+    const pass = this.movie.queue.priority;
+    this.movie.queue.priority = CONSTRUCT;
+    try {
+      // A SWF 6 sets the init object's properties before the construct events, a later one
+      // after (adl).
+      if (version <= 6) {
+        this.initProperties(face, init, version);
+      }
+
+      for (const block of constructBlocks(native)) {
+        this.movie.queue.runOne(new Queued(BLOCK, child, native.swf, block), []);
+      }
+
+      if (version > 6) {
+        this.initProperties(face, init, version);
+      }
+
+      if (constr !== null) {
+        this.construct(child, face, constr);
+      }
+
+      // Then its onConstruct, from MovieClip's prototype or its class's, what it
+      // throws caught there (adl, and the corpus's movieclip_onconstruct).
+      const cx = this.movie.activationOf(child);
+      if (cx !== null) {
+        this.movie.rt.callMethod(cx, face, "onConstruct", NO_ARGS, version);
+      }
+    } finally {
+      this.movie.queue.priority = pass;
+    }
+
+    return child;
+  }
+
+  /** An init object's properties set on `face`, in the reverse of for..in's order, as Flash sets them. */
+  private initProperties(
+    face: avm1.Avm1Object,
+    init: avm1.Avm1Object | null,
+    version: number,
+  ): void {
+    const cx = init === null ? null : this.movie.activationOf(this.movie.root);
+    if (init === null || cx === null) {
+      return;
+    }
+
+    this.movie.rt.call(cx, () => {
+      const names = avm1.keys(init, version);
+      for (let i = names.length - 1; i >= 0; i--) {
+        avm1.set(face, names[i], avm1.get(init, names[i], version), version);
+      }
+    });
+  }
+
+  /** `constr` run on the clip's object as its constructor, as `new` runs one. */
+  construct(clip: DisplayObject, face: avm1.Avm1Object, constr: avm1.Avm1Function): void {
+    const cx = this.movie.activationOf(clip);
+    if (cx === null) {
+      return;
+    }
+
+    const version = this.movie.swfOf(clip).version;
+    face.define("__constructor__", constr, avm1.DONT_ENUM);
+    if (version < 7) {
+      face.define("constructor", constr, avm1.DONT_ENUM);
+    }
+
+    this.movie.rt.call(cx, () => {
+      constr.callConstructor(face, NO_ARGS, version, 1);
+    });
+  }
+}