@afterswf/playerglobal 0.0.0-stage → 0.2.460

package/dist/lib/events/UncaughtErrorEvents.js

@@ -0,0 +1,29 @@
+import { __extends } from "tslib";
+import { EventDispatcher } from './EventDispatcher';
+/**
+ * Copyright 2014 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+// Class: UncaughtErrorEvents
+var UncaughtErrorEvents = /** @class */ (function (_super) {
+    __extends(UncaughtErrorEvents, _super);
+    function UncaughtErrorEvents() {
+        return _super.call(this) || this;
+    }
+    UncaughtErrorEvents.classInitializer = null;
+    UncaughtErrorEvents.classSymbols = null;
+    UncaughtErrorEvents.instanceSymbols = null;
+    return UncaughtErrorEvents;
+}(EventDispatcher));
+export { UncaughtErrorEvents };

package/dist/lib/events/VideoEvent.d.ts

@@ -0,0 +1,13 @@
+import { Event } from './Event';
+export declare class VideoEvent extends Event {
+    static classInitializer: any;
+    static classSymbols: string[];
+    static instanceSymbols: string[];
+    status: string;
+    constructor(type: string, bubbles?: boolean, cancelable?: boolean, status?: string);
+    static RENDER_STATE: string;
+    static RENDER_STATUS_UNAVAILABLE: string;
+    static RENDER_STATUS_SOFTWARE: string;
+    static RENDER_STATUS_ACCELERATED: string;
+}
+//# sourceMappingURL=VideoEvent.d.ts.map

package/dist/lib/events/VideoEvent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VideoEvent.d.ts","sourceRoot":"","sources":["../../../lib/events/VideoEvent.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,qBAAa,UAAW,SAAQ,KAAK;IAEpC,MAAM,CAAC,gBAAgB,EAAE,GAAG,CAAQ;IAEpC,MAAM,CAAC,YAAY,EAAE,MAAM,EAAG,CAAQ;IACtC,MAAM,CAAC,eAAe,EAAE,MAAM,EAAG,CAAQ;IAEzC,MAAM,EAAE,MAAM,CAAC;gBAEH,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,OAAe,EAAE,UAAU,GAAE,OAAe,EAC9E,MAAM,GAAE,MAAa;IAMtB,MAAM,CAAC,YAAY,EAAE,MAAM,CAAiB;IAC5C,MAAM,CAAC,yBAAyB,EAAE,MAAM,CAAiB;IACzD,MAAM,CAAC,sBAAsB,EAAE,MAAM,CAAc;IACnD,MAAM,CAAC,yBAAyB,EAAE,MAAM,CAAiB;CACzD"}

package/dist/lib/events/VideoEvent.js

@@ -0,0 +1,24 @@
+import { __extends } from "tslib";
+import { axCoerceString } from '@awayfl/avm2';
+import { Event } from './Event';
+var VideoEvent = /** @class */ (function (_super) {
+    __extends(VideoEvent, _super);
+    function VideoEvent(type, bubbles, cancelable, status) {
+        if (bubbles === void 0) { bubbles = false; }
+        if (cancelable === void 0) { cancelable = false; }
+        if (status === void 0) { status = null; }
+        var _this = _super.call(this, type, bubbles, cancelable) || this;
+        _this.status = axCoerceString(status);
+        return _this;
+    }
+    VideoEvent.classInitializer = null;
+    VideoEvent.classSymbols = null;
+    VideoEvent.instanceSymbols = null;
+    // JS -> AS Bindings
+    VideoEvent.RENDER_STATE = 'renderState';
+    VideoEvent.RENDER_STATUS_UNAVAILABLE = 'unavailable';
+    VideoEvent.RENDER_STATUS_SOFTWARE = 'software';
+    VideoEvent.RENDER_STATUS_ACCELERATED = 'accelerated';
+    return VideoEvent;
+}(Event));
+export { VideoEvent };

package/dist/lib/external/ExternalInterface.d.ts

@@ -0,0 +1,27 @@
+import { ASObject, ASXML, AXFunction } from '@awayfl/avm2';
+export declare class ExternalInterface extends ASObject {
+    static classInitializer: any;
+    constructor();
+    static $BgmarshallExceptions: boolean;
+    private static initialized;
+    private static registeredCallbacks;
+    static ensureInitialized(): void;
+    static call(functionName: string): any;
+    static addCallback(functionName: string, closure: AXFunction): void;
+    static get available(): boolean;
+    static get objectID(): string;
+    static _addCallback(functionName: string, closure: Function): void;
+    static _removeCallback(functionName: string): void;
+    static _evalJS(expression: string): string;
+    private static _callIn;
+    static _callOut(request: string): string;
+    static convertToXML(s: String): ASXML;
+    static convertToXMLString(obj: any): String;
+    static convertFromXML(xml: any): any;
+    /**
+     * Converts an AS value into a JS value, for callbacks that JS calls directly
+     */
+    static convertToJS(obj: any): any;
+    static convertToJSString(obj: any): string;
+}
+//# sourceMappingURL=ExternalInterface.d.ts.map

package/dist/lib/external/ExternalInterface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExternalInterface.d.ts","sourceRoot":"","sources":["../../../lib/external/ExternalInterface.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAU,UAAU,EACK,MAAM,cAAc,CAAC;AACtE,qBAAa,iBAAkB,SAAQ,QAAQ;IAE9C,MAAM,CAAC,gBAAgB,EAAE,GAAG,CAAQ;;IAMpC,MAAM,CAAC,qBAAqB,EAAE,OAAO,CAAC;IAEtC,OAAO,CAAC,MAAM,CAAC,WAAW,CAAkB;IAC5C,OAAO,CAAC,MAAM,CAAC,mBAAmB,CAAgC;IAElE,MAAM,CAAC,iBAAiB,IAAI,IAAI;IAWhC,MAAM,CAAC,IAAI,CAAC,YAAY,EAAE,MAAM;IAwBhC,MAAM,CAAC,WAAW,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,GAAG,IAAI;IA8DnE,MAAM,KAAK,SAAS,IAAI,OAAO,CAE9B;IAED,MAAM,KAAK,QAAQ,IAAI,MAAM,CAE5B;IAED,MAAM,CAAC,YAAY,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,GAAG,IAAI;IAKlE,MAAM,CAAC,eAAe,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI;IAKlD,MAAM,CAAC,OAAO,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM;IAK1C,OAAO,CAAC,MAAM,CAAC,OAAO;IAQtB,MAAM,CAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IAKxC,MAAM,CAAC,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,KAAK;IASrC,MAAM,CAAC,kBAAkB,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM;IA6C3C,MAAM,CAAC,cAAc,CAAC,GAAG,EAAE,GAAG,GAA2B,GAAG;IAqC5D;;OAEG;IACH,MAAM,CAAC,WAAW,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG;IAqBjC,MAAM,CAAC,iBAAiB,CAAC,GAAG,KAAA,GAAG,MAAM;CA6BrC"}

package/dist/lib/external/ExternalInterface.js

@@ -0,0 +1,298 @@
+import { __extends } from "tslib";
+import { ExternalInterfaceService } from '@awayfl/swf-loader';
+import { ASObject, Errors, axCoerceString, Multiname } from '@awayfl/avm2';
+var ExternalInterface = /** @class */ (function (_super) {
+    __extends(ExternalInterface, _super);
+    function ExternalInterface() {
+        return _super.call(this) || this;
+    }
+    ExternalInterface.ensureInitialized = function () {
+        if (!this.available) {
+            this.sec.throwError('Error', Errors.ExternalInterfaceNotAvailableError);
+        }
+        if (this.initialized) {
+            return;
+        }
+        this.initialized = true;
+        ExternalInterfaceService.initJS(this._callIn);
+    };
+    ExternalInterface.call = function (functionName) {
+        this.ensureInitialized();
+        var argsExpr = '';
+        if (arguments.length > 1) {
+            var args = [];
+            for (var i = 1; i < arguments.length; i++) {
+                args.push(this.convertToJSString(arguments[i]));
+            }
+            argsExpr = args.join(',');
+        }
+        var catchExpr = this.$BgmarshallExceptions ?
+            '"<exception>" + e + "</exception>";' :
+            '"<undefined/>";';
+        var evalExpr = 'try {'
+            + ExternalInterfaceService.interfaceID
+            + '.__flash__toXML(' + functionName + '(' + argsExpr + '));'
+            + '} catch (e) {' + catchExpr + '}';
+        var result = this._evalJS(evalExpr);
+        if (result == null) {
+            return null;
+        }
+        return this.convertFromXML(this.convertToXML(result));
+    };
+    ExternalInterface.addCallback = function (functionName, closure) {
+        var _this = this;
+        this.ensureInitialized();
+        if (!closure) {
+            this._removeCallback(functionName);
+            return;
+        }
+        var self = this;
+        this._addCallback(functionName, function (request, args) {
+            var returnAsJS = true;
+            var calledFromJS = Array.isArray(args);
+            if (typeof args !== 'undefined') {
+                if (Array.isArray(args)) {
+                    var wrappedArgs = [];
+                    for (var i = 0; i < args.length; i++) {
+                        var arg = args[i];
+                        // Objects have to be converted into proper AS objects in the current security domain.
+                        if (typeof arg === 'object' && arg) {
+                            if (Array.isArray(arg))
+                                wrappedArgs.push(self.sec.createArray(arg));
+                            else
+                                wrappedArgs.push(self.sec.createObjectFromJS(arg, true));
+                        }
+                        else {
+                            wrappedArgs.push(arg);
+                        }
+                    }
+                    args = wrappedArgs;
+                }
+                else {
+                    args = [args];
+                }
+            }
+            else {
+                var xml = _this.convertToXML(request);
+                var returnTypeAttr = xml.attribute('returntype');
+                returnAsJS = returnTypeAttr && returnTypeAttr._value == 'javascript';
+                args = [];
+                if (xml._children) {
+                    for (var i = 0; i < xml._children.length; i++) {
+                        var x = xml._children[i];
+                        args.push(_this.convertFromXML(x));
+                    }
+                }
+            }
+            var result;
+            try {
+                result = closure.axApply(null, args);
+            }
+            catch (e) {
+                if (_this.$BgmarshallExceptions) {
+                    result = e;
+                }
+                else {
+                    throw e;
+                }
+            }
+            if (calledFromJS) {
+                return self.convertToJS(result);
+            }
+            return returnAsJS ? self.convertToJSString(result) : self.convertToXMLString(result);
+        });
+    };
+    Object.defineProperty(ExternalInterface, "available", {
+        get: function () {
+            return ExternalInterfaceService.enabled;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ExternalInterface, "objectID", {
+        get: function () {
+            return ExternalInterfaceService.getId();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ExternalInterface._addCallback = function (functionName, closure) {
+        ExternalInterfaceService.registerCallback(functionName);
+        ExternalInterface.registeredCallbacks[functionName] = closure;
+    };
+    ExternalInterface._removeCallback = function (functionName) {
+        ExternalInterfaceService.unregisterCallback(functionName);
+        delete ExternalInterface.registeredCallbacks[functionName];
+    };
+    ExternalInterface._evalJS = function (expression) {
+        expression = axCoerceString(expression);
+        return ExternalInterfaceService.eval(expression);
+    };
+    ExternalInterface._callIn = function (functionName, args) {
+        var callback = ExternalInterface.registeredCallbacks[functionName];
+        if (!callback) {
+            return;
+        }
+        return callback(functionName, args);
+    };
+    ExternalInterface._callOut = function (request) {
+        request = axCoerceString(request);
+        return ExternalInterfaceService.call(request);
+    };
+    ExternalInterface.convertToXML = function (s) {
+        var xmlClass = this.sec.system.getClass(Multiname.FromSimpleName('XML'));
+        var savedIgnoreWhitespace = xmlClass.ignoreWhitespace;
+        xmlClass.ignoreWhitespace = false;
+        var xml = xmlClass.Create(s);
+        xmlClass.ignoreWhitespace = savedIgnoreWhitespace;
+        return xml;
+    };
+    ExternalInterface.convertToXMLString = function (obj) {
+        switch (typeof obj) {
+            case 'boolean':
+                return obj ? '<true/>' : '<false/>';
+            case 'number':
+                return '<number>' + obj + '</number>';
+            case 'string':
+                return '<string>' + obj.split('&').join('&amp;').split('<').join('&lt;').
+                    split('>').join('&gt;') + '</string>';
+            case 'object':
+                if (obj === null) {
+                    return '<null/>';
+                }
+                if (this.sec.AXDate.axIsInstanceOf(obj)) {
+                    return '<date>' + obj.time + '</date>';
+                }
+                if (this.sec.AXError.axIsInstanceOf(obj)) {
+                    if (this.$BgmarshallExceptions) {
+                        return '<exception>' + obj + '</exception>';
+                    }
+                    else {
+                        return '<null/>'; // not sure?
+                    }
+                }
+                var result = [];
+                // Looks like length is used to detect array. (obj is Array) is better?
+                if (obj.hasOwnProperty('$Bglength')) {
+                    var len = obj.$Bglength;
+                    for (var i = 0; i < len; i++) {
+                        var entry = this.convertToXMLString(obj.axGetNumericProperty(i));
+                        result.push('<property id="' + i + '">' + entry + '</property>');
+                    }
+                    return '<array>' + result.join('') + '</array>';
+                }
+                var keys = obj.axGetEnumerableKeys();
+                for (var i = 0; i < keys.length; i++) {
+                    var key = keys[i];
+                    var entry = this.convertToXMLString(obj.axGetPublicProperty(key));
+                    result.push('<property id="' + key + '">' + entry + '</property>');
+                }
+                return '<object>' + result.join('') + '</object>';
+            default:
+                return '<undefined/>';
+        }
+    };
+    ExternalInterface.convertFromXML = function (xml /* ASXML | ASXMLList */) {
+        switch (xml._name.name) {
+            case 'true':
+                return true;
+            case 'false':
+                return false;
+            case 'number':
+                return Number(String(xml.children()));
+            case 'string':
+                return String(xml.children());
+            case 'null':
+                return null;
+            case 'date':
+                return this.sec.AXDate.axConstruct([Number(String(xml.children()))]);
+            case 'exception':
+                if (this.$BgmarshallExceptions) {
+                    throw this.sec.AXError.axConstruct([String(xml.children())]);
+                }
+                return undefined;
+            case 'array':
+            case 'object':
+                var obj = xml._name.name === 'object' ?
+                    this.sec.createObject() :
+                    this.sec.createArrayUnsafe([]);
+                for (var i = 0; i < xml._children.length; i++) {
+                    var x = xml._children[i];
+                    obj.axSetPublicProperty(extractId(x), this.convertFromXML(x._children[0]));
+                }
+                return obj;
+            case 'class':
+                var className = Multiname.FromFQNString(String(xml.children()), 0 /* NamespaceType.Public */);
+                return this.sec.application.getClass(className);
+            default:
+                return undefined;
+        }
+    };
+    /**
+     * Converts an AS value into a JS value, for callbacks that JS calls directly
+     */
+    ExternalInterface.convertToJS = function (obj) {
+        var _this = this;
+        if (typeof obj !== 'object' || obj === null) {
+            return obj;
+        }
+        if (this.sec.AXArray.axIsInstanceOf(obj)) {
+            return obj.value.map(function (value) { return _this.convertToJS(value); });
+        }
+        if (this.sec.AXDate.axIsInstanceOf(obj)) {
+            return new Date(+obj.value);
+        }
+        if (this.$BgmarshallExceptions && (this.sec.AXError.axIsInstanceOf(obj))) {
+            throw new Error(String(obj));
+        }
+        var result = {};
+        var keys = obj.axGetEnumerableKeys();
+        for (var i = 0; i < keys.length; i++) {
+            result[keys[i]] = this.convertToJS(obj.axGetPublicProperty(keys[i]));
+        }
+        return result;
+    };
+    ExternalInterface.convertToJSString = function (obj) {
+        if (typeof obj == 'string') {
+            return JSON.stringify(obj);
+        }
+        if (this.sec.AXArray.axIsInstanceOf(obj)) {
+            var parts = [];
+            var arr = obj.value;
+            for (var i = 0; i < arr.length; i++) {
+                parts.push(this.convertToJSString(arr[i]));
+            }
+            return '[' + parts.join(',') + ']';
+        }
+        if (this.sec.AXDate.axIsInstanceOf(obj)) {
+            return 'new Date(' + (+obj.value) + ')';
+        }
+        if (this.$BgmarshallExceptions && (this.sec.AXError.axIsInstanceOf(obj))) {
+            return 'throw ' + JSON.stringify(String(obj));
+        }
+        if (typeof obj === 'object' && obj !== null) {
+            var parts = [];
+            var keys = obj.axGetEnumerableKeys();
+            for (var i = 0; i < keys.length; i++) {
+                var key = keys[i];
+                parts.push(JSON.stringify(key) + ':' + this.convertToJSString(obj.axGetPublicProperty(key)));
+            }
+            return '({' + parts.join(',') + '})';
+        }
+        return String(obj);
+    };
+    ExternalInterface.classInitializer = null;
+    ExternalInterface.initialized = false;
+    ExternalInterface.registeredCallbacks = {};
+    return ExternalInterface;
+}(ASObject));
+export { ExternalInterface };
+function extractId(node) {
+    for (var i = 0; i < node._attributes.length; i++) {
+        var attribute = node._attributes[i];
+        if (attribute._name.name === 'id') {
+            return attribute._value;
+        }
+    }
+    // TODO: throw if no `id` attribute was found.
+}

package/dist/lib/factories/FlashSceneGraphFactory.d.ts

@@ -0,0 +1,33 @@
+import { Image2D } from '@awayjs/stage';
+import { IFrameScript, Timeline, MovieClip, Sprite, DisplayObjectContainer as AwayDisplayObjectContainer, Billboard, ISceneGraphFactory, TextField, PrefabBase } from '@awayjs/scene';
+import { MaterialBase } from '@awayjs/materials';
+import { DefaultSceneGraphFactory } from '@awayjs/scene';
+import { Graphics } from '@awayjs/graphics';
+import { SecurityDomain } from '../SecurityDomain';
+import { LoaderInfo } from '../display/LoaderInfo';
+import { IAsset } from '@awayjs/core';
+export declare class FlashSceneGraphFactory extends DefaultSceneGraphFactory implements ISceneGraphFactory {
+    imageStore: Object;
+    private _sec;
+    private _loaderInfo;
+    private get appDomain();
+    constructor(sec: SecurityDomain, loaderInfo?: LoaderInfo);
+    executeABCBytes(abcBlocks: any[]): any;
+    createSprite(_prefab?: PrefabBase, graphics?: Graphics, symbol?: any): Sprite;
+    createDisplayObjectContainer(_symbol?: any): AwayDisplayObjectContainer;
+    createBinarySymbol(symbol?: any): void;
+    createMovieClip(timeline?: Timeline, symbol?: any): MovieClip;
+    createTextField(symbol?: any): TextField;
+    createBillboard(material: MaterialBase, _symbol?: any): Billboard;
+    createImage2D(width: number, height: number, transparent?: boolean, fillColor?: number, _powerOfTwo?: boolean, _symbol?: any): Image2D;
+    createFrameScripts(_scripts: IFrameScript[], _frameIdx: number, _objName: string, _objID: number): IFrameScript[];
+    /**
+     * Get a instance for a given SymbolID and assign a sessionID to it.
+     * This is used by timeline to create children
+     *
+     * @param symbolID
+     * @param sessionID
+     */
+    createChildInstanceForTimeline(timeline: Timeline, symbolID: number, sessionID: number): IAsset;
+}
+//# sourceMappingURL=FlashSceneGraphFactory.d.ts.map

package/dist/lib/factories/FlashSceneGraphFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FlashSceneGraphFactory.d.ts","sourceRoot":"","sources":["../../../lib/factories/FlashSceneGraphFactory.ts"],"names":[],"mappings":"AACA,OAAO,EAAiB,OAAO,EAAE,MAAM,eAAe,CAAC;AACvD,OAAO,EACN,YAAY,EACZ,QAAQ,EACR,SAAS,EACT,MAAM,EACN,sBAAsB,IAAI,0BAA0B,EACpD,SAAS,EACT,kBAAkB,EAClB,SAAS,EACT,UAAU,EAIV,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC;AAKzD,OAAO,EAAE,QAAQ,EAAmB,MAAM,kBAAkB,CAAC;AAS7D,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC,qBAAa,sBAAuB,SAAQ,wBAAyB,YAAW,kBAAkB;IAC1F,UAAU,EAAE,MAAM,CAAM;IAC/B,OAAO,CAAC,IAAI,CAAiB;IAC7B,OAAO,CAAC,WAAW,CAAa;IAEhC,OAAO,KAAK,SAAS,GAMpB;gBAEW,GAAG,EAAE,cAAc,EAAE,UAAU,CAAC,EAAE,UAAU;IAMjD,eAAe,CAAC,SAAS,EAAE,GAAG,EAAE;IAgBhC,YAAY,CAAC,OAAO,GAAE,UAAiB,EAAE,QAAQ,GAAE,QAAe,EAAE,MAAM,GAAE,GAAU,GAAG,MAAM;IAqB/F,4BAA4B,CAAC,OAAO,GAAE,GAAU,GAAG,0BAA0B;IAI7E,kBAAkB,CAAC,MAAM,GAAE,GAAU,GAAG,IAAI;IAI5C,eAAe,CAAC,QAAQ,GAAE,QAAe,EAAE,MAAM,GAAE,GAAU,GAAG,SAAS;IA8BzE,eAAe,CAAC,MAAM,GAAE,GAAU,GAAG,SAAS;IAkB9C,eAAe,CAAC,QAAQ,EAAE,YAAY,EAAE,OAAO,GAAE,GAAU,GAAG,SAAS;IAIvE,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EACjD,WAAW,GAAE,OAAc,EAC3B,SAAS,GAAE,MAAa,EACxB,WAAW,GAAE,OAAc,EAC3B,OAAO,GAAE,GAAU,GAAG,OAAO;IAS9B,kBAAkB,CAAC,QAAQ,EAAE,YAAY,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,YAAY,EAAE;IAIjH;;;;;;OAMG;IACI,8BAA8B,CAAC,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM;CA6BtG"}

package/dist/lib/factories/FlashSceneGraphFactory.js

@@ -0,0 +1,175 @@
+import { __extends } from "tslib";
+import { BitmapImage2D } from '@awayjs/stage';
+import { Timeline, MovieClip, Sprite, Billboard, MorphSprite, FrameScriptManager, } from '@awayjs/scene';
+import { DefaultSceneGraphFactory } from '@awayjs/scene';
+import { SceneImage2D } from '@awayjs/scene';
+import { Bitmap } from '../display/Bitmap';
+import { BitmapData } from '../display/BitmapData';
+import { Graphics, MaterialManager } from '@awayjs/graphics';
+import { Multiname, constructClassFromSymbol, ABCFile, } from '@awayfl/avm2';
+var FlashSceneGraphFactory = /** @class */ (function (_super) {
+    __extends(FlashSceneGraphFactory, _super);
+    function FlashSceneGraphFactory(sec, loaderInfo) {
+        var _this = _super.call(this) || this;
+        _this.imageStore = {};
+        _this._sec = sec;
+        _this._loaderInfo = loaderInfo;
+        return _this;
+    }
+    Object.defineProperty(FlashSceneGraphFactory.prototype, "appDomain", {
+        get: function () {
+            if (this._loaderInfo) {
+                return this._loaderInfo.applicationDomain.axApplicationDomain;
+            }
+            return this._sec.application;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    FlashSceneGraphFactory.prototype.executeABCBytes = function (abcBlocks) {
+        for (var i = 0; i < abcBlocks.length; i++) {
+            var abcBlock = abcBlocks[i];
+            var abc = new ABCFile({ app: this.appDomain, url: '' }, abcBlock.data);
+            if (abcBlock.flags) {
+                // kDoAbcLazyInitializeFlag = 1 Indicates that the ABC block should not be executed
+                // immediately.
+                this.appDomain.loadABC(abc);
+            }
+            else {
+                // TODO: probably delay execution until playhead reaches the frame.
+                this.appDomain.loadAndExecuteABC(abc);
+            }
+        }
+        return null;
+    };
+    FlashSceneGraphFactory.prototype.createSprite = function (_prefab, graphics, symbol) {
+        if (_prefab === void 0) { _prefab = null; }
+        if (graphics === void 0) { graphics = null; }
+        if (symbol === void 0) { symbol = null; }
+        if (!symbol || !this._sec)
+            throw ('no symbol provided');
+        var symbolClass = null;
+        if (symbol.className)
+            symbolClass = this.appDomain.getClass(Multiname.FromFQNString(symbol.className, 0 /* NamespaceType.Public */));
+        else
+            symbolClass = this._sec.flash.display.Sprite.axClass;
+        symbol.symbolClass = symbolClass;
+        //Graphicsadapter.currentAwayGraphics=graphics;
+        // create the root for the root-symbol
+        var asObj = constructClassFromSymbol(symbol, symbolClass);
+        asObj.adaptee = new Sprite(graphics);
+        asObj.adaptee.name = graphics.name;
+        // manually call the axInitializer for now:
+        //asObj.axInitializer(Sprite.getNewSprite(new this._sec.flash.display.Graphics(graphics).adaptee));
+        return asObj.adaptee;
+    };
+    FlashSceneGraphFactory.prototype.createDisplayObjectContainer = function (_symbol) {
+        if (_symbol === void 0) { _symbol = null; }
+        return new this._sec.flash.display.DisplayObjectContainer().adaptee;
+    };
+    FlashSceneGraphFactory.prototype.createBinarySymbol = function (symbol) {
+        if (symbol === void 0) { symbol = null; }
+        this.appDomain.addBinarySymbol(symbol);
+    };
+    FlashSceneGraphFactory.prototype.createMovieClip = function (timeline, symbol) {
+        if (timeline === void 0) { timeline = null; }
+        if (symbol === void 0) { symbol = null; }
+        if (!symbol || !this._sec)
+            throw ('no symbol provided');
+        var symbolClass = null;
+        if (symbol.className) {
+            symbolClass = this.appDomain.getClass(Multiname.FromFQNString(symbol.className, 0 /* NamespaceType.Public */));
+            symbolClass._symbol = symbol;
+        }
+        else if (symbol.isButton) {
+            symbolClass = this._sec.flash.display.SimpleButton.axClass;
+        }
+        else {
+            symbolClass = this._sec.flash.display.MovieClip.axClass;
+        }
+        //console.log("parsed symbolClass", symbolClass, symbol);
+        symbol.symbolClass = symbolClass;
+        // create the root for the root-symbol
+        var rootSymbolClass = symbol.isButton
+            ? this._sec.flash.display.SimpleButton.axClass
+            : this._sec.flash.display.MovieClip.axClass;
+        var asObj = constructClassFromSymbol(symbol, rootSymbolClass);
+        asObj.adaptee = new MovieClip(timeline || new Timeline(this));
+        symbol.timeline = asObj.adaptee.timeline;
+        //(<MovieClip>asObj.adaptee).timeline.resetScripts();
+        //(<any>asObj).axInitializer();
+        return asObj.adaptee;
+    };
+    FlashSceneGraphFactory.prototype.createTextField = function (symbol) {
+        if (symbol === void 0) { symbol = null; }
+        var symbolClass = null;
+        if (symbol.className) {
+            symbolClass = this.appDomain.getClass(Multiname.FromFQNString(symbol.className, 0 /* NamespaceType.Public */));
+        }
+        else {
+            symbolClass = this._sec.flash.text.TextField.axClass;
+        }
+        symbol.symbolClass = symbolClass;
+        // create the root for the root-symbol
+        var asObj = constructClassFromSymbol(symbol, symbolClass);
+        // 	manually call the axInitializer - this will run the constructor
+        //	creating new Away-MovieClip and timeline, and registers framescripts on the timeline:
+        asObj.axInitializer();
+        return asObj.adaptee;
+    };
+    FlashSceneGraphFactory.prototype.createBillboard = function (material, _symbol) {
+        if (_symbol === void 0) { _symbol = null; }
+        return new Bitmap(material.style.image.adapter).adaptee;
+    };
+    FlashSceneGraphFactory.prototype.createImage2D = function (width, height, transparent, fillColor, _powerOfTwo, _symbol) {
+        if (transparent === void 0) { transparent = true; }
+        if (fillColor === void 0) { fillColor = null; }
+        if (_powerOfTwo === void 0) { _powerOfTwo = true; }
+        if (_symbol === void 0) { _symbol = null; }
+        var image = new BitmapData(width, height, transparent, fillColor).adaptee;
+        // drop weak ref for symbols
+        image.unuseWeakRef();
+        return image;
+    };
+    FlashSceneGraphFactory.prototype.createFrameScripts = function (_scripts, _frameIdx, _objName, _objID) {
+        return _scripts;
+    };
+    /**
+     * Get a instance for a given SymbolID and assign a sessionID to it.
+     * This is used by timeline to create children
+     *
+     * @param symbolID
+     * @param sessionID
+     */
+    FlashSceneGraphFactory.prototype.createChildInstanceForTimeline = function (timeline, symbolID, sessionID) {
+        // if this was called we might have new constructors from timeline to process
+        FrameScriptManager.invalidAS3Constructors = true;
+        var asset = this.awaySymbols[symbolID];
+        var clone;
+        if (asset.isAsset(Graphics)) {
+            clone = Sprite.getNewSprite(asset);
+            clone.name = asset.name;
+            clone.mouseEnabled = false;
+        }
+        else if (asset.isAsset(Sprite)) {
+            clone = Sprite.getNewSprite(asset.graphics);
+            clone.mouseEnabled = false;
+        }
+        else if (asset.isAsset(MorphSprite)) {
+            clone = MorphSprite.getNewMorphSprite(asset.graphics.clone());
+            clone.mouseEnabled = false;
+        }
+        else if (asset.isAsset(BitmapImage2D) || asset.isAsset(SceneImage2D)) {
+            clone = Billboard.getNewBillboard(MaterialManager.getMaterialForBitmap());
+            clone.mouseEnabled = false;
+            clone.style.image = asset;
+        }
+        else {
+            clone = asset.adapter.clone(false).adaptee;
+        }
+        clone._sessionID = sessionID;
+        return clone;
+    };
+    return FlashSceneGraphFactory;
+}(DefaultSceneGraphFactory));
+export { FlashSceneGraphFactory };