@swf2es/player-hosts 0.0.0-stage → 0.1.1

package/dist/thread/player/playerglobal/flash/desktop/NativeApplication.js

@@ -0,0 +1,179 @@
+// flash.desktop.NativeApplication, AIR's one application object, over the
+// host's AirApplication (hosts.ts): its descriptor, its window and its
+// launch, which adl hands each InvokeEvent listener once it listens. A
+// listener added in the document class's constructor has it before the
+// first frame's ENTER_FRAME; one added in a frame's scripts, at that
+// frame's end; each once, those that had it before not again, with the
+// directory it was launched from as a File. Without a host the application
+// has no window and was launched with no arguments, from nowhere.
+// What the values are where no host says: adl's (AIR 51.3).
+import { avm2 } from "../../../../runtime/index.js";
+import { dispatchEvent, dispatchToListener } from "../../../scripting/events.js";
+import { nativeWindowOf } from "../display/NativeWindow.js";
+import { addListener, removeListener } from "../events/EventDispatcher.js";
+import { fileAt } from "../filesystem/File.js";
+/** NativeApplication.runtimeVersion, and its patch level: the AIR these natives follow. */
+export const AIR_RUNTIME_VERSION = "51.3.1.2";
+const AIR_PATCH_LEVEL = 2;
+const INVOKE = "invoke";
+export function nativeApplicationNatives(s) {
+    const natives = {};
+    let application = null;
+    /** InvokeEvent listeners added since the launch was last handed out, in the order added. */
+    const awaiting = [];
+    let autoExit = true;
+    let idleThreshold = 300;
+    let systemIdleMode = "normal";
+    let executeInBackground = false;
+    /** The launch, to each listener added since it was last handed out, at the frame's end. */
+    const handOut = () => {
+        const app = application;
+        const listening = app.$listeners?.get(INVOKE) ?? [];
+        for (const fn of awaiting.splice(0)) {
+            // Taken off again before the frame ended, it hears nothing.
+            if (!listening.some((l) => l.fn === fn && !l.capture)) {
+                continue;
+            }
+            const event = s.rt.construct(s.rt.classNamed("flash.events::InvokeEvent"), INVOKE, false, false, s.application?.currentDirectory ? fileAt(s, s.application.currentDirectory) : null, s.rt.array([...(s.application?.arguments ?? [])]), "standard");
+            dispatchToListener(s, app, event, fn);
+        }
+    };
+    class NativeApplicationNatives {
+        static get nativeApplication() {
+            application ??= s.rt.construct(s.rt.classNamed("flash.desktop::NativeApplication"));
+            return application;
+        }
+        // A browser's or Electron's window has no menu, dock or tray of AIR's.
+        static get supportsMenu() {
+            return false;
+        }
+        static get supportsDockIcon() {
+            return false;
+        }
+        static get supportsSystemTrayIcon() {
+            return false;
+        }
+        static get supportsDefaultApplication() {
+            return false;
+        }
+        static get supportsStartAtLogin() {
+            return false;
+        }
+        addEventListener(type, fn, useCapture, priority) {
+            const added = addListener(s, this, type, fn, useCapture, priority);
+            if (added && type === INVOKE && !useCapture) {
+                if (awaiting.length === 0) {
+                    s.afterExitFrame.push(handOut);
+                }
+                awaiting.push(fn);
+            }
+        }
+        removeEventListener(type, fn, useCapture) {
+            removeListener(s, this, type, fn, useCapture);
+        }
+        dispatchEvent(event) {
+            return dispatchEvent(s, this, event);
+        }
+        exit(code) {
+            s.application?.exit?.(Number(code) | 0);
+        }
+        get runtimeVersion() {
+            return AIR_RUNTIME_VERSION;
+        }
+        get runtimePatchLevel() {
+            return AIR_PATCH_LEVEL;
+        }
+        get applicationID() {
+            return s.application?.id ?? "";
+        }
+        get publisherID() {
+            return "";
+        }
+        get applicationDescriptor() {
+            const text = s.application?.descriptor;
+            return text ? s.rt.constructClass(s.rt.builtinClass("XML"), [text]) : null;
+        }
+        get menu() {
+            return null;
+        }
+        set menu(_v) { }
+        get icon() {
+            return null;
+        }
+        get autoExit() {
+            return autoExit;
+        }
+        set autoExit(v) {
+            autoExit = !!v;
+        }
+        get idleThreshold() {
+            return idleThreshold;
+        }
+        set idleThreshold(v) {
+            idleThreshold = Number(v) | 0;
+        }
+        get timeSinceLastUserInput() {
+            return 0;
+        }
+        get systemIdleMode() {
+            return systemIdleMode;
+        }
+        set systemIdleMode(v) {
+            systemIdleMode = String(v);
+        }
+        get executeInBackground() {
+            return executeInBackground;
+        }
+        set executeInBackground(v) {
+            executeInBackground = !!v;
+        }
+        // adl refuses it, being no installed application; so does a host.
+        get startAtLogin() {
+            throw s.rt.error("Error", 2014);
+        }
+        set startAtLogin(_v) {
+            throw s.rt.error("Error", 2014);
+        }
+        get activeWindow() {
+            const window = nativeWindowOf(s);
+            return window && s.application?.window?.active() ? window : null;
+        }
+        get openedWindows() {
+            const window = nativeWindowOf(s);
+            return s.rt.array(window ? [window] : []);
+        }
+        activate(_window) {
+            s.application?.window?.activate?.();
+        }
+        // The edit commands go to the focused text, which the player's keyboard handles itself.
+        copy() {
+            return false;
+        }
+        cut() {
+            return false;
+        }
+        paste() {
+            return false;
+        }
+        clear() {
+            return false;
+        }
+        selectAll() {
+            return false;
+        }
+        getDefaultApplication(_extension) {
+            return null;
+        }
+        isSetAsDefaultApplication(_extension) {
+            return false;
+        }
+        setAsDefaultApplication(_extension) {
+            throw s.rt.error("Error", 2014);
+        }
+        removeAsDefaultApplication(_extension) {
+            throw s.rt.error("Error", 2014);
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.desktop::NativeApplication", NativeApplicationNatives);
+    return natives;
+}

package/dist/thread/player/playerglobal/flash/display/AVM1Movie.js

@@ -0,0 +1,19 @@
+// flash.display.AVM1Movie: an AVM1 SWF's root as an AS3 Loader's content
+// (Loads.requestLoad), a display object AS3 cannot script into. Its
+// `call` and `addCallback` are playerglobal's own code, which throws Error
+// #2014 while interop is unavailable; with no AVM1 interpreter it always
+// is, so nothing ever crosses to the AVM1 side.
+import { avm2 } from "../../../../runtime/index.js";
+export function avm1MovieNatives() {
+    const natives = {};
+    class AVM1MovieNatives {
+        get "flash.display:AVM1Movie::_interopAvailable"() {
+            return false;
+        }
+        "flash.display:AVM1Movie::_callAS2"() { }
+        // Its constructor hands over the closure an AVM1 call would reach AS3 by; no AVM1 code calls it.
+        "flash.display:AVM1Movie::_setCallAS3"() { }
+    }
+    avm2.registerNativeClass(natives, "flash.display::AVM1Movie", AVM1MovieNatives);
+    return natives;
+}

package/dist/thread/player/playerglobal/flash/display/Bitmap.js

@@ -0,0 +1,58 @@
+// flash.display.Bitmap: a display object showing a BitmapData, its node a
+// BitmapObject (display/display.ts) that the renderer draws as a textured sprite.
+import { avm2 } from "../../../../runtime/index.js";
+import { CONTENT } from "../../../display/display.js";
+export function bitmapNatives(s) {
+    const natives = {};
+    // A native runs with the AS3 object as `this`, so the constructor sets
+    // what the setters set through the same helpers, not through them.
+    const setData = (o, v) => {
+        const data = v === null || v === undefined ? null : v;
+        o.$bitmapData = data;
+        const display = o.$display;
+        display.store = data?.$store ?? null;
+        display.invalidate(CONTENT);
+    };
+    const setSnapping = (o, v) => {
+        const mode = v === null || v === undefined ? "auto" : s.rt.toString(v);
+        if (mode !== "auto" && mode !== "always" && mode !== "never") {
+            throw s.rt.error("ArgumentError", 2008, "pixelSnapping");
+        }
+        o.$display.pixelSnapping = mode;
+    };
+    const setSmoothing = (o, v) => {
+        const display = o.$display;
+        display.smoothing = !!v;
+        display.invalidate(CONTENT);
+    };
+    class BitmapNatives {
+        "flash.display:Bitmap::ctor"(bitmapData, pixelSnapping, smoothing) {
+            // One of a bitmap's class, or placed by a timeline, shows a new BitmapData of its pixels.
+            const character = this.$display.character;
+            const none = bitmapData === null || bitmapData === undefined;
+            setData(this, none && character ? s.symbols.bitmapDataOf(character) : bitmapData);
+            setSnapping(this, pixelSnapping);
+            setSmoothing(this, smoothing);
+        }
+        get bitmapData() {
+            return this.$bitmapData ?? null;
+        }
+        set bitmapData(v) {
+            setData(this, v);
+        }
+        get pixelSnapping() {
+            return this.$display.pixelSnapping;
+        }
+        set pixelSnapping(v) {
+            setSnapping(this, v);
+        }
+        get smoothing() {
+            return this.$display.smoothing;
+        }
+        set smoothing(v) {
+            setSmoothing(this, v);
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.display::Bitmap", BitmapNatives);
+    return natives;
+}