@swf2es/player-hosts 0.0.0-stage → 0.1.1

package/dist/thread/player/playerglobal/flash/events/GestureEvent.js

@@ -0,0 +1,34 @@
+// 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 "../../../../runtime/index.js";
+import { stagePoint } from "./MouseEvent.js";
+export function gestureEventNatives(s) {
+    const natives = {};
+    class GestureEventNatives {
+        updateAfterEvent() {
+            s.updates++;
+        }
+        get localX() {
+            return this.$gestureX ?? Number.NaN;
+        }
+        set localX(value) {
+            this.$gestureX = s.rt.toNumber(value);
+        }
+        get localY() {
+            return this.$gestureY ?? Number.NaN;
+        }
+        set localY(value) {
+            this.$gestureY = s.rt.toNumber(value);
+        }
+        "flash.events:GestureEvent::getStageX"(x, y) {
+            return stagePoint(s, this, x ?? this.$gestureX, y ?? this.$gestureY)[0];
+        }
+        "flash.events:GestureEvent::getStageY"(x, y) {
+            return stagePoint(s, this, x ?? this.$gestureX, y ?? this.$gestureY)[1];
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.events::GestureEvent", GestureEventNatives);
+    return natives;
+}

package/dist/thread/player/playerglobal/flash/events/HTTPStatusEvent.js

@@ -0,0 +1,8 @@
+export const httpStatusHooks = {
+    "flash.events::HTTPStatusEvent": {
+        setOnlySlots: {
+            responseURL: "$2",
+            responseHeaders: "$1",
+        },
+    },
+};

package/dist/thread/player/playerglobal/flash/events/KeyboardEvent.js

@@ -0,0 +1,51 @@
+// 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 "../../../../runtime/index.js";
+export function keyboardEventNatives(s) {
+    const natives = {};
+    class KeyboardEventNatives {
+        get charCode() {
+            return this.$charCode ?? 0;
+        }
+        set charCode(value) {
+            this.$charCode = s.rt.toUint(value);
+        }
+        get ctrlKey() {
+            return this.$ctrlKey ?? false;
+        }
+        set ctrlKey(value) {
+            this.$ctrlKey = !!value;
+        }
+        get altKey() {
+            return this.$altKey ?? false;
+        }
+        set altKey(value) {
+            this.$altKey = !!value;
+        }
+        get shiftKey() {
+            return this.$shiftKey ?? false;
+        }
+        set shiftKey(value) {
+            this.$shiftKey = !!value;
+        }
+        get commandKey() {
+            return this.$commandKey ?? false;
+        }
+        set commandKey(value) {
+            this.$commandKey = !!value;
+        }
+        updateAfterEvent() {
+            s.updates++;
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.events::KeyboardEvent", KeyboardEventNatives);
+    class TextEventNatives {
+        "flash.events:TextEvent::copyNativeData"(_from) {
+            // A text input's IME data, which the player has none of.
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.events::TextEvent", TextEventNatives);
+    return natives;
+}

package/dist/thread/player/playerglobal/flash/events/MouseEvent.js

@@ -0,0 +1,59 @@
+// 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 "../../../../runtime/index.js";
+import { toStage } from "../../../display/bounds.js";
+import { apply } from "../../../display/geometry.js";
+import { eventFields } from "../../../scripting/events.js";
+/**
+ * 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, event, x = Number.NaN, y = Number.NaN) {
+    const target = event[eventFields(s).target]?.$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) {
+    const natives = {};
+    class MouseEventNatives {
+        updateAfterEvent() {
+            s.updates++;
+        }
+        get localX() {
+            return this.$mouseX ?? Number.NaN;
+        }
+        set localX(value) {
+            this.$mouseX = s.rt.toNumber(value);
+        }
+        get localY() {
+            return this.$mouseY ?? Number.NaN;
+        }
+        set localY(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, y) {
+            return stagePoint(s, this, x ?? this.$mouseX, y ?? this.$mouseY)[0];
+        }
+        "flash.events:MouseEvent::getStageY"(x, y) {
+            return stagePoint(s, this, x ?? this.$mouseX, y ?? this.$mouseY)[1];
+        }
+        get movementX() {
+            return this.$movementX ?? 0;
+        }
+        set movementX(value) {
+            this.$movementX = s.rt.toNumber(value);
+        }
+        get movementY() {
+            return this.$movementY ?? 0;
+        }
+        set movementY(value) {
+            this.$movementY = s.rt.toNumber(value);
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.events::MouseEvent", MouseEventNatives);
+    return natives;
+}

package/dist/thread/player/playerglobal/flash/events/PressAndTapGestureEvent.js

@@ -0,0 +1,30 @@
+// 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 "../../../../runtime/index.js";
+import { stagePoint } from "./MouseEvent.js";
+export function pressAndTapGestureEventNatives(s) {
+    const natives = {};
+    class PressAndTapGestureEventNatives {
+        get tapLocalX() {
+            return this.$tapX ?? Number.NaN;
+        }
+        set tapLocalX(value) {
+            this.$tapX = s.rt.toNumber(value);
+        }
+        get tapLocalY() {
+            return this.$tapY ?? Number.NaN;
+        }
+        set tapLocalY(value) {
+            this.$tapY = s.rt.toNumber(value);
+        }
+        "flash.events:PressAndTapGestureEvent::getTapStageX"(x, y) {
+            return stagePoint(s, this, x ?? this.$tapX, y ?? this.$tapY)[0];
+        }
+        "flash.events:PressAndTapGestureEvent::getTapStageY"(x, y) {
+            return stagePoint(s, this, x ?? this.$tapX, y ?? this.$tapY)[1];
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.events::PressAndTapGestureEvent", PressAndTapGestureEventNatives);
+    return natives;
+}

package/dist/thread/player/playerglobal/flash/events/TimerEvent.js

@@ -0,0 +1,16 @@
+// 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 "../../../../runtime/index.js";
+export function timerEventNatives(s) {
+    const natives = {};
+    class TimerEventNatives {
+        updateAfterEvent() {
+            s.updates++;
+            s.timers.renderAsked = true;
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.events::TimerEvent", TimerEventNatives);
+    return natives;
+}

package/dist/thread/player/playerglobal/flash/events/TouchEvent.js

@@ -0,0 +1,45 @@
+// 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 "../../../../runtime/index.js";
+import { stagePoint } from "./MouseEvent.js";
+export function touchEventNatives(s) {
+    const natives = {};
+    class TouchEventNatives {
+        updateAfterEvent() {
+            s.updates++;
+        }
+        get localX() {
+            return this.$touchX ?? Number.NaN;
+        }
+        set localX(value) {
+            this.$touchX = s.rt.toNumber(value);
+        }
+        get localY() {
+            return this.$touchY ?? Number.NaN;
+        }
+        set localY(value) {
+            this.$touchY = s.rt.toNumber(value);
+        }
+        "flash.events:TouchEvent::getStageX"(x, y) {
+            return stagePoint(s, this, x ?? this.$touchX, y ?? this.$touchY)[0];
+        }
+        "flash.events:TouchEvent::getStageY"(x, y) {
+            return stagePoint(s, this, x ?? this.$touchX, y ?? this.$touchY)[1];
+        }
+        isToolButtonDown() {
+            return false;
+        }
+        getSamples() {
+            return 0;
+        }
+        "flash.events:TouchEvent::privateGetSamples"() {
+            return 0;
+        }
+        "flash.events:TouchEvent::setSamples"() { }
+    }
+    avm2.registerNativeClass(natives, "flash.events::TouchEvent", TouchEventNatives);
+    return natives;
+}

package/dist/thread/player/playerglobal/flash/external/ExternalInterface.js

@@ -0,0 +1,73 @@
+// playerglobal's private ExternalInterface natives use the optional host
+// given to Scripting. Without one, available is false and calls throw #2067.
+import { avm2 } from "../../../../runtime/index.js";
+export function externalInterfaceNatives(s) {
+    const 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() {
+            return bridge() !== null;
+        }
+        static get objectID() {
+            return bridge()?.objectID ?? null;
+        }
+        static "flash.external:ExternalInterface::_initJS"() {
+            // The host supplies the bridge; playerglobal's JavaScript shim needs no installation.
+        }
+        static "flash.external:ExternalInterface::_getPropNames"(object) {
+            const names = [];
+            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"() {
+            return false;
+        }
+        static "flash.external:ExternalInterface::_addCallback"(name, closure, remove) {
+            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) {
+            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) {
+            const host = bridge();
+            if (!host) {
+                throw s.rt.error("Error", 2067);
+            }
+            return host.callOut(s.rt.toString(request));
+        }
+        static "flash.external:ExternalInterface::_quotedStringFromString"(value) {
+            return JSON.stringify(s.rt.toString(value));
+        }
+        static "flash.external:ExternalInterface::_quotedStringFromError"(error) {
+            return JSON.stringify(s.rt.toString(error));
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.external::ExternalInterface", ExternalInterfaceNatives);
+    return natives;
+}

package/dist/thread/player/playerglobal/flash/filesystem/File.js

@@ -0,0 +1,340 @@
+// flash.filesystem.File over the host's FileSystemHost (hosts.ts), as adl
+// (AIR 51.3) has it: a native path and the URL that names it, under the
+// file system's root, the application's directory (app:/) or its storage's
+// (app-storage:/), which a File keeps as it resolves paths and goes up,
+// never climbing out of app:/. Relative paths are refused (ArgumentError
+// 2004), a File of no path is unusable (Error 2037), and what reads a file
+// that is not there fails (Error 3003). Reading what is there is
+// synchronous, as File's properties are; FileStream reads a file's bytes
+// (FileStream.ts). It makes and deletes directories and deletes, copies
+// and moves files and directories (writes.ts), at once or on the next
+// frame with an event, as the asynchronous methods do; dialogs are not
+// supported yet. Without a host, nothing is there.
+import { avm2 } from "../../../../runtime/index.js";
+import { dispatchEvent } from "../../../scripting/events.js";
+import { NativePaths } from "./paths.js";
+import { copyOrMove, createDirectory, deleteDirectory, deleteFile, ioErrorEvent, refuseApp, } from "./writes.js";
+/** The location of `o`, a File given a path; null for one of none, or a FileReference. */
+export function fileLocation(o) {
+    return o.$fileLocation ?? null;
+}
+/** What `name`, `size` and the dates of a File read: its name and what is there, null where nothing is. */
+export function fileEntry(s, o) {
+    const at = fileLocation(o);
+    if (!at) {
+        return null;
+    }
+    const paths = new NativePaths(s.fileSystem?.separator ?? "/");
+    return { name: paths.name(at.path), stat: s.fileSystem?.stat(at.path) ?? null };
+}
+/** A new File at the native path `path`, under the file system's root. */
+export function fileAt(s, path) {
+    const file = s.rt.construct(s.rt.classNamed("flash.filesystem::File"));
+    file.$fileLocation = { root: "file", path };
+    return file;
+}
+export function fileNatives(s) {
+    const natives = {};
+    const host = s.fileSystem;
+    const paths = new NativePaths(host?.separator ?? "/");
+    const fileClass = () => s.rt.classNamed("flash.filesystem::File");
+    /** The directory a root's URLs start from; null for the file system's. */
+    const floor = (root) => {
+        switch (root) {
+            case "app":
+                return host?.directories.application ?? null;
+            case "app-storage":
+                return host?.directories.applicationStorage ?? null;
+            default:
+                return null;
+        }
+    };
+    /** A new File at `at`. */
+    const make = (at) => {
+        const file = s.rt.construct(fileClass());
+        file.$fileLocation = at;
+        return file;
+    };
+    /** A directory AIR names, as a File; one the host does not have is refused. */
+    const named = (root, path) => {
+        if (!path) {
+            throw s.rt.error("Error", 2014);
+        }
+        return make({ root, path: paths.normalize(path) ?? path });
+    };
+    /** Where `o` is; Error 2037 for a File of no path. */
+    const locationOf = (o) => {
+        const at = fileLocation(o);
+        if (!at) {
+            throw s.rt.error("Error", 2037);
+        }
+        return at;
+    };
+    const refuse = () => {
+        throw s.rt.error("ArgumentError", 2004);
+    };
+    /** The location a native path or a file:, app: or app-storage: URL names; null for neither. */
+    const parse = (given) => {
+        const app = /^(app|app-storage):(.*)$/i.exec(given);
+        if (app) {
+            const root = app[1].toLowerCase();
+            const base = floor(root);
+            const segments = paths.urlSegments(app[2]);
+            if (!base || !segments) {
+                return null;
+            }
+            return { root, path: paths.resolve(base, segments.join(paths.separator), base) };
+        }
+        if (/^file:/i.test(given)) {
+            const path = paths.fromFileUrl(given);
+            return path ? { root: "file", path } : null;
+        }
+        if (/^[a-z][a-z0-9+.-]*:\/\//i.test(given)) {
+            return null;
+        }
+        const path = paths.normalize(given);
+        return path ? { root: "file", path } : null;
+    };
+    /** Throws the IOError `id`, unless it is 0. */
+    const check = (id) => {
+        if (id) {
+            throw s.rt.error("flash.errors::IOError", id);
+        }
+    };
+    /** `file`'s location, to be written: a SecurityError for one of the app: URL. */
+    const writable = (file) => {
+        if (file === null || file === undefined) {
+            throw s.rt.error("TypeError", 2007, "newLocation");
+        }
+        const at = locationOf(file);
+        refuseApp(s, at);
+        return at;
+    };
+    /** Runs `change` on the next frame, then tells `file` complete, or ioError for the IOError it gives. */
+    const later = (file, change) => {
+        s.loads.deferHostEvent(() => {
+            const id = change();
+            dispatchEvent(s, file, id ? ioErrorEvent(s, id) : s.event("complete"));
+        });
+    };
+    /** What is at `at`; Error 3003 where nothing is. */
+    const there = (at) => {
+        const stat = host?.stat(at.path);
+        if (!stat) {
+            throw s.rt.error("Error", 3003);
+        }
+        return stat;
+    };
+    class FileNatives {
+        static get systemCharset() {
+            return "utf-8";
+        }
+        static get separator() {
+            return paths.separator;
+        }
+        static get lineEnding() {
+            return paths.separator === "\\" ? "\r\n" : "\n";
+        }
+        static get applicationDirectory() {
+            return named("app", host?.directories.application);
+        }
+        static get applicationStorageDirectory() {
+            return named("app-storage", host?.directories.applicationStorage);
+        }
+        static get userDirectory() {
+            return named("file", host?.directories.user);
+        }
+        static get documentsDirectory() {
+            return named("file", host?.directories.documents);
+        }
+        static get desktopDirectory() {
+            return named("file", host?.directories.desktop);
+        }
+        static get cacheDirectory() {
+            return named("file", host?.directories.cache);
+        }
+        static getRootDirectories() {
+            const roots = new Set();
+            for (const dir of Object.values(host?.directories ?? {})) {
+                let at = dir ? paths.normalize(dir) : null;
+                while (at && paths.parent(at) !== null) {
+                    at = paths.parent(at);
+                }
+                if (at) {
+                    roots.add(at);
+                }
+            }
+            return s.rt.array([...roots].map((path) => make({ root: "file", path })));
+        }
+        static createTempFile() {
+            throw s.rt.unsupported("File.createTempFile");
+        }
+        static createTempDirectory() {
+            throw s.rt.unsupported("File.createTempDirectory");
+        }
+        "flash.filesystem:File::_init"(given) {
+            this.$fileLocation = parse(String(given)) ?? refuse();
+        }
+        toString() {
+            return "[object File]";
+        }
+        get exists() {
+            return !!host?.stat(locationOf(this).path);
+        }
+        get isDirectory() {
+            return host?.stat(locationOf(this).path)?.directory ?? false;
+        }
+        get isHidden() {
+            return host?.stat(locationOf(this).path)?.hidden ?? false;
+        }
+        get isSymbolicLink() {
+            return host?.stat(locationOf(this).path)?.symbolicLink ?? false;
+        }
+        get isPackage() {
+            locationOf(this);
+            return false;
+        }
+        resolvePath(given) {
+            const at = locationOf(this);
+            const text = String(given ?? "");
+            // A File's URL or an absolute path names its own place, whatever this File's is; "a:b" is
+            // a name, as on a system that allows a colon in one.
+            if (/^(file|app|app-storage):/i.test(text) && !paths.isAbsolute(text)) {
+                return make(parse(text) ?? refuse());
+            }
+            if (paths.isAbsolute(text)) {
+                return make({ root: "file", path: paths.normalize(text) });
+            }
+            return make({ root: at.root, path: paths.resolve(at.path, text, floor(at.root)) });
+        }
+        getRelativePath(ref, useDotDot) {
+            const from = locationOf(this).path;
+            const to = locationOf(ref).path;
+            const below = paths.under(to, from);
+            if (below) {
+                return below.join("/");
+            }
+            if (!useDotDot) {
+                return null;
+            }
+            // Up to the nearest directory both are in, then down.
+            let common = from;
+            let ups = 0;
+            while (common !== null && !paths.under(to, common)) {
+                common = paths.parent(common);
+                ups++;
+            }
+            if (common === null) {
+                return null;
+            }
+            return [...Array(ups).fill(".."), ...paths.under(to, common)].join("/");
+        }
+        get parent() {
+            const at = locationOf(this);
+            const base = floor(at.root);
+            // The application's directory and its storage's have none, as adl's.
+            if (base !== null && paths.under(base, at.path)) {
+                return null;
+            }
+            const up = paths.parent(at.path);
+            return up === null ? null : make({ root: at.root, path: up });
+        }
+        get nativePath() {
+            return locationOf(this).path;
+        }
+        set nativePath(v) {
+            const path = paths.normalize(String(v ?? ""));
+            this.$fileLocation = path ? { root: "file", path } : refuse();
+        }
+        canonicalize() {
+            locationOf(this);
+        }
+        get url() {
+            const at = locationOf(this);
+            const base = floor(at.root);
+            if (base !== null) {
+                const below = paths.under(at.path, base) ?? [];
+                return `${at.root}:/${below.map(encodeURIComponent).join("/")}`;
+            }
+            return paths.fileUrl(at.path);
+        }
+        set url(v) {
+            const text = String(v ?? "");
+            const at = /^(file|app|app-storage):/i.test(text) ? parse(text) : null;
+            this.$fileLocation = at ?? refuse();
+        }
+        getDirectoryListing() {
+            const at = locationOf(this);
+            const stat = there(at);
+            if (!stat.directory) {
+                throw s.rt.error("Error", 3007);
+            }
+            const names = host?.list(at.path) ?? [];
+            return s.rt.array(names.map((name) => make({ root: at.root, path: paths.resolve(at.path, name, null) })));
+        }
+        getDirectoryListingAsync() {
+            const at = locationOf(this);
+            s.loads.deferHostEvent(() => {
+                const stat = host?.stat(at.path);
+                if (!stat?.directory) {
+                    dispatchEvent(s, this, ioErrorEvent(s, stat ? 3007 : 3003));
+                    return;
+                }
+                const files = (host?.list(at.path) ?? []).map((name) => make({ root: at.root, path: paths.resolve(at.path, name, null) }));
+                dispatchEvent(s, this, s.rt.construct(s.rt.classNamed("flash.events::FileListEvent"), "directoryListing", false, false, s.rt.array(files)));
+            });
+        }
+        createDirectory() {
+            check(createDirectory(s, writable(this).path));
+        }
+        deleteFile() {
+            check(deleteFile(s, writable(this).path));
+        }
+        deleteFileAsync() {
+            const at = writable(this);
+            later(this, () => deleteFile(s, at.path));
+        }
+        deleteDirectory(contents = false) {
+            check(deleteDirectory(s, writable(this).path, !!contents));
+        }
+        deleteDirectoryAsync(contents = false) {
+            const at = writable(this);
+            later(this, () => deleteDirectory(s, at.path, !!contents));
+        }
+        copyTo(to, overwrite = false) {
+            const from = locationOf(this);
+            check(copyOrMove(s, from.path, writable(to).path, !!overwrite, false));
+        }
+        copyToAsync(to, overwrite = false) {
+            const from = locationOf(this);
+            const into = writable(to);
+            later(this, () => copyOrMove(s, from.path, into.path, !!overwrite, false));
+        }
+        moveTo(to, overwrite = false) {
+            const from = writable(this);
+            check(copyOrMove(s, from.path, writable(to).path, !!overwrite, true));
+        }
+        moveToAsync(to, overwrite = false) {
+            const from = writable(this);
+            const into = writable(to);
+            later(this, () => copyOrMove(s, from.path, into.path, !!overwrite, true));
+        }
+        clone() {
+            return make({ ...locationOf(this) });
+        }
+        cancel() { }
+        get icon() {
+            return null;
+        }
+        get downloaded() {
+            return false;
+        }
+        set downloaded(_v) { }
+        get preventBackup() {
+            return false;
+        }
+        set preventBackup(_v) { }
+    }
+    avm2.registerNativeClass(natives, "flash.filesystem::File", FileNatives);
+    return natives;
+}