@afterswf/playerglobal 0.0.0-stage → 0.2.460

package/lib/xml/XMLNode.ts

@@ -0,0 +1,326 @@
+import { Debug } from '@awayjs/core';
+/**
+ * The XMLNode class represents the legacy XML object
+ * that was present in ActionScript 2.0 and that was renamed in ActionScript 3.0.
+ * In ActionScript 3.0, consider using the new top-level <xref href="../../XML.html" class="- topic/xref ">XML</xref>
+ * class and related classes instead,
+ * which support E4X (ECMAScript for XML).
+ * The XMLNode class is present for backward compatibility.
+ */
+export class XMLNode {
+	/**
+	 * Creates a new XMLNode object. You must use the constructor to create an XMLNode object before you
+	 * call any of the methods of the XMLNode class.
+	 * Note: Use the createElement() and createTextNode()
+	 * methods to add elements and text nodes to an XML document tree.
+	 * @param	type	The node type: either 1 for an XML element or 3 for a text node.
+	 * @param	value	The XML text parsed to create the new XMLNode object.
+	 */
+	constructor (type: number, value: string) {
+	}
+
+	// for AVM1:
+	public axCallPublicProperty(value1: any, value2: any): any {
+		return null;
+	}
+
+	public axGetPublicProperty(value: any): any {
+		return null;
+	}
+
+	public axSetPublicProperty(value: any, value2: any): any {
+		return null;
+	}
+
+	/**
+	 * Evaluates the specified XMLDocument object and references the first child in the parent node's child list.
+	 * This property is null if the node does not have children. This property is
+	 * undefined if the node is a text node. This is a read-only property and cannot be used
+	 * to manipulate child nodes; use the appendChild(), insertBefore(), and
+	 * removeNode() methods to manipulate child nodes.
+	 */
+	public firstChild: XMLNode;
+
+	public removeChild(child: any) {
+
+	}
+
+	/**
+	 * An XMLNode value that references the last child in the node's child list. The
+	 * XMLNode.lastChild property is null if the node does not have children.
+	 * This property cannot be used to manipulate child nodes; use the appendChild(),
+	 * insertBefore(), and removeNode() methods to manipulate child nodes.
+	 */
+	public lastChild: XMLNode;
+
+	/**
+	 * An XMLNode value that references the next sibling in the parent node's child list. This property is
+	 * null if the node does not have a next sibling node. This property cannot be used to
+	 * manipulate child nodes; use the appendChild(), insertBefore(), and
+	 * removeNode() methods to manipulate child nodes.
+	 */
+	public nextSibling: XMLNode;
+
+	/**
+	 * A string representing the node name of the XMLNode object. If the XMLNode object is an XML
+	 * element (nodeType == 1), nodeName is the name of the tag that
+	 * represents the node in the XML file. For example, TITLE is the nodeName
+	 * of an HTML TITLE tag. If the XMLNode object is a text node
+	 * (nodeType == 3), nodeName is null.
+	 */
+	public nodeName: string;
+
+	/**
+	 * A nodeType constant value, either XMLNodeType.ELEMENT_NODE for an XML element or
+	 * XMLNodeType.TEXT_NODE for a text node.
+	 * The nodeType is a numeric value from the NodeType enumeration in the W3C DOM
+	 * Level 1 recommendation:
+	 * http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core.html.
+	 * The following table lists the values:4CDATA_SECTION_NODEInteger valueDefined
+	 * constant1ELEMENT_NODE3TEXT_NODE5ENTITY_REFERENCE_NODE7PROCESSING_INSTRUCTION_NODE9
+	 * DOCUMENT_NODE11DOCUMENT_FRAGMENT_NODEIn Flash Player, the built-in XMLNode class only supports
+	 * XMLNodeType.ELEMENT_NODE and
+	 * XMLNodeType.TEXT_NODE.
+	 */
+	public nodeType: number;
+
+	/**
+	 * The node value of the XMLDocument object. If the XMLDocument object is a text node, the nodeType
+	 * is 3, and the nodeValue is the text of the node. If the XMLDocument object is an XML element
+	 * (nodeType is 1), nodeValue is null and read-only.
+	 */
+	public nodeValue: string;
+
+	/**
+	 * An XMLNode value that references the parent node of the specified XML object, or returns
+	 * null if the node has no parent. This is a read-only property and cannot be used to
+	 * manipulate child nodes; use the appendChild(), insertBefore(), and
+	 * removeNode() methods to manipulate child nodes.
+	 */
+	public parentNode: XMLNode;
+
+	/**
+	 * An XMLNode value that references the previous sibling in the parent node's child list.
+	 * The property has a value of null if the node does not have a previous sibling node. This property
+	 * cannot be used to manipulate child nodes; use the appendChild(),
+	 * insertBefore(), and removeNode() methods to manipulate child nodes.
+	 */
+	public previousSibling: XMLNode;
+
+	/**
+	 * An object containing all of the attributes of the specified XMLNode instance. The
+	 * XMLNode.attributes object contains one variable for each attribute of the XMLNode instance.
+	 * Because these variables are defined as part of the object, they are generally referred to as
+	 * properties of the object. The value of each attribute is stored in the corresponding property as a
+	 * string. For example, if you have an attribute named color, you would retrieve
+	 * that attribute's value
+	 * by specifying color as the property name, as the following code shows:
+	 *
+	 *   var myColor:String = doc.firstChild.attributes.color
+	 */
+	public get attributes (): any {
+		// @todo
+		Debug.throwPIR('playerglobals/xml/XMLNode', 'get attributes', '');
+		return null;
+	}
+
+	public set attributes (value: any) {
+		// @todo
+		Debug.throwPIR('playerglobals/xml/XMLNode', 'set attributes', '');
+	}
+
+	/**
+	 * An array of the specified XMLNode object's children. Each element in the array is a reference
+	 * to an XMLNode object that represents a child node. This is a read-only property and cannot be
+	 * used to manipulate child nodes. Use the appendChild(), insertBefore(),
+	 * and removeNode()  methods to manipulate child nodes.
+	 *
+	 *   This property is undefined for text nodes (nodeType == 3).
+	 */
+	public get childNodes (): any[] {
+		// @todo
+		Debug.throwPIR('playerglobals/xml/XMLNode', 'get childNodes', '');
+		return [];
+	}
+
+	/**
+	 * The local name portion of the XML node's name. This is the element name without
+	 * the namespace prefix. For example, the node
+	 * <contact:mailbox/>bob@example.com</contact:mailbox>
+	 *   has the local name "mailbox", and the prefix "contact", which comprise the full
+	 *   element name "contact.mailbox".
+	 *
+	 *     You can access the namespace prefix through the prefix property of
+	 *   the XML node object. The nodeName property returns the full name
+	 *   (including the prefix and the local name).
+	 */
+	public get localName (): string {
+		// @todo
+		Debug.throwPIR('playerglobals/xml/XMLNode', 'localName', '');
+		return '';
+	}
+
+	/**
+	 * If the XML node has a prefix, namespaceURI is the value of the xmlns
+	 * declaration for that prefix (the URI), which is typically called the namespace URI.
+	 * The xmlns declaration is in the current node or in a node higher in the XML
+	 * hierarchy.
+	 *
+	 *   If the XML node does not have a prefix, the value of the namespaceURI property
+	 * depends on whether there is a default namespace defined (as in
+	 * xmlns="http://www.example.com/"). If there is a default namespace, the value of
+	 * the namespaceURI property is the value of the default namespace.
+	 * If there is no default namespace, the namespaceURI property for
+	 * that node is an empty string ("").You can use the getNamespaceForPrefix() method
+	 * to identify the namespace associated with a
+	 * specific prefix. The namespaceURI property returns the prefix associated with the node name.
+	 */
+	public get namespaceURI (): string {
+		// @todo
+		Debug.throwPIR('playerglobals/xml/XMLNode', 'namespaceURI', '');
+		return '';
+	}
+
+	/**
+	 * The prefix portion of the XML node name. For example, the node
+	 * <contact:mailbox/>bob@example.com</contact:mailbox> prefix
+	 *   "contact" and the local name "mailbox", which comprise the full element name "contact.mailbox".
+	 *
+	 *     The nodeName property of an XML node object returns the full name
+	 *   (including the prefix and the  local name). You can access the local name portion of the
+	 *   element's name via the localName property.
+	 */
+	public get prefix (): string {
+		// @todo
+		Debug.throwPIR('playerglobals/xml/XMLNode', 'get prefix', '');
+		return '';
+	}
+
+	/**
+	 * Appends the specified node to the XML object's child list. This method operates directly on the
+	 * node referenced by the childNode parameter; it does not append a copy of the
+	 * node. If the node to be appended already exists in another tree structure, appending the node to the
+	 * new location will remove it from its current location. If the childNode
+	 * parameter refers to a node that already exists in another XML tree structure, the appended child node
+	 * is placed in the new tree structure after it is removed from its existing parent node.
+	 * @param	node	An XMLNode that represents the node to be moved from its current location to the child
+	 *   list of the my_xml object.
+	 */
+	public appendChild (node: XMLNode) {
+		// @todo
+		Debug.throwPIR('playerglobals/xml/XMLNode', 'appendChild', '');
+	}
+
+	/**
+	 * Constructs and returns a new XML node of the same type, name, value, and attributes as the
+	 * specified XML object. If deep is set to true, all child nodes are
+	 * recursively cloned, resulting in an exact copy of the original object's document tree.
+	 * The clone of the node that is returned is no longer associated with the tree of the cloned item.
+	 * Consequently, nextSibling, parentNode, and previousSibling
+	 * all have a value of null. If the deep parameter is set to
+	 * false, or the my_xml node has no child nodes,
+	 * firstChild and lastChild are also null.
+	 * @param	deep	A Boolean value; if set to true, the children of the specified
+	 * XML object will be recursively cloned.
+	 * @return	An XMLNode Object.
+	 */
+	public cloneNode (deep: boolean): XMLNode {
+		// @todo
+		Debug.throwPIR('playerglobals/xml/XMLNode', 'cloneNode', '');
+		return null;
+	}
+
+	/**
+	 * Returns the namespace URI that is associated with the specified prefix for the node. To determine
+	 * the URI, getPrefixForNamespace() searches up the XML hierarchy from the node, as
+	 * necessary, and returns the namespace URI of the first xmlns declaration for the
+	 * given prefix.
+	 *
+	 *   If no namespace is defined for the specified prefix, the method returns null.
+	 * If you specify an empty string ("") as the prefix and there is a
+	 * default namespace defined for the node (as in xmlns="http://www.example.com/"),
+	 * the method returns that default namespace URI.
+	 * @param	prefix	The prefix for which the method returns the associated namespace.
+	 * @return	The namespace that is associated with the specified prefix.
+	 * @refpath
+	 */
+	public getNamespaceForPrefix (prefix: string): string {
+		// @todo
+		Debug.throwPIR('playerglobals/xml/XMLNode', 'getNamespaceForPrefix', '');
+		return '';
+	}
+
+	/**
+	 * Returns the prefix that is associated with the specified namespace URI for the node. To determine
+	 * the prefix, getPrefixForNamespace() searches up the XML hierarchy from the node, as
+	 * necessary, and returns the prefix of the first xmlns declaration with a namespace URI
+	 * that matches ns.
+	 *
+	 *   If there is no xmlns
+	 * assignment for the given URI, the method returns null. If there is an
+	 * xmlns assignment for the given URI but no prefix is associated with the assignment,
+	 * the method returns an empty string
+	 * ("").
+	 * @param	ns	The namespace URI for which the method returns the associated prefix.
+	 * @return	The prefix associated with the specified namespace.
+	 */
+	public getPrefixForNamespace (ns: string): string {
+		// @todo
+		Debug.throwPIR('playerglobals/xml/XMLNode', 'getPrefixForNamespace', '');
+		return '';
+	}
+
+	/**
+	 * Indicates whether the specified XMLNode object has child nodes. This property is true if the
+	 * specified XMLNode object has child nodes; otherwise, it is false.
+	 * @return	Returns true if the
+	 *   specified XMLNode object has child nodes; otherwise, false.
+	 */
+	public hasChildNodes (): boolean {
+		// @todo
+		Debug.throwPIR('playerglobals/xml/XMLNode', 'hasChildNodes', '');
+		return false;
+	}
+
+	/**
+	 * Inserts a new child node into the XML object's child list, before the
+	 * beforeNode node. If the beforeNode parameter is undefined
+	 * or null, the node is added using the appendChild() method. If beforeNode
+	 * is not a child of my_xml, the insertion fails.
+	 * @param	node	The XMLNode object to be inserted.
+	 * @param	before	The XMLNode object before the insertion point for the childNode.
+	 */
+	public insertBefore (node: XMLNode, before: XMLNode) {
+		// @todo
+		Debug.throwPIR('playerglobals/xml/XMLNode', 'insertBefore', '');
+	}
+
+	/**
+	 * Removes the specified XML object from its parent. Also deletes all descendants of the node.
+	 */
+	public removeNode () {
+		// @todo
+		Debug.throwPIR('playerglobals/xml/XMLNode', 'removeNode', '');
+	}
+
+	/**
+	 * Evaluates the specified XMLNode object, constructs a textual representation of the XML structure,
+	 * including the node, children, and attributes, and returns the result as a string.
+	 *
+	 *   For top-level XMLDocument objects (those created with the constructor),
+	 * the XMLDocument.toString() method outputs the document's XML declaration
+	 * (stored in the XMLDocument.xmlDecl property), followed by the document's
+	 * DOCTYPE declaration (stored in the XMLDocument.docTypeDecl property),
+	 * followed by the text representation of all XML nodes in the object. The XML declaration is not
+	 * output if the XMLDocument.xmlDecl property is null.
+	 * The DOCTYPE declaration is not output if the
+	 * XMLDocument.docTypeDecl property is null.
+	 * @return	The string representing the XMLNode object.
+	 */
+	public toString (): string {
+		// @todo
+		Debug.throwPIR('playerglobals/xml/XMLNode', 'toString', '');
+		return '';
+	}
+
+}

package/lib/xml/XMLNodeType.ts

@@ -0,0 +1,48 @@
+
+/**
+ * The XMLNodeType class contains constants used with
+ * <codeph class="+ topic/ph pr-d/codeph ">XMLNode.nodeType</codeph>. The values are defined
+ * by the NodeType enumeration in the
+ * W3C DOM Level 1 recommendation:
+ * <xref href="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core.html" scope="external"
+ * class="- topic/xref ">http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core.html</xref>
+ * @langversion	3.0
+ * @playerversion	Flash 9
+ * @playerversion	Lite 4
+ */
+export class XMLNodeType {
+	//80pro todo: all values above 100 are value i assigned, maybe worth to check what they was in original as3
+	public static CDATA_NODE: number = 100;
+	public static COMMENT_NODE: number = 101;
+	public static DOCUMENT_TYPE_NODE: number = 102;
+
+	/**
+	 * Specifies that the node is an element.
+	 * This constant is used with XMLNode.nodeType.
+	 * The value is defined by the NodeType enumeration in the
+	 * W3C DOM Level 1 recommendation:
+	 * http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core.html
+	 * @langversion	3.0
+	 * @playerversion	Flash 9
+	 * @playerversion	Lite 4
+	 */
+	public static ELEMENT_NODE: number = 1;
+	public static PROCESSING_INSTRUCTION_NODE: number = 103;
+
+	/**
+	 * Specifies that the node is a text node.
+	 * This constant is used with XMLNode.nodeType.
+	 * The value is defined by the NodeType enumeration in the
+	 * W3C DOM Level 1 recommendation:
+	 * http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core.html
+	 * @langversion	3.0
+	 * @playerversion	Flash 9
+	 * @playerversion	Lite 4
+	 */
+	public static TEXT_NODE: number = 3;
+	public static XML_DECLARATION: number=104;
+
+	constructor () {
+		// todo: why does this have a constructor ? it just provides static props...
+	}
+}

package/package.json

@@ -1,6 +1,80 @@
 {
   "name": "@afterswf/playerglobal",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.460",
+  "description": "Global class definitions for the AS3 language",
+  "main": "bundle/awayfl-playerglobal.umd.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "url": "http://www.away3d.com",
+  "author": "Rob Bateman",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/afterswf/playerglobal.git"
+  },
+  "scripts": {
+    "rimraf": "rimraf",
+    "rollup": "rollup -c",
+    "tsc": "tsc",
+    "tsc:build": "npm run tsc || exit 0",
+    "clean": "npm cache clean && npm run rimraf -- node_modules dist bundle",
+    "clean:dist": "npm run rimraf -- dist bundle",
+    "watch": "npm run tsc -- --w",
+    "eslint": "eslint ./lib --fix",
+    "eslint:commit": "npm run eslint && npm run --silent gitdiff || git add -u && git commit -m \"fixed by eslint\"",
+    "gitdiff": "git diff --quiet && git diff --cached --quiet",
+    "prebuild": "npm run clean:dist",
+    "build": "npm run tsc:build && npm run rollup",
+    "prepare": "npm run tsc:build",
+    "prepublishOnly": "npm run build",
+    "copyVersionToIndex": "node ./copyVersionToIndex && git add ./index.ts && git commit -m \"update version number in index.ts\"",
+    "version": "npm run copyVersionToIndex && npm run build"
+  },
+  "keywords": [
+    "AwayJS",
+    "WebGL",
+    "2D",
+    "3D",
+    "graphics"
+  ],
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/afterswf/playerglobal/issues"
+  },
+  "homepage": "https://github.com/afterswf/playerglobal#readme",
+  "peerDependencies": {
+    "@awayfl/avm2": "npm:@afterswf/avm2@^0.2.241",
+    "@awayfl/swf-loader": "^0.4.0",
+    "@awayjs/core": "^0.9.0",
+    "@awayjs/graphics": "npm:@afterswf/graphics@^0.5.101",
+    "@awayjs/materials": "^0.6.0",
+    "@awayjs/scene": "npm:@afterswf/scene@^0.13.325",
+    "@awayjs/stage": "^0.11.0",
+    "@awayjs/view": "^0.6.0",
+    "tslib": "^2.3.0"
+  },
+  "devDependencies": {
+    "@awayfl/avm2": "^0.2.0",
+    "@awayfl/swf-loader": "^0.4.0",
+    "@awayjs/core": "^0.9.0",
+    "@awayjs/graphics": "^0.5.0",
+    "@awayjs/materials": "^0.6.0",
+    "@awayjs/renderer": "^0.11.0",
+    "@awayjs/scene": "^0.13.0",
+    "@awayjs/stage": "^0.11.0",
+    "@awayjs/view": "^0.6.0",
+    "@types/wicg-file-system-access": "^2020.9.5",
+    "@rollup/plugin-commonjs": "^18.0.0",
+    "@rollup/plugin-terser": "^0.4.3",
+    "@rollup/plugin-node-resolve": "^11.2.1",
+    "@typescript-eslint/eslint-plugin": "^4.4.1",
+    "@typescript-eslint/parser": "^4.4.1",
+    "eslint": "^7.11.0",
+    "rimraf": "^2.5.2",
+    "rollup": "^2.79.1",
+    "tslib": "^2.3.0",
+    "typescript": "^4.9.5"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/rollup.config.js

@@ -0,0 +1,40 @@
+import nodeResolve from '@rollup/plugin-node-resolve';
+import commonjs from '@rollup/plugin-commonjs';
+import terser from '@rollup/plugin-terser';
+
+export default {
+	input: './dist/index.js',
+	output: {
+		name: 'AwayflPlayerglobal',
+		globals: {
+			'@awayfl/swf-loader': 'AwayflSwfLoader',
+			'@awayfl/avm2': 'AwayflAvm2',
+			'@awayjs/core': 'AwayjsCore',
+			'@awayjs/stage': 'AwayjsStage',
+			'@awayjs/view': 'AwayjsView',
+			'@awayjs/renderer': 'AwayjsRenderer',
+			'@awayjs/graphics': 'AwayjsGraphics',
+			'@awayjs/materials': 'AwayjsMaterials',
+			'@awayjs/scene': 'AwayjsScene'
+		},
+		sourcemap: true,
+		format: 'umd',
+		file: './bundle/awayfl-playerglobal.umd.js'
+	},
+	external: [
+		'@awayfl/swf-loader',
+		'@awayfl/avm2',
+		'@awayjs/core',
+		'@awayjs/stage',
+		'@awayjs/view',
+		'@awayjs/renderer',
+		'@awayjs/graphics',
+		'@awayjs/materials',
+		'@awayjs/scene'
+	],
+	plugins: [
+		nodeResolve(),
+		commonjs(),
+		terser(),
+	]
+};

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "es5",
+    "module": "es2015",
+    "lib": ["DOM","ScriptHost", "ESNext"],
+    "types":[ "@types/wicg-file-system-access"],
+    "moduleResolution": "node",
+    "noImplicitUseStrict": true,
+    "noEmitHelpers": true,
+    "importHelpers": true,
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "./dist"
+  },
+  "files": [
+    "./index.ts"
+  ]
+}