@swf2es/player 0.0.0-stage → 0.1.1

package/src/avm1/globals/FileReference.ts

@@ -0,0 +1,249 @@
+// AS2's flash.net file references use the same dialogs and transfers as AS3's.
+import { avm1 } from "@swf2es/runtime";
+import { FileReference, type FileServices, type SelectedFile } from "../../files.js";
+import type { Avm1 } from "../avm1.js";
+
+type Obj = avm1.Avm1Object;
+
+export function fileReferenceClasses(movie: Avm1): avm1.Avm1Object {
+  const realm = movie.realm;
+  const version = movie.version;
+  const states = new WeakMap<Obj, FileReference>();
+  const services: FileServices = {
+    host: movie.fileHost,
+    signal: movie.fileLifetime.signal,
+    defer: (deliver) => movie.net.after(Promise.resolve(), deliver),
+    track: (task) => movie.net.after(task, () => {}),
+    fetch: (request, signal) =>
+      movie.net.request(
+        {
+          ...request,
+          method: request.method === "POST" ? "POST" : "GET",
+          headers: request.headers.map(([name, value]) => [name, value]),
+        },
+        "data",
+        signal,
+      ),
+    error: (id): never => {
+      throw new Error(`Error #${id}`);
+    },
+  };
+  const notify = (self: Obj, name: string, args: avm1.Value[] = []) => {
+    movie.callback(self, "broadcastMessage", [name, self, ...args]);
+  };
+  const state = (self: Obj): FileReference => {
+    let ref = states.get(self);
+    if (!ref) {
+      ref = new FileReference(services, (type, loaded, total, text) => {
+        switch (type) {
+          case "select":
+            notify(self, "onSelect");
+            break;
+          case "cancel":
+            notify(self, "onCancel");
+            break;
+          case "open":
+            notify(self, "onOpen");
+            break;
+          case "progress":
+            notify(self, "onProgress", [loaded, total]);
+            break;
+          case "httpStatus":
+            notify(self, "onHTTPError", [loaded]);
+            break;
+          case "complete":
+            notify(self, "onComplete");
+            break;
+          case "ioError":
+            notify(self, "onIOError");
+            break;
+          case "uploadCompleteData":
+            notify(self, "onUploadCompleteData", [text]);
+            break;
+        }
+      });
+      states.set(self, ref);
+    }
+
+    return ref;
+  };
+  const proto = new avm1.Avm1Object(realm.objectProto);
+  const construct = (self: Obj) => {
+    state(self);
+    avm1.initializeBroadcaster(self, realm, version);
+    return self;
+  };
+  const reference = realm.classOf(proto, construct, () => undefined);
+  const hidden = avm1.DONT_ENUM | avm1.DONT_DELETE;
+  const method = (name: string, fn: avm1.Native) => proto.define(name, realm.method(fn), hidden);
+  const metadata = (name: string, read: (file: SelectedFile) => avm1.Value) => {
+    const p = proto.define(name, undefined, hidden);
+    p.get = realm.method((self) => {
+      const file = states.get(self as Obj)?.file;
+      return file ? read(file) : undefined;
+    });
+    p.set = realm.method(() => undefined);
+  };
+  metadata("name", (file) => file.name);
+  metadata("size", (file) => file.size);
+  metadata("type", (file) => {
+    const dot = file.name.lastIndexOf(".");
+    return dot < 0 ? "" : file.name.slice(dot);
+  });
+  metadata("creator", () => undefined);
+  metadata("creationDate", (file) =>
+    realm.construct(realm.Date.constr, [file.creationDate ?? file.modificationDate], version),
+  );
+  metadata("modificationDate", (file) =>
+    realm.construct(realm.Date.constr, [file.modificationDate], version),
+  );
+  const filters = (args: avm1.Value[]) => {
+    if (args.length === 0) {
+      return [];
+    }
+
+    const value = args[0];
+    if (!(value instanceof avm1.Avm1Object) || !value.own("length", version)) {
+      return null;
+    }
+
+    const count = avm1.toNumber(avm1.get(value, "length", version), version) >>> 0;
+    if (count === 0) {
+      return null;
+    }
+
+    const result: { description: string; extension: string }[] = [];
+    for (let i = 0; i < count; i++) {
+      const filter = avm1.get(value, String(i), version);
+      if (
+        !(filter instanceof avm1.Avm1Object) ||
+        !filter.own("description", version) ||
+        !filter.own("extension", version)
+      ) {
+        return null;
+      }
+
+      const read = (name: string) => {
+        try {
+          return avm1.get(filter, name, version);
+        } catch {
+          return undefined;
+        }
+      };
+      const description = read("description");
+      const extension = read("extension");
+      if (description == null || extension == null) {
+        return null;
+      }
+
+      const text = avm1.stringOf(description, version);
+      const pattern = avm1.stringOf(extension, version);
+      const mac = read("macType");
+      if (mac != null) {
+        avm1.stringOf(mac, version);
+      }
+      if (!text || !pattern) {
+        return null;
+      }
+      result.push({ description: text, extension: pattern });
+    }
+
+    return result;
+  };
+  method("browse", (self, args) => {
+    const chosen = filters(args);
+    if (chosen === null) {
+      return false;
+    }
+    try {
+      state(self as Obj).browse(chosen);
+      return true;
+    } catch {
+      return false;
+    }
+  });
+  method("cancel", (self) => {
+    state(self as Obj).cancel();
+  });
+  method("download", (self, args) => {
+    if (!args.length) {
+      return false;
+    }
+
+    const url = avm1.stringOf(args[0], version);
+    const name =
+      args.length > 1
+        ? avm1.stringOf(args[1], version)
+        : url.split(/[?#]/, 1)[0].split("/").pop() || "download";
+    try {
+      state(self as Obj).save(name, {
+        url: movie.net.resolve(url),
+        method: "GET",
+        headers: [],
+        body: null,
+        purpose: "data",
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  });
+  method("upload", (self, args) => {
+    if (!args.length || !state(self as Obj).file) {
+      return false;
+    }
+
+    try {
+      state(self as Obj).upload(
+        {
+          url: movie.net.resolve(avm1.stringOf(args[0], version)),
+          method: "POST",
+          headers: [],
+          body: null,
+          purpose: "data",
+        },
+        args.length > 1 ? avm1.stringOf(args[1], version) : "Filedata",
+        avm1.toBoolean(args[2], version),
+      );
+      return true;
+    } catch {
+      return false;
+    }
+  });
+  const listProto = new avm1.Avm1Object(realm.objectProto);
+  const list = realm.classOf(
+    listProto,
+    (self) => {
+      avm1.initializeBroadcaster(self, realm, version);
+      return self;
+    },
+    () => undefined,
+  );
+  listProto.define(
+    "browse",
+    realm.method((self, args) => {
+      const chosen = filters(args);
+      if (chosen === null) {
+        return false;
+      }
+      try {
+        state(self as Obj).browse(chosen, true, (files) => {
+          const objects = files.map((file) => {
+            const object = realm.construct(reference, [], version);
+            state(object as Obj).file = file;
+            return object;
+          });
+          avm1.set(self as Obj, "fileList", realm.newArray(objects, version), version);
+        });
+        return true;
+      } catch {
+        return false;
+      }
+    }),
+    hidden,
+  );
+  const net = new avm1.Avm1Object(realm.objectProto);
+  net.define("FileReference", reference, 0);
+  net.define("FileReferenceList", list, 0);
+  return net;
+}

package/src/avm1/globals/Key.ts

@@ -0,0 +1,102 @@
+// Key and Mouse, the keyboard's and the pointer's AS2 faces, as Ruffle's
+// (https://github.com/ruffle-rs/ruffle) core/src/avm1/globals/key.rs and
+// mouse.rs have them: MIT OR Apache-2.0, Copyright (c) 2018-2022 Ruffle LLC
+// and Ruffle contributors. Each is a broadcaster: the player sends Key's
+// listeners onKeyDown and onKeyUp, Mouse's onMouseDown, onMouseMove,
+// onMouseUp and onMouseWheel (input.ts).
+import { avm1 } from "@swf2es/runtime";
+
+/** What Key and Mouse read of the player. */
+export interface InputState {
+  /** Whether the key of Flash's code `code` is down; the mouse's buttons are keys 1, 2 and 4. */
+  keyIsDown(code: number): boolean;
+  /** Whether the key of code `code` is toggled on, as each press turns it on or off. */
+  keyToggled(code: number): boolean;
+  /** The last key pressed: its code, and the character it typed. */
+  readonly keyCode: number;
+  readonly keyAscii: number;
+  /** Whether the pointer shows; set, it shows or hides. */
+  mouseShown: boolean;
+}
+
+/** Key's constants, its keys' codes. */
+const KEYS: [string, number][] = [
+  ["ALT", 18],
+  ["BACKSPACE", 8],
+  ["CAPSLOCK", 20],
+  ["CONTROL", 17],
+  ["DELETEKEY", 46],
+  ["DOWN", 40],
+  ["END", 35],
+  ["ENTER", 13],
+  ["ESCAPE", 27],
+  ["HOME", 36],
+  ["INSERT", 45],
+  ["LEFT", 37],
+  ["PGDN", 34],
+  ["PGUP", 33],
+  ["RIGHT", 39],
+  ["SHIFT", 16],
+  ["SPACE", 32],
+  ["TAB", 9],
+  ["UP", 38],
+];
+
+const FIXED = avm1.DONT_ENUM | avm1.DONT_DELETE | avm1.READ_ONLY;
+
+/** `_global.Key`. */
+export function keyObject(realm: avm1.Realm, input: InputState, version: number): avm1.Avm1Object {
+  const key = new avm1.Avm1Object(realm.objectProto);
+  avm1.initializeBroadcaster(key, realm, version);
+
+  for (const [name, code] of KEYS) {
+    key.define(name, code, FIXED);
+  }
+
+  const code = (args: avm1.Value[], v: number) =>
+    args.length > 0 ? avm1.toNumber(args[0], v) | 0 : Number.NaN;
+  key.define(
+    "isDown",
+    realm.method((_, args, v) => input.keyIsDown(code(args, v))),
+    FIXED,
+  );
+  key.define(
+    "isToggled",
+    realm.method((_, args, v) => input.keyToggled(code(args, v))),
+    FIXED,
+  );
+  key.define(
+    "getAscii",
+    realm.method(() => input.keyAscii),
+    FIXED,
+  );
+  key.define(
+    "getCode",
+    realm.method(() => input.keyCode),
+    FIXED,
+  );
+
+  return key;
+}
+
+/**
+ * `_global.Mouse`: show and hide give 1 where the pointer showed before
+ * the call, else 0, as adl gives them (Ruffle gives the opposite).
+ */
+export function mouseObject(
+  realm: avm1.Realm,
+  input: InputState,
+  version: number,
+): avm1.Avm1Object {
+  const mouse = new avm1.Avm1Object(realm.objectProto);
+  avm1.initializeBroadcaster(mouse, realm, version);
+  const showing = (shown: boolean) => () => {
+    const was = input.mouseShown;
+    input.mouseShown = shown;
+    return was ? 1 : 0;
+  };
+  mouse.define("show", realm.method(showing(true)), FIXED);
+  mouse.define("hide", realm.method(showing(false)), FIXED);
+
+  return mouse;
+}

package/src/avm1/globals/LoadVars.ts

@@ -0,0 +1,280 @@
+// LoadVars, AS1 and AS2's, and the loading it shares with XML, as Ruffle's
+// (https://github.com/ruffle-rs/ruffle) core/src/avm1/globals/load_vars.rs
+// and core/src/loader.rs (load_form_into_load_vars) have them: MIT OR
+// Apache-2.0, Copyright (c) 2018-2022 Ruffle LLC and Ruffle contributors.
+// A load sets the object's hidden _bytesLoaded, _bytesTotal and loaded
+// first; once the answer has come, between frames, it calls onHTTPStatus
+// with its status, then onData with its text, or with undefined where it
+// failed or was empty. LoadVars' onData decodes the text's variables onto
+// the object and calls onLoad.
+import { avm1 } from "@swf2es/runtime";
+import type { FetchResult } from "../../hosts.js";
+import { type Avm1Net, type NetRequest, textFor } from "../net.js";
+
+type Value = avm1.Value;
+type Obj = avm1.Avm1Object;
+
+/** What a load needs of the movie. */
+export interface LoadHost {
+  readonly realm: avm1.Realm;
+  readonly net: Avm1Net;
+  /** The SWF's version, which a load's callbacks run by. */
+  readonly version: number;
+  /** `o[name](...args)`, as a callback between frames runs it. */
+  callback(o: Obj, name: string, args: Value[]): void;
+  /** getURL's page: `url` in `window`, with `form`'s variables. */
+  navigate(url: string, window: string, form: avm1.UrlForm): void;
+}
+
+const HIDDEN = avm1.DONT_ENUM | avm1.DONT_DELETE;
+const FORM = "application/x-www-form-urlencoded";
+
+/** `name` on `o` as `value`: defined hidden where it has none, else set as a script would. */
+function setHidden(o: Obj, name: string, value: Value, version: number): void {
+  if (avm1.has(o, name, version)) {
+    avm1.set(o, name, value, version);
+  } else {
+    o.define(name, value, HIDDEN);
+  }
+}
+
+/** The text of a load's answer as Flash reads it: UTF-8, a BOM dropped, bad bytes replaced. */
+function textOf(bytes: Uint8Array): string {
+  return new TextDecoder().decode(bytes);
+}
+
+/** `request` loaded for `target`, by LoadVars' and XML's rules (above). */
+export function startLoad(
+  host: LoadHost,
+  target: Obj,
+  request: NetRequest,
+  version: number,
+  httpStatus = true,
+): void {
+  setHidden(target, "_bytesLoaded", 0, version);
+  setHidden(target, "_bytesTotal", undefined, version);
+  setHidden(target, "loaded", false, version);
+  host.net.fetch(request, (result: FetchResult) => {
+    const v = host.version;
+    const length = result.bytes?.length ?? 0;
+    if (result.bytes !== null) {
+      avm1.set(target, "_bytesTotal", length, v);
+      if (length > 0) {
+        avm1.set(target, "_bytesLoaded", length, v);
+      }
+    }
+
+    if (httpStatus) {
+      host.callback(target, "onHTTPStatus", [result.status]);
+    }
+
+    const data = result.bytes !== null && length > 0 ? textFor(textOf(result.bytes), v) : undefined;
+    host.callback(target, "onData", [data]);
+  });
+}
+
+/**
+ * URL-encoded variables, `a=1&b=2`, as name and value pairs in order,
+ * empty parts left out, each unescaped as unescape does (adl: `%zz` is `z`).
+ */
+export function parseForm(text: string, version: number): [string, string][] {
+  const pairs: [string, string][] = [];
+  for (const part of text.split("&")) {
+    if (part === "") {
+      continue;
+    }
+
+    const eq = part.indexOf("=");
+    const name = eq < 0 ? part : part.slice(0, eq);
+    const value = eq < 0 ? "" : part.slice(eq + 1);
+    pairs.push([avm1.unescapeAvm1(name, version), avm1.unescapeAvm1(value, version)]);
+  }
+
+  return pairs;
+}
+
+/**
+ * `o`'s variables as for..in lists them, each as a string; one whose
+ * getter throws is "undefined", as a form of them sends it.
+ */
+export function formVars(o: Obj, version: number): [string, string][] {
+  const vars: [string, string][] = [];
+  for (const name of avm1.keys(o, version)) {
+    let text: string;
+    try {
+      text = avm1.stringOf(avm1.get(o, name, version), version);
+    } catch (error) {
+      if (!(error instanceof avm1.Avm1Throw)) {
+        throw error;
+      }
+
+      text = "undefined";
+    }
+
+    vars.push([name, text]);
+  }
+
+  return vars;
+}
+
+/**
+ * A request for `url` with `vars`: in the query for a GET, after a `&`
+ * where the URL has a query already, or in a POST's body as a form's.
+ */
+export function formRequest(
+  url: string,
+  method: "GET" | "POST",
+  vars: [string, string][],
+  contentType = FORM,
+  headers: [string, string][] = [],
+): NetRequest {
+  const query = new URLSearchParams(vars).toString();
+  if (method === "GET") {
+    return {
+      url: `${url}${url.includes("?") ? "&" : "?"}${query}`,
+      method,
+      headers: [],
+      body: null,
+    };
+  }
+
+  return {
+    url,
+    method,
+    headers: [...headers, ["Content-Type", contentType]],
+    body: new TextEncoder().encode(query),
+  };
+}
+
+/** A method's name, "GET" in any case for a GET; anything else a POST. */
+function methodOf(value: Value, version: number): "GET" | "POST" {
+  return avm1.stringOf(value, version).toUpperCase() === "GET" ? "GET" : "POST";
+}
+
+/** The headers addRequestHeader gave a LoadVars or an XML, name and value. */
+const requestHeaders = new WeakMap<Obj, [string, string][]>();
+
+export function headersOf(o: Obj): [string, string][] {
+  return requestHeaders.get(o) ?? [];
+}
+
+/** addRequestHeader, LoadVars' and XML's: a name and a value, or an array of names and values. */
+export function addRequestHeader(self: Obj, args: Value[], version: number): Value {
+  const headers = requestHeaders.get(self) ?? [];
+  requestHeaders.set(self, headers);
+  const add = (name: Value, value: Value) => {
+    if (typeof name === "string" && typeof value === "string") {
+      headers.push([name, value]);
+    }
+  };
+  const list = args[0];
+  if (list instanceof avm1.Avm1Object && list.array) {
+    const length = avm1.toNumber(avm1.get(list, "length", version), version);
+    for (let i = 0; i + 1 < length; i += 2) {
+      add(avm1.get(list, String(i), version), avm1.get(list, String(i + 1), version));
+    }
+  } else {
+    add(args[0], args[1]);
+  }
+
+  return undefined;
+}
+
+/** `self[name](...args)` where it is a function. */
+function call(self: Obj, name: string, args: Value[], v: number): Value {
+  return avm1.invoke(avm1.get(self, name, v), self, args, v);
+}
+
+const FIXED = avm1.DONT_ENUM | avm1.DONT_DELETE;
+
+/** `_global.LoadVars`. */
+export function loadVarsClass(host: LoadHost): avm1.Avm1Function {
+  const realm = host.realm;
+  const proto = new avm1.Avm1Object(realm.objectProto);
+  const constr = realm.classOf(
+    proto,
+    (self) => self,
+    () => undefined,
+  );
+  const method = (name: string, fn: avm1.Native) => proto.define(name, realm.method(fn), FIXED);
+  const contentType = (self: Obj, v: number) => avm1.stringOf(avm1.get(self, "contentType", v), v);
+
+  method("load", (self, args, v) => {
+    if (args.length === 0) {
+      return false;
+    }
+
+    startLoad(
+      host,
+      self,
+      { url: avm1.stringOf(args[0], v), method: "GET", headers: [], body: null },
+      v,
+    );
+    return true;
+  });
+  method("send", (self, args, v) => {
+    if (args.length === 0) {
+      return false;
+    }
+
+    const url = avm1.stringOf(args[0], v);
+    const window = args.length > 1 ? avm1.stringOf(args[1], v) : "";
+    host.navigate(url, window, { method: methodOf(args[2], v), vars: formVars(self, v) });
+    return true;
+  });
+  method("sendAndLoad", (self, args, v) => {
+    const url = avm1.stringOf(args[0], v);
+    const target = args[1];
+    if (!(target instanceof avm1.Avm1Object)) {
+      return false;
+    }
+
+    const request = formRequest(
+      url,
+      methodOf(args[2], v),
+      formVars(self, v),
+      contentType(self, v),
+      headersOf(self),
+    );
+    startLoad(host, target, request, v);
+    return true;
+  });
+  method("decode", (self, args, v) => {
+    if (args.length === 0) {
+      return false;
+    }
+
+    for (const [name, value] of parseForm(avm1.stringOf(args[0], v), v)) {
+      avm1.set(self, name, value, v);
+    }
+
+    return undefined;
+  });
+  method("getBytesLoaded", (self, _, v) => avm1.get(self, "_bytesLoaded", v));
+  method("getBytesTotal", (self, _, v) => avm1.get(self, "_bytesTotal", v));
+  method("toString", (self, _, v) => {
+    const parts: string[] = [];
+    for (const name of avm1.keys(self, v)) {
+      const value = avm1.stringOf(avm1.get(self, name, v), v);
+      parts.push(`${avm1.escapeAvm1(name, v)}=${avm1.escapeAvm1(value, v)}`);
+    }
+
+    return parts.join("&");
+  });
+  proto.define("contentType", FORM, FIXED);
+  method("onLoad", () => undefined);
+  method("onData", (self, args, v) => {
+    const data = args[0];
+    const success = data !== undefined && data !== null;
+    if (success) {
+      call(self, "decode", [data], v);
+      avm1.set(self, "loaded", true, v);
+    }
+
+    call(self, "onLoad", [success], v);
+    return undefined;
+  });
+  method("addRequestHeader", (self, args, v) => addRequestHeader(self, args, v));
+
+  return constr;
+}