Initial commit.

frontend/build-templates/wechatgame/libs/engine/Audio.js

@@ -0,0 +1,13 @@
+(function () {
+    if (!(cc && cc.Audio)) {
+        return;
+    }
+    cc.Audio.prototype.stop = function () {
+        if (!this._element) return;
+        this._element.stop();
+        this._element.currentTime = 0;
+        this._unbindEnded();
+        this.emit('stop');
+        this._state = cc.Audio.State.STOPPED;
+    };
+})();

frontend/build-templates/wechatgame/libs/engine/DeviceMotionEvent.js

@@ -0,0 +1,79 @@
+
+const inputManager = _cc.inputManager;
+let isInit = false;
+
+Object.assign(inputManager, {
+    setAccelerometerEnabled (isEnable) {
+        let scheduler = cc.director.getScheduler();
+        scheduler.enableForTarget(this);
+        if (isEnable) {
+            this._registerAccelerometerEvent();
+            scheduler.scheduleUpdate(this);
+        }
+        else {
+            this._unregisterAccelerometerEvent();
+            scheduler.unscheduleUpdate(this);
+        }
+    },
+
+    // No need to adapt
+    // setAccelerometerInterval (interval) {  },
+
+    _registerAccelerometerEvent () {
+        this._accelCurTime = 0;   
+        if (!isInit) {
+            isInit = true;
+            let self = this;
+            this._acceleration = new cc.Acceleration();
+
+            wx.onAccelerometerChange && wx.onAccelerometerChange(function (res) {
+                let x = res.x;
+                let y = res.y;
+            
+                let systemInfo = wx.getSystemInfoSync();
+                let windowWidth = systemInfo.windowWidth;
+                let windowHeight = systemInfo.windowHeight;
+                if (windowHeight < windowWidth) {
+                    // Landscape orientation
+
+                    // For left landscape
+                    // x = y;
+                    // y = -x;
+
+                    // For right landscape
+                    // x = -y;
+                    // y = x;
+
+                    // We suggest to use right landscape by default
+                    let tmp = x;
+                    x = -y;
+                    y = tmp;
+                }
+                
+                self._acceleration.x = x;
+                self._acceleration.y = y;
+                self._acceleration.z = res.z;
+            });
+        }
+        else {
+            wx.startAccelerometer && wx.startAccelerometer({
+                fail: function (err) {
+                    cc.error('register Accelerometer failed ! err: ' + err);
+                },
+                success: function () {},
+                complete: function () {},
+            });
+        }
+    },
+
+    _unregisterAccelerometerEvent () {
+        this._accelCurTime = 0;  
+        wx.stopAccelerometer && wx.stopAccelerometer({
+            fail: function (err) {
+                cc.error('unregister Accelerometer failed ! err: ' + err);
+            },
+            success: function () {},
+            complete: function () {},
+        });
+    },
+});

frontend/build-templates/wechatgame/libs/engine/Editbox.js

@@ -0,0 +1,140 @@
+(function () {
+    if (!(cc && cc.EditBox)) {
+        return;
+    }
+    
+    var KeyboardReturnType = cc.EditBox.KeyboardReturnType;
+    var _p = cc.EditBox._EditBoxImpl.prototype;
+    var _currentEditBoxImpl = null;
+
+    function getKeyboardReturnType (type) {
+        switch (type) {
+            case KeyboardReturnType.DEFAULT:
+            case KeyboardReturnType.DONE:
+                return 'done';
+            case KeyboardReturnType.SEND:
+                return 'send';
+            case KeyboardReturnType.SEARCH:
+                return 'search';
+            case KeyboardReturnType.GO:
+                return 'go';
+            case KeyboardReturnType.NEXT:
+                return 'next';
+        }
+        return 'done';
+    }
+
+    function updateLabelsVisibility(editBox) {
+        var placeholderLabel = editBox._placeholderLabel;
+        var textLabel = editBox._textLabel;
+        var displayText = editBox._impl._text;
+  
+        placeholderLabel.node.active = displayText === '';
+        textLabel.node.active = displayText !== '';
+    }
+
+    cc.EditBox.prototype.editBoxEditingDidBegan = function () {
+        cc.Component.EventHandler.emitEvents(this.editingDidBegan, this);
+        this.node.emit('editing-did-began', this);
+    };
+
+    cc.EditBox.prototype.editBoxEditingDidEnded = function () {
+        cc.Component.EventHandler.emitEvents(this.editingDidEnded, this);
+        this.node.emit('editing-did-ended', this);
+    };
+
+    cc.EditBox.prototype._updateStayOnTop = function () {
+        // wx not support
+    };
+
+    _p.setFocus = function () {
+        this._beginEditing();
+    };
+
+    _p.isFocused = function () {
+        return this._editing;
+    };
+
+    _p.setInputMode = function (inputMode) {
+        this._inputMode = inputMode;
+    };
+
+    _p._beginEditing = function () {
+        this.createInput();
+    };
+
+    _p._endEditing = function () {
+        this._delegate && this._delegate.editBoxEditingDidEnded();
+        this._editing = false;
+    };
+
+    _p.createInput = function () {
+        // Unregister keyboard event listener in old editBoxImpl if keyboard haven't hidden.
+        if (_currentEditBoxImpl !== this) {
+            if (_currentEditBoxImpl) {
+                _currentEditBoxImpl._endEditing();
+                wx.offKeyboardConfirm(_currentEditBoxImpl.onKeyboardConfirmCallback);
+                wx.offKeyboardInput(_currentEditBoxImpl.onKeyboardInputCallback);
+                wx.offKeyboardComplete(_currentEditBoxImpl.onKeyboardCompleteCallback);
+            }
+            _currentEditBoxImpl = this;
+        }
+
+        var multiline = this._inputMode === cc.EditBox.InputMode.ANY;
+        var editBoxImpl = this;
+        this._editing = true;
+
+        function onKeyboardConfirmCallback (res) {
+            editBoxImpl._text = res.value;
+            editBoxImpl._delegate && editBoxImpl._delegate.editBoxEditingReturn && editBoxImpl._delegate.editBoxEditingReturn();
+            wx.hideKeyboard({
+                success: function (res) {
+                    
+                },
+                fail: function (res) {
+                    cc.warn(res.errMsg);
+                }
+            });
+        }
+
+        function onKeyboardInputCallback (res) {        
+            if (res.value.length > editBoxImpl._maxLength) {
+                res.value = res.value.slice(0, editBoxImpl._maxLength);
+            }
+            if (editBoxImpl._delegate && editBoxImpl._delegate.editBoxTextChanged) {
+                if (editBoxImpl._text !== res.value) {
+                    editBoxImpl._text = res.value;
+                    editBoxImpl._delegate.editBoxTextChanged(editBoxImpl._text);
+                    updateLabelsVisibility(editBoxImpl._delegate);
+                }
+            }
+        }
+
+        function onKeyboardCompleteCallback () {
+            editBoxImpl._endEditing();
+            wx.offKeyboardConfirm(onKeyboardConfirmCallback);
+            wx.offKeyboardInput(onKeyboardInputCallback);
+            wx.offKeyboardComplete(onKeyboardCompleteCallback);
+            _currentEditBoxImpl = null;
+        }
+        
+        wx.showKeyboard({
+            defaultValue: editBoxImpl._text,
+            maxLength: editBoxImpl._maxLength,
+            multiple: multiline,
+            confirmHold: false,  // hide keyboard mannually by wx.onKeyboardConfirm
+            confirmType: getKeyboardReturnType(editBoxImpl._returnType),
+            success: function (res) {
+                editBoxImpl._delegate && editBoxImpl._delegate.editBoxEditingDidBegan && editBoxImpl._delegate.editBoxEditingDidBegan();
+            },
+            fail: function (res) {
+                cc.warn(res.errMsg);
+                editBoxImpl._endEditing();
+            }
+        });
+        wx.onKeyboardConfirm(onKeyboardConfirmCallback);
+        wx.onKeyboardInput(onKeyboardInputCallback);
+        wx.onKeyboardComplete(onKeyboardCompleteCallback);
+    };
+})();
+

frontend/build-templates/wechatgame/libs/engine/Game.js

@@ -0,0 +1,59 @@
+var _frameRate = 60;
+cc.game.setFrameRate = function (frameRate) {
+    _frameRate = frameRate;
+    if (wx.setPreferredFramesPerSecond) {
+        wx.setPreferredFramesPerSecond(frameRate);
+    }
+    else {
+        if (this._intervalId) {
+            window.cancelAnimFrame(this._intervalId);
+        }
+        this._intervalId = 0;
+        this._paused = true;
+        this._setAnimFrame();
+        this._runMainLoop();
+    }
+};
+
+cc.game._setAnimFrame = function () {
+    this._lastTime = performance.now();
+    this._frameTime = 1000 / _frameRate;
+
+    if (_frameRate !== 60 && _frameRate !== 30) {
+        window.requestAnimFrame = this._stTime;
+        window.cancelAnimFrame = this._ctTime;
+    }
+    else {
+        window.requestAnimFrame = window.requestAnimationFrame || this._stTime;
+        window.cancelAnimFrame = window.cancelAnimationFrame || this._ctTime;
+    }
+};
+
+cc.game.getFrameRate = function () {
+    return _frameRate;
+};
+
+cc.game._runMainLoop = function () {
+    var self = this, callback, config = self.config,
+        director = cc.director,
+        skip = true, frameRate = config.frameRate;
+
+    cc.debug.setDisplayStats(config.showFPS);
+
+    callback = function () {
+        if (!self._paused) {
+            self._intervalId = window.requestAnimFrame(callback);
+            if (frameRate === 30) {
+                if (skip = !skip) {
+                    return;
+                }
+            }
+            director.mainLoop();
+        }
+    };
+
+    self._intervalId = window.requestAnimFrame(callback);
+    self._paused = false;
+};
+// wechat game platform not support this api
+cc.game.end = function () {};

frontend/build-templates/wechatgame/libs/engine/downloader.js

@@ -0,0 +1,37 @@
+cc.loader.downloader.loadSubpackage = function (name, completeCallback) {
+    wx.loadSubpackage({
+        name: name,
+        success: function () {
+            if (completeCallback) completeCallback();
+        },
+        fail: function () {
+            if (completeCallback) completeCallback(new Error(`Failed to load subpackage ${name}`));
+        }
+    })
+};
+
+function downloadScript (item, callback, isAsync) {
+    var url = '../../' + item.url;
+    require(url);
+    callback(null, item.url);
+}
+
+function loadFont (item) {
+    var url = item.url;
+    var fontFamily = wx.loadFont(url);
+    return fontFamily || 'Arial';
+}
+
+cc.loader.downloader.addHandlers({
+    js : downloadScript
+});
+
+cc.loader.loader.addHandlers({
+    // Font
+    font: loadFont,
+    eot: loadFont,
+    ttf: loadFont,
+    woff: loadFont,
+    svg: loadFont,
+    ttc: loadFont,
+});

frontend/build-templates/wechatgame/libs/engine/index.js

@@ -0,0 +1,6 @@
+require('./Game');
+require('./Audio');
+require('./Editbox');
+require('./DeviceMotionEvent');
+require('./downloader');
+require('./misc');

frontend/build-templates/wechatgame/libs/engine/misc.js

@@ -0,0 +1,7 @@
+// cc.AuidioEngine
+if (cc && cc.audioEngine) {
+    cc.audioEngine._maxAudioInstance = 10;
+}
+
+// cc.Macro
+cc.macro.DOWNLOAD_MAX_CONCURRENT = 10;

frontend/build-templates/wechatgame/libs/weapp-adapter/Audio.js

@@ -0,0 +1,246 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = undefined;
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
+
+var _HTMLAudioElement2 = require('./HTMLAudioElement');
+
+var _HTMLAudioElement3 = _interopRequireDefault(_HTMLAudioElement2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var HAVE_NOTHING = 0;
+var HAVE_METADATA = 1;
+var HAVE_CURRENT_DATA = 2;
+var HAVE_FUTURE_DATA = 3;
+var HAVE_ENOUGH_DATA = 4;
+
+var SN_SEED = 1;
+
+var _innerAudioContextMap = {};
+
+var Audio = function (_HTMLAudioElement) {
+  _inherits(Audio, _HTMLAudioElement);
+
+  function Audio(url) {
+    _classCallCheck(this, Audio);
+
+    var _this = _possibleConstructorReturn(this, (Audio.__proto__ || Object.getPrototypeOf(Audio)).call(this));
+
+    _this._$sn = SN_SEED++;
+
+    _this.HAVE_NOTHING = HAVE_NOTHING;
+    _this.HAVE_METADATA = HAVE_METADATA;
+    _this.HAVE_CURRENT_DATA = HAVE_CURRENT_DATA;
+    _this.HAVE_FUTURE_DATA = HAVE_FUTURE_DATA;
+    _this.HAVE_ENOUGH_DATA = HAVE_ENOUGH_DATA;
+
+    _this.readyState = HAVE_NOTHING;
+
+    var innerAudioContext = wx.createInnerAudioContext();
+
+    _innerAudioContextMap[_this._$sn] = innerAudioContext;
+
+    _this._canplayEvents = ['load', 'loadend', 'canplay', 'canplaythrough', 'loadedmetadata'];
+
+    innerAudioContext.onCanplay(function () {
+      _this._loaded = true;
+      _this.readyState = _this.HAVE_CURRENT_DATA;
+      _this._canplayEvents.forEach(function (type) {
+        _this.dispatchEvent({ type: type });
+      });
+    });
+    innerAudioContext.onPlay(function () {
+      _this._paused = _innerAudioContextMap[_this._$sn].paused;
+      _this.dispatchEvent({ type: 'play' });
+    });
+    innerAudioContext.onPause(function () {
+      _this._paused = _innerAudioContextMap[_this._$sn].paused;
+      _this.dispatchEvent({ type: 'pause' });
+    });
+    innerAudioContext.onEnded(function () {
+      _this._paused = _innerAudioContextMap[_this._$sn].paused;
+      if (_innerAudioContextMap[_this._$sn].loop === false) {
+        _this.dispatchEvent({ type: 'ended' });
+      }
+      _this.readyState = HAVE_ENOUGH_DATA;
+    });
+    innerAudioContext.onError(function () {
+      _this._paused = _innerAudioContextMap[_this._$sn].paused;
+      _this.dispatchEvent({ type: 'error' });
+    });
+
+    if (url) {
+      _this.src = url;
+    } else {
+      _this._src = '';
+    }
+
+    _this._loop = innerAudioContext.loop;
+    _this._autoplay = innerAudioContext.autoplay;
+    _this._paused = innerAudioContext.paused;
+    _this._volume = innerAudioContext.volume;
+    _this._muted = false;
+    return _this;
+  }
+
+  _createClass(Audio, [{
+    key: 'addEventListener',
+    value: function addEventListener(type, listener) {
+      var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+
+      _get(Audio.prototype.__proto__ || Object.getPrototypeOf(Audio.prototype), 'addEventListener', this).call(this, type, listener, options);
+
+      type = String(type).toLowerCase();
+
+      if (this._loaded && this._canplayEvents.indexOf(type) !== -1) {
+        this.dispatchEvent({ type: type });
+      }
+    }
+  }, {
+    key: 'load',
+    value: function load() {
+      // console.warn('HTMLAudioElement.load() is not implemented.')
+      // weixin doesn't need call load() manually
+    }
+  }, {
+    key: 'play',
+    value: function play() {
+      _innerAudioContextMap[this._$sn].play();
+    }
+  }, {
+    key: 'resume',
+    value: function resume() {
+      _innerAudioContextMap[this._$sn].resume();
+    }
+  }, {
+    key: 'pause',
+    value: function pause() {
+      _innerAudioContextMap[this._$sn].pause();
+    }
+  }, {
+    key: 'stop',
+    value: function stop() {
+      _innerAudioContextMap[this._$sn].stop();
+    }
+  }, {
+    key: 'destroy',
+    value: function destroy() {
+      _innerAudioContextMap[this._$sn].destroy();
+    }
+  }, {
+    key: 'canPlayType',
+    value: function canPlayType() {
+      var mediaType = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+
+      if (typeof mediaType !== 'string') {
+        return '';
+      }
+
+      if (mediaType.indexOf('audio/mpeg') > -1 || mediaType.indexOf('audio/mp4')) {
+        return 'probably';
+      }
+      return '';
+    }
+  }, {
+    key: 'cloneNode',
+    value: function cloneNode() {
+      var newAudio = new Audio();
+      newAudio.loop = this.loop;
+      newAudio.autoplay = this.autoplay;
+      newAudio.src = this.src;
+      return newAudio;
+    }
+  }, {
+    key: 'currentTime',
+    get: function get() {
+      return _innerAudioContextMap[this._$sn].currentTime;
+    },
+    set: function set(value) {
+      _innerAudioContextMap[this._$sn].seek(value);
+    }
+  }, {
+    key: 'duration',
+    get: function get() {
+      return _innerAudioContextMap[this._$sn].duration;
+    }
+  }, {
+    key: 'src',
+    get: function get() {
+      return this._src;
+    },
+    set: function set(value) {
+      this._src = value;
+      this._loaded = false;
+      this.readyState = this.HAVE_NOTHING;
+
+      var innerAudioContext = _innerAudioContextMap[this._$sn];
+
+      innerAudioContext.src = value;
+    }
+  }, {
+    key: 'loop',
+    get: function get() {
+      return this._loop;
+    },
+    set: function set(value) {
+      this._loop = value;
+      _innerAudioContextMap[this._$sn].loop = value;
+    }
+  }, {
+    key: 'autoplay',
+    get: function get() {
+      return this.autoplay;
+    },
+    set: function set(value) {
+      this._autoplay = value;
+      _innerAudioContextMap[this._$sn].autoplay = value;
+    }
+  }, {
+    key: 'paused',
+    get: function get() {
+      return this._paused;
+    }
+  }, {
+    key: 'volume',
+    get: function get() {
+      return this._volume;
+    },
+    set: function set(value) {
+      this._volume = value;
+      if (!this._muted) {
+        _innerAudioContextMap[this._$sn].volume = value;
+      }
+    }
+  }, {
+    key: 'muted',
+    get: function get() {
+      return this._muted;
+    },
+    set: function set(value) {
+      this._muted = value;
+      if (value) {
+        _innerAudioContextMap[this._$sn].volume = 0;
+      } else {
+        _innerAudioContextMap[this._$sn].volume = this._volume;
+      }
+    }
+  }]);
+
+  return Audio;
+}(_HTMLAudioElement3.default);
+
+exports.default = Audio;
+module.exports = exports['default'];

frontend/build-templates/wechatgame/libs/weapp-adapter/Canvas.js

@@ -0,0 +1,76 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = Canvas;
+
+var _WindowProperties = require('./WindowProperties');
+
+var hasModifiedCanvasPrototype = false; // import HTMLCanvasElement from './HTMLCanvasElement'
+
+var hasInit2DContextConstructor = false;
+var hasInitWebGLContextConstructor = false;
+
+function Canvas() {
+  var canvas = wx.createCanvas();
+
+  canvas.type = 'canvas';
+
+  // canvas.__proto__.__proto__.__proto__ = new HTMLCanvasElement()
+
+  var _getContext = canvas.getContext;
+
+  canvas.getBoundingClientRect = function () {
+    var ret = {
+      top: 0,
+      left: 0,
+      width: window.innerWidth,
+      height: window.innerHeight
+    };
+    return ret;
+  };
+
+  canvas.style = {
+    top: '0px',
+    left: '0px',
+    width: _WindowProperties.innerWidth + 'px',
+    height: _WindowProperties.innerHeight + 'px'
+  };
+
+  canvas.addEventListener = function (type, listener) {
+    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+
+    // console.log('canvas.addEventListener', type);
+    document.addEventListener(type, listener, options);
+  };
+
+  canvas.removeEventListener = function (type, listener) {
+    // console.log('canvas.removeEventListener', type);
+    document.removeEventListener(type, listener);
+  };
+
+  canvas.dispatchEvent = function () {
+    var event = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+    console.log('canvas.dispatchEvent', event.type, event);
+    // nothing to do
+  };
+
+  Object.defineProperty(canvas, 'clientWidth', {
+    enumerable: true,
+    get: function get() {
+      return _WindowProperties.innerWidth;
+    }
+  });
+
+  Object.defineProperty(canvas, 'clientHeight', {
+    enumerable: true,
+    get: function get() {
+      return _WindowProperties.innerHeight;
+    }
+  });
+
+  return canvas;
+}
+module.exports = exports['default'];

frontend/build-templates/wechatgame/libs/weapp-adapter/Element.js

@@ -0,0 +1,37 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = undefined;
+
+var _Node2 = require('./Node');
+
+var _Node3 = _interopRequireDefault(_Node2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var Element = function (_Node) {
+  _inherits(Element, _Node);
+
+  function Element() {
+    _classCallCheck(this, Element);
+
+    var _this = _possibleConstructorReturn(this, (Element.__proto__ || Object.getPrototypeOf(Element)).call(this));
+
+    _this.className = '';
+    _this.children = [];
+    return _this;
+  }
+
+  return Element;
+}(_Node3.default);
+
+exports.default = Element;
+module.exports = exports['default'];

frontend/build-templates/wechatgame/libs/weapp-adapter/Event.js

@@ -0,0 +1,26 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = undefined;
+
+var _util = require('./util');
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var Event = function Event(type) {
+  _classCallCheck(this, Event);
+
+  this.cancelBubble = false;
+  this.cancelable = false;
+  this.target = null;
+  this.timestampe = Date.now();
+  this.preventDefault = _util.noop;
+  this.stopPropagation = _util.noop;
+
+  this.type = type;
+};
+
+exports.default = Event;
+module.exports = exports['default'];

frontend/build-templates/wechatgame/libs/weapp-adapter/EventIniter/MouseEvent.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var MouseEvent = function MouseEvent() {
+    _classCallCheck(this, MouseEvent);
+};
+
+exports.default = MouseEvent;
+module.exports = exports["default"];

frontend/build-templates/wechatgame/libs/weapp-adapter/EventIniter/TouchEvent.js

@@ -0,0 +1,45 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = undefined;
+
+var _index = require('../util/index.js');
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var TouchEvent = function TouchEvent(type) {
+  _classCallCheck(this, TouchEvent);
+
+  this.touches = [];
+  this.targetTouches = [];
+  this.changedTouches = [];
+  this.preventDefault = _index.noop;
+  this.stopPropagation = _index.noop;
+
+  this.type = type;
+  this.target = window.canvas;
+  this.currentTarget = window.canvas;
+};
+
+exports.default = TouchEvent;
+
+
+function touchEventHandlerFactory(type) {
+  return function (event) {
+    var touchEvent = new TouchEvent(type);
+
+    touchEvent.touches = event.touches;
+    touchEvent.targetTouches = Array.prototype.slice.call(event.touches);
+    touchEvent.changedTouches = event.changedTouches;
+    touchEvent.timeStamp = event.timeStamp;
+    document.dispatchEvent(touchEvent);
+  };
+}
+
+wx.onTouchStart(touchEventHandlerFactory('touchstart'));
+wx.onTouchMove(touchEventHandlerFactory('touchmove'));
+wx.onTouchEnd(touchEventHandlerFactory('touchend'));
+wx.onTouchCancel(touchEventHandlerFactory('touchcancel'));
+module.exports = exports['default'];

frontend/build-templates/wechatgame/libs/weapp-adapter/EventIniter/index.js

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MouseEvent = exports.TouchEvent = undefined;
+
+var _TouchEvent2 = require('./TouchEvent');
+
+var _TouchEvent3 = _interopRequireDefault(_TouchEvent2);
+
+var _MouseEvent2 = require('./MouseEvent');
+
+var _MouseEvent3 = _interopRequireDefault(_MouseEvent2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.TouchEvent = _TouchEvent3.default;
+exports.MouseEvent = _MouseEvent3.default;

frontend/build-templates/wechatgame/libs/weapp-adapter/EventTarget.js

@@ -0,0 +1,83 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var _events = new WeakMap();
+
+var EventTarget = function () {
+  function EventTarget() {
+    _classCallCheck(this, EventTarget);
+
+    _events.set(this, {});
+  }
+
+  _createClass(EventTarget, [{
+    key: "addEventListener",
+    value: function addEventListener(type, listener) {
+      var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+
+      var events = _events.get(this);
+
+      if (!events) {
+        events = {};
+        _events.set(this, events);
+      }
+      if (!events[type]) {
+        events[type] = [];
+      }
+      events[type].push(listener);
+
+      if (options.capture) {
+        // console.warn('EventTarget.addEventListener: options.capture is not implemented.')
+      }
+      if (options.once) {
+        // console.warn('EventTarget.addEventListener: options.once is not implemented.')
+      }
+      if (options.passive) {
+        // console.warn('EventTarget.addEventListener: options.passive is not implemented.')
+      }
+    }
+  }, {
+    key: "removeEventListener",
+    value: function removeEventListener(type, listener) {
+      var events = _events.get(this);
+
+      if (events) {
+        var listeners = events[type];
+
+        if (listeners && listeners.length > 0) {
+          for (var i = listeners.length; i--; i > 0) {
+            if (listeners[i] === listener) {
+              listeners.splice(i, 1);
+              break;
+            }
+          }
+        }
+      }
+    }
+  }, {
+    key: "dispatchEvent",
+    value: function dispatchEvent() {
+      var event = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+      var listeners = _events.get(this)[event.type];
+
+      if (listeners) {
+        for (var i = 0; i < listeners.length; i++) {
+          listeners[i](event);
+        }
+      }
+    }
+  }]);
+
+  return EventTarget;
+}();
+
+exports.default = EventTarget;
+module.exports = exports["default"];

frontend/build-templates/wechatgame/libs/weapp-adapter/FileReader.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+/*
+ * TODO 使用 wx.readFile 来封装 FileReader
+ */
+var FileReader = function () {
+  function FileReader() {
+    _classCallCheck(this, FileReader);
+  }
+
+  _createClass(FileReader, [{
+    key: "construct",
+    value: function construct() {}
+  }]);
+
+  return FileReader;
+}();
+
+exports.default = FileReader;
+module.exports = exports["default"];

frontend/build-templates/wechatgame/libs/weapp-adapter/HTMLAudioElement.js

@@ -0,0 +1,33 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = undefined;
+
+var _HTMLMediaElement2 = require('./HTMLMediaElement');
+
+var _HTMLMediaElement3 = _interopRequireDefault(_HTMLMediaElement2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var HTMLAudioElement = function (_HTMLMediaElement) {
+  _inherits(HTMLAudioElement, _HTMLMediaElement);
+
+  function HTMLAudioElement() {
+    _classCallCheck(this, HTMLAudioElement);
+
+    return _possibleConstructorReturn(this, (HTMLAudioElement.__proto__ || Object.getPrototypeOf(HTMLAudioElement)).call(this, 'audio'));
+  }
+
+  return HTMLAudioElement;
+}(_HTMLMediaElement3.default);
+
+exports.default = HTMLAudioElement;
+module.exports = exports['default'];

frontend/build-templates/wechatgame/libs/weapp-adapter/HTMLCanvasElement.js

@@ -0,0 +1,34 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _Canvas = require('./Canvas');
+
+var _Canvas2 = _interopRequireDefault(_Canvas);
+
+var _HTMLElement = require('./HTMLElement');
+
+var _HTMLElement2 = _interopRequireDefault(_HTMLElement);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// import HTMLElement from './HTMLElement';
+
+// export default class HTMLCanvasElement extends HTMLElement
+// {
+//     constructor(){
+//         super('canvas')
+//     }
+// };
+
+GameGlobal.screencanvas = GameGlobal.screencanvas || new _Canvas2.default();
+var canvas = GameGlobal.screencanvas;
+
+var canvasConstructor = canvas.constructor;
+
+// canvasConstructor.__proto__.__proto__ = new HTMLElement();
+
+exports.default = canvasConstructor;
+module.exports = exports['default'];

frontend/build-templates/wechatgame/libs/weapp-adapter/HTMLElement.js

@@ -0,0 +1,92 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = undefined;
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _Element2 = require('./Element');
+
+var _Element3 = _interopRequireDefault(_Element2);
+
+var _index = require('./util/index.js');
+
+var _WindowProperties = require('./WindowProperties');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var HTMLElement = function (_Element) {
+  _inherits(HTMLElement, _Element);
+
+  function HTMLElement() {
+    var tagName = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+
+    _classCallCheck(this, HTMLElement);
+
+    var _this = _possibleConstructorReturn(this, (HTMLElement.__proto__ || Object.getPrototypeOf(HTMLElement)).call(this));
+
+    _this.className = '';
+    _this.childern = [];
+    _this.style = {
+      width: _WindowProperties.innerWidth + 'px',
+      height: _WindowProperties.innerHeight + 'px'
+    };
+    _this.insertBefore = _index.noop;
+    _this.innerHTML = '';
+
+    _this.tagName = tagName.toUpperCase();
+    return _this;
+  }
+
+  _createClass(HTMLElement, [{
+    key: 'setAttribute',
+    value: function setAttribute(name, value) {
+      this[name] = value;
+    }
+  }, {
+    key: 'getAttribute',
+    value: function getAttribute(name) {
+      return this[name];
+    }
+  }, {
+    key: 'getBoundingClientRect',
+    value: function getBoundingClientRect() {
+      return {
+        top: 0,
+        left: 0,
+        width: _WindowProperties.innerWidth,
+        height: _WindowProperties.innerHeight
+      };
+    }
+  }, {
+    key: 'focus',
+    value: function focus() {}
+  }, {
+    key: 'clientWidth',
+    get: function get() {
+      var ret = parseInt(this.style.fontSize, 10) * this.innerHTML.length;
+
+      return Number.isNaN(ret) ? 0 : ret;
+    }
+  }, {
+    key: 'clientHeight',
+    get: function get() {
+      var ret = parseInt(this.style.fontSize, 10);
+
+      return Number.isNaN(ret) ? 0 : ret;
+    }
+  }]);
+
+  return HTMLElement;
+}(_Element3.default);
+
+exports.default = HTMLElement;
+module.exports = exports['default'];

frontend/build-templates/wechatgame/libs/weapp-adapter/HTMLImageElement.js

@@ -0,0 +1,27 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _HTMLElement = require('./HTMLElement');
+
+var _HTMLElement2 = _interopRequireDefault(_HTMLElement);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var imageConstructor = wx.createImage().constructor;
+
+// imageConstructor.__proto__.__proto__ = new HTMLElement();
+
+// import HTMLElement from './HTMLElement';
+
+// export default class HTMLImageElement extends HTMLElement
+// {
+//     constructor(){
+//         super('img')
+//     }
+// };
+
+exports.default = imageConstructor;
+module.exports = exports['default'];

frontend/build-templates/wechatgame/libs/weapp-adapter/HTMLMediaElement.js

@@ -0,0 +1,55 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = undefined;
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _HTMLElement2 = require('./HTMLElement');
+
+var _HTMLElement3 = _interopRequireDefault(_HTMLElement2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var HTMLMediaElement = function (_HTMLElement) {
+  _inherits(HTMLMediaElement, _HTMLElement);
+
+  function HTMLMediaElement(type) {
+    _classCallCheck(this, HTMLMediaElement);
+
+    return _possibleConstructorReturn(this, (HTMLMediaElement.__proto__ || Object.getPrototypeOf(HTMLMediaElement)).call(this, type));
+  }
+
+  _createClass(HTMLMediaElement, [{
+    key: 'addTextTrack',
+    value: function addTextTrack() {}
+  }, {
+    key: 'captureStream',
+    value: function captureStream() {}
+  }, {
+    key: 'fastSeek',
+    value: function fastSeek() {}
+  }, {
+    key: 'load',
+    value: function load() {}
+  }, {
+    key: 'pause',
+    value: function pause() {}
+  }, {
+    key: 'play',
+    value: function play() {}
+  }]);
+
+  return HTMLMediaElement;
+}(_HTMLElement3.default);
+
+exports.default = HTMLMediaElement;
+module.exports = exports['default'];

frontend/build-templates/wechatgame/libs/weapp-adapter/HTMLVideoElement.js

@@ -0,0 +1,34 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.default = undefined;
+
+var _HTMLMediaElement2 = require('./HTMLMediaElement');
+
+var _HTMLMediaElement3 = _interopRequireDefault(_HTMLMediaElement2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var HTMLVideoElement = function (_HTMLMediaElement) {
+    _inherits(HTMLVideoElement, _HTMLMediaElement);
+
+    function HTMLVideoElement() {
+        _classCallCheck(this, HTMLVideoElement);
+
+        return _possibleConstructorReturn(this, (HTMLVideoElement.__proto__ || Object.getPrototypeOf(HTMLVideoElement)).call(this, 'video'));
+    }
+
+    return HTMLVideoElement;
+}(_HTMLMediaElement3.default);
+
+exports.default = HTMLVideoElement;
+;
+module.exports = exports['default'];

frontend/build-templates/wechatgame/libs/weapp-adapter/Image.js

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+exports.default = function () {
+    var image = wx.createImage();
+
+    // image.__proto__.__proto__.__proto__ = new HTMLImageElement();
+
+    return image;
+};
+
+var _HTMLImageElement = require('./HTMLImageElement');
+
+var _HTMLImageElement2 = _interopRequireDefault(_HTMLImageElement);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+;
+module.exports = exports['default'];

frontend/build-templates/wechatgame/libs/weapp-adapter/ImageBitmap.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var ImageBitmap = function ImageBitmap() {
+    // TODO
+
+    _classCallCheck(this, ImageBitmap);
+};
+
+exports.default = ImageBitmap;
+module.exports = exports["default"];

frontend/build-templates/wechatgame/libs/weapp-adapter/Node.js

@@ -0,0 +1,70 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = undefined;
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _EventTarget2 = require('./EventTarget.js');
+
+var _EventTarget3 = _interopRequireDefault(_EventTarget2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var Node = function (_EventTarget) {
+  _inherits(Node, _EventTarget);
+
+  function Node() {
+    _classCallCheck(this, Node);
+
+    var _this = _possibleConstructorReturn(this, (Node.__proto__ || Object.getPrototypeOf(Node)).call(this));
+
+    _this.childNodes = [];
+    return _this;
+  }
+
+  _createClass(Node, [{
+    key: 'appendChild',
+    value: function appendChild(node) {
+      this.childNodes.push(node);
+      // if (node instanceof Node) {
+      //   this.childNodes.push(node)
+      // } else {
+      //   throw new TypeError('Failed to executed \'appendChild\' on \'Node\': parameter 1 is not of type \'Node\'.')
+      // }
+    }
+  }, {
+    key: 'cloneNode',
+    value: function cloneNode() {
+      var copyNode = Object.create(this);
+
+      Object.assign(copyNode, this);
+      return copyNode;
+    }
+  }, {
+    key: 'removeChild',
+    value: function removeChild(node) {
+      var index = this.childNodes.findIndex(function (child) {
+        return child === node;
+      });
+
+      if (index > -1) {
+        return this.childNodes.splice(index, 1);
+      }
+      return null;
+    }
+  }]);
+
+  return Node;
+}(_EventTarget3.default);
+
+exports.default = Node;
+module.exports = exports['default'];

frontend/build-templates/wechatgame/libs/weapp-adapter/WebGLRenderingContext.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var WebGLRenderingContext = function WebGLRenderingContext() {
+    // TODO
+
+    _classCallCheck(this, WebGLRenderingContext);
+};
+
+exports.default = WebGLRenderingContext;
+module.exports = exports["default"];

frontend/build-templates/wechatgame/libs/weapp-adapter/WebSocket.js

@@ -0,0 +1,114 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _class, _temp;
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var _socketTask = new WeakMap();
+
+var WebSocket = (_temp = _class = function () {
+  // TODO 更新 binaryType
+  // The connection is in the process of closing.
+  // The connection is not yet open.
+  function WebSocket(url) {
+    var _this = this;
+
+    var protocols = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+
+    _classCallCheck(this, WebSocket);
+
+    this.binaryType = '';
+    this.bufferedAmount = 0;
+    this.extensions = '';
+    this.onclose = null;
+    this.onerror = null;
+    this.onmessage = null;
+    this.onopen = null;
+    this.protocol = '';
+    this.readyState = 3;
+
+    if (typeof url !== 'string' || !/(^ws:\/\/)|(^wss:\/\/)/.test(url)) {
+      throw new TypeError('Failed to construct \'WebSocket\': The URL \'' + url + '\' is invalid');
+    }
+
+    this.url = url;
+    this.readyState = WebSocket.CONNECTING;
+
+    var socketTask = wx.connectSocket({
+      url: url,
+      protocols: Array.isArray(protocols) ? protocols : [protocols],
+      tcpNoDelay: true
+    });
+
+    _socketTask.set(this, socketTask);
+
+    socketTask.onClose(function (res) {
+      _this.readyState = WebSocket.CLOSED;
+      if (typeof _this.onclose === 'function') {
+        _this.onclose(res);
+      }
+    });
+
+    socketTask.onMessage(function (res) {
+      if (typeof _this.onmessage === 'function') {
+        _this.onmessage(res);
+      }
+    });
+
+    socketTask.onOpen(function () {
+      _this.readyState = WebSocket.OPEN;
+      if (typeof _this.onopen === 'function') {
+        _this.onopen();
+      }
+    });
+
+    socketTask.onError(function (res) {
+      if (typeof _this.onerror === 'function') {
+        _this.onerror(new Error(res.errMsg));
+      }
+    });
+
+    return this;
+  } // TODO 小程序内目前获取不到，实际上需要根据服务器选择的 sub-protocol 返回
+  // TODO 更新 bufferedAmount
+  // The connection is closed or couldn't be opened.
+
+  // The connection is open and ready to communicate.
+
+
+  _createClass(WebSocket, [{
+    key: 'close',
+    value: function close(code, reason) {
+      this.readyState = WebSocket.CLOSING;
+      var socketTask = _socketTask.get(this);
+
+      socketTask.close({
+        code: code,
+        reason: reason
+      });
+    }
+  }, {
+    key: 'send',
+    value: function send(data) {
+      if (typeof data !== 'string' && !(data instanceof ArrayBuffer)) {
+        throw new TypeError('Failed to send message: The data ' + data + ' is invalid');
+      }
+
+      var socketTask = _socketTask.get(this);
+
+      socketTask.send({
+        data: data
+      });
+    }
+  }]);
+
+  return WebSocket;
+}(), _class.CONNECTING = 0, _class.OPEN = 1, _class.CLOSING = 2, _class.CLOSED = 3, _temp);
+exports.default = WebSocket;
+module.exports = exports['default'];

frontend/build-templates/wechatgame/libs/weapp-adapter/WindowProperties.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _wx$getSystemInfoSync = wx.getSystemInfoSync(),
+    screenWidth = _wx$getSystemInfoSync.screenWidth,
+    screenHeight = _wx$getSystemInfoSync.screenHeight,
+    devicePixelRatio = _wx$getSystemInfoSync.devicePixelRatio;
+
+var innerWidth = exports.innerWidth = screenWidth;
+var innerHeight = exports.innerHeight = screenHeight;
+exports.devicePixelRatio = devicePixelRatio;
+var screen = exports.screen = {
+  width: screenWidth,
+  height: screenHeight,
+  availWidth: innerWidth,
+  availHeight: innerHeight,
+  availLeft: 0,
+  availTop: 0
+};
+
+var performance = exports.performance = {
+  now: Date.now
+};
+
+var ontouchstart = exports.ontouchstart = null;
+var ontouchmove = exports.ontouchmove = null;
+var ontouchend = exports.ontouchend = null;

frontend/build-templates/wechatgame/libs/weapp-adapter/Worker.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+exports.default = function (file) {
+    var worker = wx.createWorker(file);
+
+    return worker;
+};
+
+;
+module.exports = exports["default"];

frontend/build-templates/wechatgame/libs/weapp-adapter/XMLHttpRequest.js

@@ -0,0 +1,210 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = undefined;
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _class, _temp;
+
+var _EventTarget2 = require('./EventTarget.js');
+
+var _EventTarget3 = _interopRequireDefault(_EventTarget2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var _url = new WeakMap();
+var _method = new WeakMap();
+var _requestHeader = new WeakMap();
+var _responseHeader = new WeakMap();
+var _requestTask = new WeakMap();
+
+function _triggerEvent(type) {
+  if (typeof this['on' + type] === 'function') {
+    for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      args[_key - 1] = arguments[_key];
+    }
+
+    this['on' + type].apply(this, args);
+  }
+}
+
+function _changeReadyState(readyState) {
+  this.readyState = readyState;
+  _triggerEvent.call(this, 'readystatechange');
+}
+
+var XMLHttpRequest = (_temp = _class = function (_EventTarget) {
+  _inherits(XMLHttpRequest, _EventTarget);
+
+  // TODO 没法模拟 HEADERS_RECEIVED 和 LOADING 两个状态
+  function XMLHttpRequest() {
+    _classCallCheck(this, XMLHttpRequest);
+
+    var _this2 = _possibleConstructorReturn(this, (XMLHttpRequest.__proto__ || Object.getPrototypeOf(XMLHttpRequest)).call(this));
+
+    _this2.onabort = null;
+    _this2.onerror = null;
+    _this2.onload = null;
+    _this2.onloadstart = null;
+    _this2.onprogress = null;
+    _this2.ontimeout = null;
+    _this2.onloadend = null;
+    _this2.onreadystatechange = null;
+    _this2.readyState = 0;
+    _this2.response = null;
+    _this2.responseText = null;
+    _this2.responseType = '';
+    _this2.responseXML = null;
+    _this2.status = 0;
+    _this2.statusText = '';
+    _this2.upload = {};
+    _this2.withCredentials = false;
+
+
+    _requestHeader.set(_this2, {
+      'content-type': 'application/x-www-form-urlencoded'
+    });
+    _responseHeader.set(_this2, {});
+    return _this2;
+  }
+
+  /*
+   * TODO 这一批事件应该是在 XMLHttpRequestEventTarget.prototype 上面的
+   */
+
+
+  _createClass(XMLHttpRequest, [{
+    key: 'abort',
+    value: function abort() {
+      var myRequestTask = _requestTask.get(this);
+
+      if (myRequestTask) {
+        myRequestTask.abort();
+      }
+    }
+  }, {
+    key: 'getAllResponseHeaders',
+    value: function getAllResponseHeaders() {
+      var responseHeader = _responseHeader.get(this);
+
+      return Object.keys(responseHeader).map(function (header) {
+        return header + ': ' + responseHeader[header];
+      }).join('\n');
+    }
+  }, {
+    key: 'getResponseHeader',
+    value: function getResponseHeader(header) {
+      return _responseHeader.get(this)[header];
+    }
+  }, {
+    key: 'open',
+    value: function open(method, url /* async, user, password 这几个参数在小程序内不支持*/) {
+      _method.set(this, method);
+      _url.set(this, url);
+      _changeReadyState.call(this, XMLHttpRequest.OPENED);
+    }
+  }, {
+    key: 'overrideMimeType',
+    value: function overrideMimeType() {}
+  }, {
+    key: 'send',
+    value: function send() {
+      var _this3 = this;
+
+      var data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+
+      if (this.readyState !== XMLHttpRequest.OPENED) {
+        throw new Error("Failed to execute 'send' on 'XMLHttpRequest': The object's state must be OPENED.");
+      } else {
+        wx.request({
+          data: data,
+          url: _url.get(this),
+          method: _method.get(this),
+          header: _requestHeader.get(this),
+          responseType: this.responseType,
+          success: function success(_ref) {
+            var data = _ref.data,
+                statusCode = _ref.statusCode,
+                header = _ref.header;
+
+            if (typeof data !== 'string' && !(data instanceof ArrayBuffer)) {
+              try {
+                data = JSON.stringify(data);
+              } catch (e) {
+                data = data;
+              }
+            }
+
+            _this3.status = statusCode;
+            _responseHeader.set(_this3, header);
+            _triggerEvent.call(_this3, 'loadstart');
+            _changeReadyState.call(_this3, XMLHttpRequest.HEADERS_RECEIVED);
+            _changeReadyState.call(_this3, XMLHttpRequest.LOADING);
+
+            _this3.response = data;
+
+            if (data instanceof ArrayBuffer) {
+              _this3.responseText = '';
+              var bytes = new Uint8Array(data);
+              var len = bytes.byteLength;
+
+              for (var i = 0; i < len; i++) {
+                _this3.responseText += String.fromCharCode(bytes[i]);
+              }
+            } else {
+              _this3.responseText = data;
+            }
+            _changeReadyState.call(_this3, XMLHttpRequest.DONE);
+            _triggerEvent.call(_this3, 'load');
+            _triggerEvent.call(_this3, 'loadend');
+          },
+          fail: function fail(_ref2) {
+            var errMsg = _ref2.errMsg;
+
+            // TODO 规范错误
+            if (errMsg.indexOf('abort') !== -1) {
+              _triggerEvent.call(_this3, 'abort');
+            } else if (errMsg.indexOf('timeout') !== -1) {
+              _triggerEvent.call(_this3, 'timeout');
+            } else {
+              _triggerEvent.call(_this3, 'error', errMsg);
+            }
+            _triggerEvent.call(_this3, 'loadend');
+          }
+        });
+      }
+    }
+  }, {
+    key: 'setRequestHeader',
+    value: function setRequestHeader(header, value) {
+      var myHeader = _requestHeader.get(this);
+
+      myHeader[header] = value;
+      _requestHeader.set(this, myHeader);
+    }
+  }, {
+    key: 'addEventListener',
+    value: function addEventListener(type, listener) {
+      if (typeof listener === 'function') {
+        var _this = this;
+        var event = { target: _this };
+        this['on' + type] = function (event) {
+          listener.call(_this, event);
+        };
+      }
+    }
+  }]);
+
+  return XMLHttpRequest;
+}(_EventTarget3.default), _class.UNSEND = 0, _class.OPENED = 1, _class.HEADERS_RECEIVED = 2, _class.LOADING = 3, _class.DONE = 4, _temp);
+exports.default = XMLHttpRequest;
+module.exports = exports['default'];

frontend/build-templates/wechatgame/libs/weapp-adapter/document.js

@@ -0,0 +1,147 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _window = require('./window');
+
+var window = _interopRequireWildcard(_window);
+
+var _HTMLElement = require('./HTMLElement');
+
+var _HTMLElement2 = _interopRequireDefault(_HTMLElement);
+
+var _HTMLVideoElement = require('./HTMLVideoElement');
+
+var _HTMLVideoElement2 = _interopRequireDefault(_HTMLVideoElement);
+
+var _Image = require('./Image');
+
+var _Image2 = _interopRequireDefault(_Image);
+
+var _Audio = require('./Audio');
+
+var _Audio2 = _interopRequireDefault(_Audio);
+
+var _Canvas = require('./Canvas');
+
+var _Canvas2 = _interopRequireDefault(_Canvas);
+
+require('./EventIniter/index.js');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+var events = {};
+
+var document = {
+  readyState: 'complete',
+  visibilityState: 'visible',
+  documentElement: window,
+  hidden: false,
+  style: {},
+  location: window.location,
+  ontouchstart: null,
+  ontouchmove: null,
+  ontouchend: null,
+
+  head: new _HTMLElement2.default('head'),
+  body: new _HTMLElement2.default('body'),
+
+  createElement: function createElement(tagName) {
+    if (tagName === 'canvas') {
+      return new _Canvas2.default();
+    } else if (tagName === 'audio') {
+      return new _Audio2.default();
+    } else if (tagName === 'img') {
+      return new _Image2.default();
+    } else if (tagName === 'video') {
+      return new _HTMLVideoElement2.default();
+    }
+
+    return new _HTMLElement2.default(tagName);
+  },
+  createElementNS: function createElementNS(nameSpace, tagName) {
+    return this.createElement(tagName);
+  },
+  getElementById: function getElementById(id) {
+    if (id === window.canvas.id) {
+      return window.canvas;
+    }
+    return null;
+  },
+  getElementsByTagName: function getElementsByTagName(tagName) {
+    if (tagName === 'head') {
+      return [document.head];
+    } else if (tagName === 'body') {
+      return [document.body];
+    } else if (tagName === 'canvas') {
+      return [window.canvas];
+    }
+    return [];
+  },
+  getElementsByName: function getElementsByName(tagName) {
+    if (tagName === 'head') {
+      return [document.head];
+    } else if (tagName === 'body') {
+      return [document.body];
+    } else if (tagName === 'canvas') {
+      return [window.canvas];
+    }
+    return [];
+  },
+  querySelector: function querySelector(query) {
+    if (query === 'head') {
+      return document.head;
+    } else if (query === 'body') {
+      return document.body;
+    } else if (query === 'canvas') {
+      return window.canvas;
+    } else if (query === '#' + window.canvas.id) {
+      return window.canvas;
+    }
+    return null;
+  },
+  querySelectorAll: function querySelectorAll(query) {
+    if (query === 'head') {
+      return [document.head];
+    } else if (query === 'body') {
+      return [document.body];
+    } else if (query === 'canvas') {
+      return [window.canvas];
+    }
+    return [];
+  },
+  addEventListener: function addEventListener(type, listener) {
+    if (!events[type]) {
+      events[type] = [];
+    }
+    events[type].push(listener);
+  },
+  removeEventListener: function removeEventListener(type, listener) {
+    var listeners = events[type];
+
+    if (listeners && listeners.length > 0) {
+      for (var i = listeners.length; i--; i > 0) {
+        if (listeners[i] === listener) {
+          listeners.splice(i, 1);
+          break;
+        }
+      }
+    }
+  },
+  dispatchEvent: function dispatchEvent(event) {
+    var listeners = events[event.type];
+
+    if (listeners) {
+      for (var i = 0; i < listeners.length; i++) {
+        listeners[i](event);
+      }
+    }
+  }
+};
+
+exports.default = document;
+module.exports = exports['default'];

frontend/build-templates/wechatgame/libs/weapp-adapter/index.js

@@ -0,0 +1,77 @@
+'use strict';
+
+var _window2 = require('./window');
+
+var _window = _interopRequireWildcard(_window2);
+
+var _document = require('./document');
+
+var _document2 = _interopRequireDefault(_document);
+
+var _HTMLElement = require('./HTMLElement');
+
+var _HTMLElement2 = _interopRequireDefault(_HTMLElement);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+var global = GameGlobal;
+
+function inject() {
+  _window.document = _document2.default;
+
+  _window.addEventListener = function (type, listener) {
+    _window.document.addEventListener(type, listener);
+  };
+  _window.removeEventListener = function (type, listener) {
+    _window.document.removeEventListener(type, listener);
+  };
+  _window.dispatchEvent = function () {
+    var event = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+    console.log('window.dispatchEvent', event.type, event);
+    // nothing to do
+  };
+
+  var _wx$getSystemInfoSync = wx.getSystemInfoSync(),
+      platform = _wx$getSystemInfoSync.platform;
+
+  // 开发者工具无法重定义 window
+
+
+  if (typeof __devtoolssubcontext === 'undefined' && platform === 'devtools') {
+    for (var key in _window) {
+      var descriptor = Object.getOwnPropertyDescriptor(global, key);
+
+      if (!descriptor || descriptor.configurable === true) {
+        Object.defineProperty(window, key, {
+          value: _window[key]
+        });
+      }
+    }
+
+    for (var _key in _window.document) {
+      var _descriptor = Object.getOwnPropertyDescriptor(global.document, _key);
+
+      if (!_descriptor || _descriptor.configurable === true) {
+        Object.defineProperty(global.document, _key, {
+          value: _window.document[_key]
+        });
+      }
+    }
+    window.parent = window;
+  } else {
+    for (var _key2 in _window) {
+      global[_key2] = _window[_key2];
+    }
+    global.window = _window;
+    window = global;
+    window.top = window.parent = window;
+  }
+}
+
+if (!GameGlobal.__isAdapterInjected) {
+  GameGlobal.__isAdapterInjected = true;
+  inject();
+}

frontend/build-templates/wechatgame/libs/weapp-adapter/localStorage.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var localStorage = {
+  get length() {
+    var _wx$getStorageInfoSyn = wx.getStorageInfoSync(),
+        keys = _wx$getStorageInfoSyn.keys;
+
+    return keys.length;
+  },
+
+  key: function key(n) {
+    var _wx$getStorageInfoSyn2 = wx.getStorageInfoSync(),
+        keys = _wx$getStorageInfoSyn2.keys;
+
+    return keys[n];
+  },
+  getItem: function getItem(key) {
+    return wx.getStorageSync(key);
+  },
+  setItem: function setItem(key, value) {
+    return wx.setStorageSync(key, value);
+  },
+  removeItem: function removeItem(key) {
+    wx.removeStorageSync(key);
+  },
+  clear: function clear() {
+    wx.clearStorageSync();
+  }
+};
+
+exports.default = localStorage;
+module.exports = exports["default"];

frontend/build-templates/wechatgame/libs/weapp-adapter/location.js

@@ -0,0 +1,12 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var location = {
+  href: 'game.js',
+  reload: function reload() {}
+};
+
+exports.default = location;
+module.exports = exports['default'];

frontend/build-templates/wechatgame/libs/weapp-adapter/navigator.js

@@ -0,0 +1,45 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _index = require('./util/index.js');
+
+// TODO 需要 wx.getSystemInfo 获取更详细信息
+var systemInfo = wx.getSystemInfoSync();
+console.log(systemInfo);
+
+var system = systemInfo.system;
+var platform = systemInfo.platform;
+var language = systemInfo.language;
+var wechatVersioin = systemInfo.version;
+
+var android = system.toLowerCase().indexOf('android') !== -1;
+
+var uaDesc = android ? 'Android; CPU ' + system : 'iPhone; CPU iPhone OS ' + system + ' like Mac OS X';
+var ua = 'Mozilla/5.0 (' + uaDesc + ') AppleWebKit/603.1.30 (KHTML, like Gecko) Mobile/14E8301 MicroMessenger/' + wechatVersioin + ' MiniGame NetType/WIFI Language/' + language;
+
+var navigator = {
+  platform: platform,
+  language: language,
+  appVersion: '5.0 (' + uaDesc + ') AppleWebKit/601.1.46 (KHTML, like Gecko) Version/9.0 Mobile/13B143 Safari/601.1',
+  userAgent: ua,
+  onLine: true, // TODO 用 wx.getNetworkStateChange 和 wx.onNetworkStateChange 来返回真实的状态
+
+  // TODO 用 wx.getLocation 来封装 geolocation
+  geolocation: {
+    getCurrentPosition: _index.noop,
+    watchPosition: _index.noop,
+    clearWatch: _index.noop
+  }
+};
+
+if (wx.onNetworkStatusChange) {
+  wx.onNetworkStatusChange(function (event) {
+    navigator.onLine = event.isConnected;
+  });
+}
+
+exports.default = navigator;
+module.exports = exports['default'];

frontend/build-templates/wechatgame/libs/weapp-adapter/util/index.js

@@ -0,0 +1,7 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.noop = noop;
+function noop() {}

frontend/build-templates/wechatgame/libs/weapp-adapter/window.js

@@ -0,0 +1,139 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cancelAnimationFrame = exports.requestAnimationFrame = exports.clearInterval = exports.clearTimeout = exports.setInterval = exports.setTimeout = exports.canvas = exports.location = exports.localStorage = exports.DeviceMotionEvent = exports.MouseEvent = exports.TouchEvent = exports.WebGLRenderingContext = exports.HTMLVideoElement = exports.HTMLAudioElement = exports.HTMLMediaElement = exports.HTMLCanvasElement = exports.HTMLImageElement = exports.HTMLElement = exports.FileReader = exports.Audio = exports.ImageBitmap = exports.Image = exports.WebSocket = exports.XMLHttpRequest = exports.navigator = undefined;
+
+var _index = require('./EventIniter/index.js');
+
+Object.defineProperty(exports, 'TouchEvent', {
+  enumerable: true,
+  get: function get() {
+    return _index.TouchEvent;
+  }
+});
+Object.defineProperty(exports, 'MouseEvent', {
+  enumerable: true,
+  get: function get() {
+    return _index.MouseEvent;
+  }
+});
+Object.defineProperty(exports, 'DeviceMotionEvent', {
+  enumerable: true,
+  get: function get() {
+    return _index.DeviceMotionEvent;
+  }
+});
+
+var _WindowProperties = require('./WindowProperties');
+
+Object.keys(_WindowProperties).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _WindowProperties[key];
+    }
+  });
+});
+
+var _Canvas = require('./Canvas');
+
+var _Canvas2 = _interopRequireDefault(_Canvas);
+
+var _navigator2 = require('./navigator');
+
+var _navigator3 = _interopRequireDefault(_navigator2);
+
+var _XMLHttpRequest2 = require('./XMLHttpRequest');
+
+var _XMLHttpRequest3 = _interopRequireDefault(_XMLHttpRequest2);
+
+var _WebSocket2 = require('./WebSocket');
+
+var _WebSocket3 = _interopRequireDefault(_WebSocket2);
+
+var _Image2 = require('./Image');
+
+var _Image3 = _interopRequireDefault(_Image2);
+
+var _ImageBitmap2 = require('./ImageBitmap');
+
+var _ImageBitmap3 = _interopRequireDefault(_ImageBitmap2);
+
+var _Audio2 = require('./Audio');
+
+var _Audio3 = _interopRequireDefault(_Audio2);
+
+var _FileReader2 = require('./FileReader');
+
+var _FileReader3 = _interopRequireDefault(_FileReader2);
+
+var _HTMLElement2 = require('./HTMLElement');
+
+var _HTMLElement3 = _interopRequireDefault(_HTMLElement2);
+
+var _HTMLImageElement2 = require('./HTMLImageElement');
+
+var _HTMLImageElement3 = _interopRequireDefault(_HTMLImageElement2);
+
+var _HTMLCanvasElement2 = require('./HTMLCanvasElement');
+
+var _HTMLCanvasElement3 = _interopRequireDefault(_HTMLCanvasElement2);
+
+var _HTMLMediaElement2 = require('./HTMLMediaElement');
+
+var _HTMLMediaElement3 = _interopRequireDefault(_HTMLMediaElement2);
+
+var _HTMLAudioElement2 = require('./HTMLAudioElement');
+
+var _HTMLAudioElement3 = _interopRequireDefault(_HTMLAudioElement2);
+
+var _HTMLVideoElement2 = require('./HTMLVideoElement');
+
+var _HTMLVideoElement3 = _interopRequireDefault(_HTMLVideoElement2);
+
+var _WebGLRenderingContext2 = require('./WebGLRenderingContext');
+
+var _WebGLRenderingContext3 = _interopRequireDefault(_WebGLRenderingContext2);
+
+var _localStorage2 = require('./localStorage');
+
+var _localStorage3 = _interopRequireDefault(_localStorage2);
+
+var _location2 = require('./location');
+
+var _location3 = _interopRequireDefault(_location2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.navigator = _navigator3.default;
+exports.XMLHttpRequest = _XMLHttpRequest3.default;
+exports.WebSocket = _WebSocket3.default;
+exports.Image = _Image3.default;
+exports.ImageBitmap = _ImageBitmap3.default;
+exports.Audio = _Audio3.default;
+exports.FileReader = _FileReader3.default;
+exports.HTMLElement = _HTMLElement3.default;
+exports.HTMLImageElement = _HTMLImageElement3.default;
+exports.HTMLCanvasElement = _HTMLCanvasElement3.default;
+exports.HTMLMediaElement = _HTMLMediaElement3.default;
+exports.HTMLAudioElement = _HTMLAudioElement3.default;
+exports.HTMLVideoElement = _HTMLVideoElement3.default;
+exports.WebGLRenderingContext = _WebGLRenderingContext3.default;
+exports.localStorage = _localStorage3.default;
+exports.location = _location3.default;
+
+
+// 暴露全局的 canvas
+GameGlobal.screencanvas = GameGlobal.screencanvas || new _Canvas2.default();
+var canvas = GameGlobal.screencanvas;
+
+exports.canvas = canvas;
+exports.setTimeout = setTimeout;
+exports.setInterval = setInterval;
+exports.clearTimeout = clearTimeout;
+exports.clearInterval = clearInterval;
+exports.requestAnimationFrame = requestAnimationFrame;
+exports.cancelAnimationFrame = cancelAnimationFrame;

frontend/build-templates/wechatgame/libs/wx-downloader.js

@@ -0,0 +1,508 @@
+/****************************************************************************
+ Copyright (c) 2017 Chukong Technologies Inc.
+
+ http://www.cocos.com
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated engine source code (the "Software"), a limited,
+  worldwide, royalty-free, non-assignable, revocable and  non-exclusive license
+ to use Cocos Creator solely to develop games on your target platforms. You shall
+  not use Cocos Creator software for developing other software or tools that's
+  used for developing games. You are not granted to publish, distribute,
+  sublicense, and/or sell copies of Cocos Creator.
+
+ The software or tools in this License Agreement are licensed, not sold.
+ Chukong Aipu reserves all rights not expressly granted to you.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+ ****************************************************************************/
+var ID = 'WXDownloader';
+const wxFsUtils = require('./wx-fs-utils');
+
+const REGEX = /^\w+:\/\/.*/;
+
+var packageFiles = null;
+var cachedFiles = null;
+var writeCacheFileList = null;
+var cacheQueue = null;
+var checkNextPeriod = false;
+var errTest = /the maximum size of the file storage/;
+
+var _newAssets = {};
+var WXDownloader = window.WXDownloader = function () {
+    this.id = ID;
+    this.async = true;
+    this.pipeline = null;
+    this.REMOTE_SERVER_ROOT = '';
+    this.SUBCONTEXT_ROOT = '';
+
+    this.totalBytesExpectedToWriteAlreadyCounted = new Map(); // Keyed by "remoteUrl".
+    this.totalBytesExpectedToWriteForAllTasks = 0;
+    this.totalBytesWrittenForAllTasks = 0;
+
+    this.immediateHandleItemCount = 0;
+    this.immediateHandleItemCompleteCount = 0;
+
+    this.immediateReadFromLocalCount = 0;
+    this.immediateReadFromLocalCompleteCount = 0;
+
+    this.immediatePackDownloaderCount = 0;
+    this.immediatePackDownloaderCompleteCount = 0;
+};
+WXDownloader.ID = ID;
+
+WXDownloader.prototype.init = function () {
+    if (!CC_WECHATGAMESUB) {
+        this.cacheDir = wx.env.USER_DATA_PATH + '/gamecaches';
+        this.cachedFileName = 'cacheList.json';
+        // whether or not cache asset into user's storage space
+        this.cacheAsset = true;
+        // cache one per cycle
+        this.cachePeriod = 100;
+        // whether or not storage space is run out of
+        this.outOfStorage = false;
+
+        this.writeFilePeriod = 1000;
+
+        cacheQueue = {};
+        packageFiles = {};
+
+        var cacheFilePath = this.cacheDir + '/' + this.cachedFileName;
+        cachedFiles = wxFsUtils.readJsonSync(cacheFilePath);
+        if (cachedFiles instanceof Error) {
+            cachedFiles = {};
+            wxFsUtils.makeDirSync(this.cacheDir, true);
+            wxFsUtils.writeFileSync(cacheFilePath, JSON.stringify(cachedFiles), 'utf8');
+        }
+    }
+};
+
+WXDownloader.prototype.handle = function (item, callback) {
+    if (item.type === 'js') {
+        return null;
+    }
+    var immediateHandleItemCompleteCallback = (errors, results) => {
+      wxDownloader.immediateHandleItemCompleteCount += 1;
+      callback(errors, results);
+    };
+    var immediateReadFromLocalCompleteCallback = (errors, results) => {
+      wxDownloader.immediateReadFromLocalCompleteCount += 1;
+      callback(errors, results);
+    };
+    var immediatePackerDownloaderCompleteCallback = (errors, results) => {
+      wxDownloader.immediatePackDownloaderCompleteCount += 1;
+      callback(errors, results);
+    };
+    if (item.type === 'uuid') {
+      wxDownloader.immediatePackDownloaderCount += 1;
+      var result = cc.Pipeline.Downloader.PackDownloader.load(item, immediatePackerDownloaderCompleteCallback);
+        if (undefined === result) {
+          // When "undefined" is returned, the above "PackDownloader.load(...)" has finished running synchronously and won't trigger "theWrappedCompleteCallback".
+          wxDownloader.immediatePackDownloaderCompleteCount += 1;
+          return;
+        } else if (null === result) {
+          // When "null" is returned, the above "PackDownloader.load(...)" has been running asynchronously and will trigger "theWrappedCompleteCallback".
+          return;
+        } else {
+          // When "non-empty" is returned, the above "PackDownloader.load(...)" has finished running synchronously and won't trigger "theWrappedCompleteCallback".
+          wxDownloader.immediatePackDownloaderCompleteCount += 1;
+          return result;
+        }
+    }
+
+    if (CC_WECHATGAMESUB) {
+        // if wx.getFileSystemManager is undefined, need to skip
+        if (REGEX.test(item.url)) {
+            return null;
+        }
+
+        item.url = this.SUBCONTEXT_ROOT + '/' + item.url;
+        if (wxFsUtils.checkFsValid()) return null;
+        wxDownloader.immediateHandleItemCount += 1;
+
+        handleItem(item, immediateHandleItemCompleteCallback);
+        return;
+    }
+
+    function seek (inPackage) {
+        if (inPackage) {
+          wxDownloader.immediateHandleItemCount += 1;
+          handleItem(item, immediateHandleItemCompleteCallback);
+        }
+        else {
+          wxDownloader.immediateReadFromLocalCount += 1;
+          readFromLocal(item, immediateReadFromLocalCompleteCallback);
+        }
+    }
+
+    if (item.url in packageFiles) {
+        seek(packageFiles[item.url]);
+    }
+    else {
+        wxFsUtils.exists(item.url, function (existance) {
+            packageFiles[item.url] = existance;
+            seek(existance);
+        });
+    }
+};
+
+WXDownloader.prototype.cleanOldAssets = function () {
+    cc.warn('wxDownloader.cleanOldAssets has been deprecated, please use wxDownloader.cleanOldCaches instead!');
+    return this.cleanOldCaches();
+};
+
+WXDownloader.prototype.cleanOldCaches = function () {
+    this.cleanAllCaches(_newAssets, function (err) {
+        if (err) {
+            cc.warn(err);
+        }
+        else {
+            for (var path in _newAssets) {
+                cc.log('reserve local file: ' + path);
+            }
+            cc.log('Clean old Assets successfully!');
+        }
+    });
+};
+
+function handleItem (item, callback) {
+    if (item.type && !shouldReadFile(item.type)) {
+        callback(null, null);
+    }
+    else {
+        readFile(item, callback);
+    }
+}
+
+WXDownloader.prototype.getCacheName = function (filePath) {
+    var cacheUrlReg = /\//g;
+    return filePath.replace(cacheUrlReg, '-');
+};
+
+WXDownloader.prototype.getCachedFileList = function () {
+    return cachedFiles;
+};
+
+WXDownloader.prototype.cleanCache = function (filePath) {
+    if (filePath in cachedFiles) {
+        var self = this;
+        delete cachedFiles[filePath];
+        wxFsUtils.writeFileSync(this.cacheDir + '/' + this.cachedFileName, JSON.stringify(cachedFiles), 'utf8');
+        wxFsUtils.deleteFile(this.cacheDir + '/' + filePath, function (err) {
+            if (!err) self.outOfStorage = false;
+        });
+    }
+};
+
+WXDownloader.prototype.cleanAllAssets = function () {
+    cc.warn('wxDownloader.cleanAllAssets has been deprecated, please use cleanAllCaches instead!');
+    this.cleanAllCaches(null, function (err) {
+        if (err) cc.error(err.message);
+    });
+};
+
+WXDownloader.prototype.cleanAllCaches = function (exclude, callback) {
+    exclude = exclude || {};
+    var self = this;
+    var result = wxFsUtils.readDir(self.cacheDir, function (err, list) {
+        if (err) {
+            callback && callback(err);
+            return;
+        }
+        var toDelete = [];
+        for (var i = 0, l = list.length; i < l; i ++) {
+            var path = list[i];
+            if (path === self.cachedFileName) continue;
+            if (path in exclude) continue;
+            if (path in cacheQueue) {
+                delete cacheQueue[path];
+                continue;
+            }
+            delete cachedFiles[path];
+            toDelete.push(path);
+        }
+        wxFsUtils.writeFileSync(self.cacheDir + '/' + self.cachedFileName, JSON.stringify(cachedFiles), 'utf8');
+        var count = 0;
+        for (var i = 0, l = toDelete.length; i < l; i ++) {
+            wxFsUtils.deleteFile(self.cacheDir + '/' + toDelete[i], function (err) {
+                if (!err) self.outOfStorage = false;
+                count++;
+                if (count === l) callback && callback(null);
+            })
+        }
+    });
+    if (result) callback(result);
+};
+
+var wxDownloader = window.wxDownloader = new WXDownloader();
+
+function registerFailHandler (item, cachePath) {
+    var queue = cc.LoadingItems.getQueue(item);
+    queue.addListener(item.id, function (item) {
+        if (item.error) {
+            if (item.url in cacheQueue) {
+                delete cacheQueue[item.url];
+            }
+            else {
+                wxDownloader.cleanCache(cachePath);
+            }
+        }
+    });
+}
+
+function readFile (item, callback) {
+    var url = item.url;
+    var func = wxFsUtils.readText;
+    if (getFileType(item.type) === FileType.BIN) func = wxFsUtils.readArrayBuffer;
+    var result = func(url, function (err, data) {
+        if (err) {
+            callback(err);
+            return;
+        }
+        if (data) {
+            item.states[cc.loader.downloader.id] = cc.Pipeline.ItemState.COMPLETE;
+            callback(null, data);
+        }
+        else {
+            callback(new Error("Empty file: " + url));
+        }
+    });
+    if (result) callback(result);
+}
+
+function readFromLocal (item, callback) {
+    var result = wxFsUtils.checkFsValid();
+    if (result) {
+        callback(result);
+        return;
+    }
+
+    var cachedPath = wxDownloader.getCacheName(item.url);
+    var localPath = wxDownloader.cacheDir + '/' + cachedPath;
+
+    if (cachedPath in cachedFiles) {
+        // cache new asset
+        _newAssets[cachedPath] = true;
+        item.url = localPath;
+        registerFailHandler(item, cachedPath);
+        handleItem(item, callback);
+    }
+    else {
+        if (!wxDownloader.REMOTE_SERVER_ROOT) {
+            callback(null, null);
+            return;
+        }
+
+        downloadRemoteFile(item, callback);
+    }
+}
+
+function cacheFile (url, isCopy, cachePath) {
+    cacheQueue[url] = { isCopy, cachePath };
+
+    if (!checkNextPeriod) {
+        checkNextPeriod = true;
+        function cache () {
+            checkNextPeriod = false;
+            for (var srcUrl in cacheQueue) {
+                if (!wxDownloader.outOfStorage) {
+                    var item = cacheQueue[srcUrl]
+                    var localPath = wxDownloader.cacheDir + '/' + item.cachePath;
+                    var func = wxFsUtils.copyFile;
+                    if (!item.isCopy) func = wxFsUtils.downloadFile; 
+                    func(srcUrl, localPath, function (err) {
+                        if (err)  {
+                            errTest.test(err.message) && (wxDownloader.outOfStorage = true);
+                            return;
+                        }
+                        cachedFiles[item.cachePath] = 1;
+                        writeCacheFile();
+                    });
+                    delete cacheQueue[srcUrl];
+                }
+                if (!cc.js.isEmptyObject(cacheQueue) && !checkNextPeriod) {
+                    checkNextPeriod = true;
+                    setTimeout(cache, wxDownloader.cachePeriod);
+                }
+                return;
+            }
+        };
+        setTimeout(cache, wxDownloader.cachePeriod);
+    }
+}
+
+function downloadRemoteFile (item, callback) {
+    // Download from remote server
+    var relatUrl = item.url;
+
+    // filter protocol url (E.g: https:// or http:// or ftp://)
+    if (REGEX.test(relatUrl)) {
+        callback(null, null);
+        return;
+    }
+
+    var remoteUrl = wxDownloader.REMOTE_SERVER_ROOT + '/' + relatUrl;
+    item.url = remoteUrl;
+    var cachePath = wxDownloader.getCacheName(relatUrl);
+    if (cc.sys.os === cc.sys.OS_ANDROID && item.type && getFileType(item.type) === FileType.IMAGE) {
+        if (wxDownloader.cacheAsset) {
+            cacheFile(remoteUrl, false, cachePath);
+            registerFailHandler(item, cachePath);
+        }
+        callback(null, null);
+    }
+    else {
+        wxFsUtils.downloadFile(remoteUrl, undefined, function (err, path) {
+            if (err) {
+                callback(err, null);
+                return;
+            }
+            item.url = path;
+            if (wxDownloader.cacheAsset) {
+                cacheFile(path, true, cachePath);
+                registerFailHandler(item, cachePath);
+            }
+            handleItem(item, callback);
+        });
+    }
+    
+}
+
+function writeCacheFile () {
+    function write () {
+        writeCacheFileList = null; 
+        wxFsUtils.writeFile(wxDownloader.cacheDir + '/' + wxDownloader.cachedFileName, JSON.stringify(cachedFiles), 'utf8');
+    }
+    !writeCacheFileList && (writeCacheFileList = setTimeout(write, wxDownloader.writeFilePeriod));
+}
+
+function shouldReadFile (type) {
+    return getFileType(type) >= FileType.LOADABLE_MIN;
+}
+
+function getFileType (type) {
+    return (map[type] || FileType.DEFAULT);
+}
+
+var FileType = {
+    'IMAGE': 1,
+    'FONT': 2,
+    'AUDIO': 3,
+    'SCRIPT': 4,
+    'TEXT': 5,
+    'BIN': 6,
+    'DEFAULT': 7,
+    'LOADABLE_MIN': 5
+};
+
+var map = {
+    // JS
+    'js' : FileType.SCRIPT,
+
+    // Images
+    'png' : FileType.IMAGE,
+    'jpg' : FileType.IMAGE,
+    'bmp' : FileType.IMAGE,
+    'jpeg' : FileType.IMAGE,
+    'gif' : FileType.IMAGE,
+    'ico' : FileType.IMAGE,
+    'tiff' : FileType.IMAGE,
+    'webp' : FileType.IMAGE,
+    'image' : FileType.IMAGE,
+
+    // Audio
+    'mp3' : FileType.AUDIO,
+    'ogg' : FileType.AUDIO,
+    'wav' : FileType.AUDIO,
+    'm4a' : FileType.AUDIO,
+
+    // Txt
+    'txt' : FileType.TEXT,
+    'xml' : FileType.TEXT,
+    'vsh' : FileType.TEXT,
+    'fsh' : FileType.TEXT,
+    'atlas' : FileType.TEXT,
+
+    'tmx' : FileType.TEXT,
+    'tsx' : FileType.TEXT,
+
+    'json' : FileType.TEXT,
+    'ExportJson' : FileType.TEXT,
+    'plist' : FileType.TEXT,
+
+    'fnt' : FileType.TEXT,
+
+    // Font
+    'font' : FileType.FONT,
+    'eot' : FileType.FONT,
+    'ttf' : FileType.FONT,
+    'woff' : FileType.FONT,
+    'svg' : FileType.FONT,
+    'ttc' : FileType.FONT,
+
+    // Binary
+    'binary' : FileType.BIN,
+    'dbbin' : FileType.BIN,
+    'bin': FileType.BIN,
+    'pvr': FileType.BIN,
+    'pkm': FileType.BIN
+};
+// function downloadRemoteTextFile (item, callback) {
+//     // Download from remote server
+//     var relatUrl = item.url;
+//     var remoteUrl = wxDownloader.REMOTE_SERVER_ROOT + '/' + relatUrl;
+//     item.url = remoteUrl;
+//     wx.request({
+//         url: remoteUrl,
+//         success: function(res) {
+//             if (res.data) {
+//                 if (res.statusCode === 200 || res.statusCode === 0) {
+//                     var data = res.data;
+//                     item.states[cc.loader.downloader.ID] = cc.Pipeline.ItemState.COMPLETE;
+//                     if (data) {
+//                         if (typeof data !== 'string' && !(data instanceof ArrayBuffer)) {
+//                             // Should we check if item.type is json ? If not, loader behavior could be different
+//                             item.states[cc.loader.loader.ID] = cc.Pipeline.ItemState.COMPLETE;
+//                             callback(null, data);
+//                             data = JSON.stringify(data);
+//                         }
+//                         else {
+//                             callback(null, data);
+//                         }
+//                     }
+
+//                     // Save to local path
+//                     var localPath = wx.env.USER_DATA_PATH + '/' + relatUrl;
+//                     // Should recursively mkdir first
+//                     fs.writeFile({
+//                         filePath: localPath,
+//                         data: data,
+//                         encoding: 'utf8',
+//                         success: function (res) {
+//                             cc.log('Write file to ' + res.savedFilePath + ' successfully!');
+//                         },
+//                         fail: function (res) {
+//                             // undone implementation
+//                         }
+//                     });
+//                 } else {
+//                     cc.warn("Download text file failed: " + remoteUrl);
+//                     callback({
+//                         status:0, 
+//                         errorMessage: res && res.errMsg ? res.errMsg : "Download text file failed: " + remoteUrl
+//                     });
+//                 }
+//             }
+//         },
+//         fail: function (res) {
+//             // Continue to try download with downloader, most probably will also fail
+//             callback(null, null);
+//         }
+//     });
+// }

frontend/build-templates/wechatgame/libs/wx-fs-utils.js

@@ -0,0 +1,238 @@
+/****************************************************************************
+ Copyright (c) 2017-2019 Xiamen Yaji Software Co., Ltd.
+
+ https://www.cocos.com/
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated engine source code (the "Software"), a limited,
+  worldwide, royalty-free, non-assignable, revocable and non-exclusive license
+ to use Cocos Creator solely to develop games on your target platforms. You shall
+  not use Cocos Creator software for developing other software or tools that's
+  used for developing games. You are not granted to publish, distribute,
+  sublicense, and/or sell copies of Cocos Creator.
+
+ The software or tools in this License Agreement are licensed, not sold.
+ Xiamen Yaji Software Co., Ltd. reserves all rights not expressly granted to you.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+ ****************************************************************************/
+var fs = wx.getFileSystemManager ? wx.getFileSystemManager() : null;
+
+function checkFsValid () {
+    if (!fs) {
+        console.warn('can not get the file system!');
+        return new Error('file system does not exist!');
+    }
+    return null;
+}
+
+function deleteFile (filePath, callback) {
+    var result = checkFsValid();
+    if (result) return result;
+    fs.unlink({
+        filePath: filePath,
+        success: function () {
+            cc.log('Removed local file ' + filePath + ' successfully!');
+            callback && callback(null);
+        },
+        fail: function (res) {
+            console.warn(res.errMsg);
+            callback && callback(new Error(res.errMsg));
+        }
+    });
+}
+
+function downloadFile (remoteUrl, filePath, callback) {
+    var currentDownloadTask = wx.downloadFile({
+        url: remoteUrl,
+        filePath: filePath,
+        success: function (res) {
+            if (res.statusCode === 200) {
+                callback && callback(null, res.tempFilePath || res.filePath);
+            }
+            else {
+                if (res.filePath) {
+                    deleteFile(res.filePath);
+                }
+                console.warn("Download file failed: " + remoteUrl);
+                callback && callback(new Error(res.errMsg), null);
+            }
+        },
+        fail: function (res) {
+            if (true == wxDownloader.totalBytesExpectedToWriteAlreadyCounted.has(remoteUrl)) {
+              wxDownloader.totalBytesExpectedToWriteForAllTasks -= res.totalBytesExpectedToWrite; 
+              const bytesWrittenOfThisRemoteUrl = parseInt(wxDownloader.totalBytesExpectedToWriteAlreadyCounted.get(remoteUrl));
+              if (isNaN(bytesWrittenOfThisRemoteUrl)) {
+                return;
+              }
+              wxDownloader.totalBytesWrittenForAllTasks -= bytesWrittenOfThisRemoteUrl;  
+              wxDownloader.totalBytesExpectedToWriteAlreadyCounted.delete(remoteUrl);
+            }
+            console.warn(res.errMsg);
+            callback && callback(new Error(res.errMsg), null);
+        }
+    });
+
+    currentDownloadTask.onProgressUpdate((res) => {
+      if (false == wxDownloader.totalBytesExpectedToWriteAlreadyCounted.has(remoteUrl)) {
+        wxDownloader.totalBytesExpectedToWriteForAllTasks += res.totalBytesExpectedToWrite; 
+        wxDownloader.totalBytesExpectedToWriteAlreadyCounted.set(remoteUrl, 0);
+      }
+      const bytesWrittenOfThisRemoteUrl = wxDownloader.totalBytesExpectedToWriteAlreadyCounted.get(remoteUrl);  
+      if (isNaN(bytesWrittenOfThisRemoteUrl)) {
+        return;
+      }
+      wxDownloader.totalBytesWrittenForAllTasks += (res.totalBytesWritten - bytesWrittenOfThisRemoteUrl); 
+      wxDownloader.totalBytesExpectedToWriteAlreadyCounted.set(remoteUrl, res.totalBytesWritten);
+    });
+}
+
+function saveFile (srcPath, destPath, callback) {
+    wx.saveFile({
+        tempFilePath: srcPath,
+        filePath: destPath,
+        success: function (res) {
+            cc.log('save file finished:' + destPath);
+            callback && callback(null, res.savedFilePath);
+        },
+        fail: function (res) {
+            cc.log('save file failed:' + res.errMsg);
+            callback && callback(new Error(res.errMsg), null);
+        }
+    });
+}
+
+function copyFile (srcPath, destPath, callback) {
+    var result = checkFsValid();
+    if (result) return result;
+    fs.copyFile({
+        srcPath: srcPath,
+        destPath: destPath,
+        success: function () {
+            cc.log('copy file finished:' + destPath);
+            callback && callback(null);
+        },
+        fail: function (res) {
+            cc.log('copy file failed:' + res.errMsg);
+            callback && callback(new Error(res.errMsg));
+        }
+    });
+}
+
+function writeFile (path, data, encoding, callback) {
+    var result = checkFsValid();
+    if (result) return result;
+    fs.writeFile({
+        filePath: path,
+        encoding: encoding,
+        data: data,
+        success: callback ? function () {
+            callback(null);
+        } : undefined,
+        fail: function (res) {
+            console.warn(res.errMsg);
+            callback && callback(new Error(res.errMsg));
+        }
+    });
+}
+
+function writeFileSync (path, data, encoding) {
+    var result = checkFsValid();
+    if (result) return result;
+    try {
+        fs.writeFileSync(path, data, encoding);
+        return null;
+    }
+    catch (e) {
+        console.warn(e.message);
+        return new Error(e.message);
+    }
+}
+
+function readFile (filePath, encoding, callback) {
+    var result = checkFsValid();
+    if (result) return result;
+    fs.readFile({
+        filePath: filePath,
+        encoding: encoding,
+        success: callback ? function (res) {
+            callback(null, res.data);
+        } : undefined,
+        fail: function (res) {
+            console.warn(res.errMsg);
+            callback && callback (new Error(res.errMsg), null);
+        }
+    });
+}
+
+function readDir (filePath, callback) {
+    var result = checkFsValid();
+    if (result) {
+        return result;
+    }
+    fs.readdir({
+        dirPath: filePath,
+        success: callback ? function (res) {
+            callback(null, res.files);
+        } : undefined,
+        fail: callback ? function (res) {
+            callback(new Error(res.errMsg), null);
+        } : undefined
+    });
+}
+
+function readText (filePath, callback) {
+    return readFile(filePath, 'utf8', callback);
+}
+
+function readArrayBuffer (filePath, callback) {
+    return readFile(filePath, '', callback);
+}
+
+function readJsonSync (path) {
+    var result = checkFsValid();
+    if (result) return result;
+    try {
+        var str = fs.readFileSync(path, 'utf8');
+        return JSON.parse(str);
+    }
+    catch (e) {
+        console.warn(e.message);
+        return new Error(e.message);
+    }
+}
+
+function makeDirSync (path, recursive) {
+    var result = checkFsValid();
+    if (result) return result;
+    try {
+        fs.mkdirSync(path, recursive);
+        return null;
+    }
+    catch (e) {
+        console.warn(e.message);
+        return new Error(e.message);
+    }
+}
+
+function exists (filePath, callback) {
+    var result = checkFsValid();
+    if (result) return result;
+    fs.access({
+        path: filePath,
+        success: callback ? function () {
+            callback(true);
+        } : undefined,
+        fail: callback ? function () {
+            callback(false);
+        } : undefined,
+    });
+}
+
+window.wxFsUtils = module.exports = {fs, checkFsValid, readDir, exists, copyFile, downloadFile, readText, readArrayBuffer, saveFile, writeFile, deleteFile, writeFileSync, readJsonSync, makeDirSync};

frontend/build-templates/wechatgame/libs/xmldom/dom-parser.js

@@ -0,0 +1,252 @@
+function DOMParser(options){
+	this.options = options ||{locator:{}};
+	
+}
+
+DOMParser.prototype.parseFromString = function(source,mimeType){
+	var options = this.options;
+	var sax =  new XMLReader();
+	var domBuilder = options.domBuilder || new DOMHandler();//contentHandler and LexicalHandler
+	var errorHandler = options.errorHandler;
+	var locator = options.locator;
+	var defaultNSMap = options.xmlns||{};
+	var isHTML = /\/x?html?$/.test(mimeType);//mimeType.toLowerCase().indexOf('html') > -1;
+  	var entityMap = isHTML?htmlEntity.entityMap:{'lt':'<','gt':'>','amp':'&','quot':'"','apos':"'"};
+	if(locator){
+		domBuilder.setDocumentLocator(locator)
+	}
+	
+	sax.errorHandler = buildErrorHandler(errorHandler,domBuilder,locator);
+	sax.domBuilder = options.domBuilder || domBuilder;
+	if(isHTML){
+		defaultNSMap['']= 'http://www.w3.org/1999/xhtml';
+	}
+	defaultNSMap.xml = defaultNSMap.xml || 'http://www.w3.org/XML/1998/namespace';
+	if(source){
+		sax.parse(source,defaultNSMap,entityMap);
+	}else{
+		sax.errorHandler.error("invalid doc source");
+	}
+	return domBuilder.doc;
+}
+function buildErrorHandler(errorImpl,domBuilder,locator){
+	if(!errorImpl){
+		if(domBuilder instanceof DOMHandler){
+			return domBuilder;
+		}
+		errorImpl = domBuilder ;
+	}
+	var errorHandler = {}
+	var isCallback = errorImpl instanceof Function;
+	locator = locator||{}
+	function build(key){
+		var fn = errorImpl[key];
+		if(!fn && isCallback){
+			fn = errorImpl.length == 2?function(msg){errorImpl(key,msg)}:errorImpl;
+		}
+		errorHandler[key] = fn && function(msg){
+			fn('[xmldom '+key+']\t'+msg+_locator(locator));
+		}||function(){};
+	}
+	build('warning');
+	build('error');
+	build('fatalError');
+	return errorHandler;
+}
+
+//console.log('#\n\n\n\n\n\n\n####')
+/**
+ * +ContentHandler+ErrorHandler
+ * +LexicalHandler+EntityResolver2
+ * -DeclHandler-DTDHandler 
+ * 
+ * DefaultHandler:EntityResolver, DTDHandler, ContentHandler, ErrorHandler
+ * DefaultHandler2:DefaultHandler,LexicalHandler, DeclHandler, EntityResolver2
+ * @link http://www.saxproject.org/apidoc/org/xml/sax/helpers/DefaultHandler.html
+ */
+function DOMHandler() {
+    this.cdata = false;
+}
+function position(locator,node){
+	node.lineNumber = locator.lineNumber;
+	node.columnNumber = locator.columnNumber;
+}
+/**
+ * @see org.xml.sax.ContentHandler#startDocument
+ * @link http://www.saxproject.org/apidoc/org/xml/sax/ContentHandler.html
+ */ 
+DOMHandler.prototype = {
+	startDocument : function() {
+    	this.doc = new DOMImplementation().createDocument(null, null, null);
+    	if (this.locator) {
+        	this.doc.documentURI = this.locator.systemId;
+    	}
+	},
+	startElement:function(namespaceURI, localName, qName, attrs) {
+		var doc = this.doc;
+	    var el = doc.createElementNS(namespaceURI, qName||localName);
+	    var len = attrs.length;
+	    appendElement(this, el);
+	    this.currentElement = el;
+	    
+		this.locator && position(this.locator,el)
+	    for (var i = 0 ; i < len; i++) {
+	        var namespaceURI = attrs.getURI(i);
+	        var value = attrs.getValue(i);
+	        var qName = attrs.getQName(i);
+			var attr = doc.createAttributeNS(namespaceURI, qName);
+			this.locator &&position(attrs.getLocator(i),attr);
+			attr.value = attr.nodeValue = value;
+			el.setAttributeNode(attr)
+	    }
+	},
+	endElement:function(namespaceURI, localName, qName) {
+		var current = this.currentElement
+		var tagName = current.tagName;
+		this.currentElement = current.parentNode;
+	},
+	startPrefixMapping:function(prefix, uri) {
+	},
+	endPrefixMapping:function(prefix) {
+	},
+	processingInstruction:function(target, data) {
+	    var ins = this.doc.createProcessingInstruction(target, data);
+	    this.locator && position(this.locator,ins)
+	    appendElement(this, ins);
+	},
+	ignorableWhitespace:function(ch, start, length) {
+	},
+	characters:function(chars, start, length) {
+		chars = _toString.apply(this,arguments)
+		//console.log(chars)
+		if(chars){
+			if (this.cdata) {
+				var charNode = this.doc.createCDATASection(chars);
+			} else {
+				var charNode = this.doc.createTextNode(chars);
+			}
+			if(this.currentElement){
+				this.currentElement.appendChild(charNode);
+			}else if(/^\s*$/.test(chars)){
+				this.doc.appendChild(charNode);
+				//process xml
+			}
+			this.locator && position(this.locator,charNode)
+		}
+	},
+	skippedEntity:function(name) {
+	},
+	endDocument:function() {
+		this.doc.normalize();
+	},
+	setDocumentLocator:function (locator) {
+	    if(this.locator = locator){// && !('lineNumber' in locator)){
+	    	locator.lineNumber = 0;
+	    }
+	},
+	//LexicalHandler
+	comment:function(chars, start, length) {
+		chars = _toString.apply(this,arguments)
+	    var comm = this.doc.createComment(chars);
+	    this.locator && position(this.locator,comm)
+	    appendElement(this, comm);
+	},
+	
+	startCDATA:function() {
+	    //used in characters() methods
+	    this.cdata = true;
+	},
+	endCDATA:function() {
+	    this.cdata = false;
+	},
+	
+	startDTD:function(name, publicId, systemId) {
+		var impl = this.doc.implementation;
+	    if (impl && impl.createDocumentType) {
+	        var dt = impl.createDocumentType(name, publicId, systemId);
+	        this.locator && position(this.locator,dt)
+	        appendElement(this, dt);
+	    }
+	},
+	/**
+	 * @see org.xml.sax.ErrorHandler
+	 * @link http://www.saxproject.org/apidoc/org/xml/sax/ErrorHandler.html
+	 */
+	warning:function(error) {
+		console.warn('[xmldom warning]\t'+error,_locator(this.locator));
+	},
+	error:function(error) {
+		console.error('[xmldom error]\t'+error,_locator(this.locator));
+	},
+	fatalError:function(error) {
+		console.error('[xmldom fatalError]\t'+error,_locator(this.locator));
+	    throw error;
+	}
+}
+function _locator(l){
+	if(l){
+		return '\n@'+(l.systemId ||'')+'#[line:'+l.lineNumber+',col:'+l.columnNumber+']'
+	}
+}
+function _toString(chars,start,length){
+	if(typeof chars == 'string'){
+		return chars.substr(start,length)
+	}else{//java sax connect width xmldom on rhino(what about: "? && !(chars instanceof String)")
+		if(chars.length >= start+length || start){
+			return new java.lang.String(chars,start,length)+'';
+		}
+		return chars;
+	}
+}
+
+/*
+ * @link http://www.saxproject.org/apidoc/org/xml/sax/ext/LexicalHandler.html
+ * used method of org.xml.sax.ext.LexicalHandler:
+ *  #comment(chars, start, length)
+ *  #startCDATA()
+ *  #endCDATA()
+ *  #startDTD(name, publicId, systemId)
+ *
+ *
+ * IGNORED method of org.xml.sax.ext.LexicalHandler:
+ *  #endDTD()
+ *  #startEntity(name)
+ *  #endEntity(name)
+ *
+ *
+ * @link http://www.saxproject.org/apidoc/org/xml/sax/ext/DeclHandler.html
+ * IGNORED method of org.xml.sax.ext.DeclHandler
+ * 	#attributeDecl(eName, aName, type, mode, value)
+ *  #elementDecl(name, model)
+ *  #externalEntityDecl(name, publicId, systemId)
+ *  #internalEntityDecl(name, value)
+ * @link http://www.saxproject.org/apidoc/org/xml/sax/ext/EntityResolver2.html
+ * IGNORED method of org.xml.sax.EntityResolver2
+ *  #resolveEntity(String name,String publicId,String baseURI,String systemId)
+ *  #resolveEntity(publicId, systemId)
+ *  #getExternalSubset(name, baseURI)
+ * @link http://www.saxproject.org/apidoc/org/xml/sax/DTDHandler.html
+ * IGNORED method of org.xml.sax.DTDHandler
+ *  #notationDecl(name, publicId, systemId) {};
+ *  #unparsedEntityDecl(name, publicId, systemId, notationName) {};
+ */
+"endDTD,startEntity,endEntity,attributeDecl,elementDecl,externalEntityDecl,internalEntityDecl,resolveEntity,getExternalSubset,notationDecl,unparsedEntityDecl".replace(/\w+/g,function(key){
+	DOMHandler.prototype[key] = function(){return null}
+})
+
+/* Private static helpers treated below as private instance methods, so don't need to add these to the public API; we might use a Relator to also get rid of non-standard public properties */
+function appendElement (hander,node) {
+    if (!hander.currentElement) {
+        hander.doc.appendChild(node);
+    } else {
+        hander.currentElement.appendChild(node);
+    }
+}//appendChild and setAttributeNS are preformance key
+
+//if(typeof require == 'function'){
+var htmlEntity = require('./entities');
+var XMLReader = require('./sax').XMLReader;
+var DOMImplementation = exports.DOMImplementation = require('./dom').DOMImplementation;
+exports.XMLSerializer = require('./dom').XMLSerializer ;
+exports.DOMParser = DOMParser;
+//}

frontend/build-templates/wechatgame/libs/xmldom/entities.js

@@ -0,0 +1,244 @@
+exports.entityMap = {
+       lt: '<',
+       gt: '>',
+       amp: '&',
+       quot: '"',
+       apos: "'",
+       Agrave: "À",
+       Aacute: "Á",
+       Acirc: "Â",
+       Atilde: "Ã",
+       Auml: "Ä",
+       Aring: "Å",
+       AElig: "Æ",
+       Ccedil: "Ç",
+       Egrave: "È",
+       Eacute: "É",
+       Ecirc: "Ê",
+       Euml: "Ë",
+       Igrave: "Ì",
+       Iacute: "Í",
+       Icirc: "Î",
+       Iuml: "Ï",
+       ETH: "Ð",
+       Ntilde: "Ñ",
+       Ograve: "Ò",
+       Oacute: "Ó",
+       Ocirc: "Ô",
+       Otilde: "Õ",
+       Ouml: "Ö",
+       Oslash: "Ø",
+       Ugrave: "Ù",
+       Uacute: "Ú",
+       Ucirc: "Û",
+       Uuml: "Ü",
+       Yacute: "Ý",
+       THORN: "Þ",
+       szlig: "ß",
+       agrave: "à",
+       aacute: "á",
+       acirc: "â",
+       atilde: "ã",
+       auml: "ä",
+       aring: "å",
+       aelig: "æ",
+       ccedil: "ç",
+       egrave: "è",
+       eacute: "é",
+       ecirc: "ê",
+       euml: "ë",
+       igrave: "ì",
+       iacute: "í",
+       icirc: "î",
+       iuml: "ï",
+       eth: "ð",
+       ntilde: "ñ",
+       ograve: "ò",
+       oacute: "ó",
+       ocirc: "ô",
+       otilde: "õ",
+       ouml: "ö",
+       oslash: "ø",
+       ugrave: "ù",
+       uacute: "ú",
+       ucirc: "û",
+       uuml: "ü",
+       yacute: "ý",
+       thorn: "þ",
+       yuml: "ÿ",
+       nbsp: " ",
+       iexcl: "¡",
+       cent: "¢",
+       pound: "£",
+       curren: "¤",
+       yen: "¥",
+       brvbar: "¦",
+       sect: "§",
+       uml: "¨",
+       copy: "©",
+       ordf: "ª",
+       laquo: "«",
+       not: "¬",
+       shy: "­­",
+       reg: "®",
+       macr: "¯",
+       deg: "°",
+       plusmn: "±",
+       sup2: "²",
+       sup3: "³",
+       acute: "´",
+       micro: "µ",
+       para: "¶",
+       middot: "·",
+       cedil: "¸",
+       sup1: "¹",
+       ordm: "º",
+       raquo: "»",
+       frac14: "¼",
+       frac12: "½",
+       frac34: "¾",
+       iquest: "¿",
+       times: "×",
+       divide: "÷",
+       forall: "∀",
+       part: "∂",
+       exist: "∃",
+       empty: "∅",
+       nabla: "∇",
+       isin: "∈",
+       notin: "∉",
+       ni: "∋",
+       prod: "∏",
+       sum: "∑",
+       minus: "−",
+       lowast: "∗",
+       radic: "√",
+       prop: "∝",
+       infin: "∞",
+       ang: "∠",
+       and: "∧",
+       or: "∨",
+       cap: "∩",
+       cup: "∪",
+       'int': "∫",
+       there4: "∴",
+       sim: "∼",
+       cong: "≅",
+       asymp: "≈",
+       ne: "≠",
+       equiv: "≡",
+       le: "≤",
+       ge: "≥",
+       sub: "⊂",
+       sup: "⊃",
+       nsub: "⊄",
+       sube: "⊆",
+       supe: "⊇",
+       oplus: "⊕",
+       otimes: "⊗",
+       perp: "⊥",
+       sdot: "⋅",
+       Alpha: "Α",
+       Beta: "Β",
+       Gamma: "Γ",
+       Delta: "Δ",
+       Epsilon: "Ε",
+       Zeta: "Ζ",
+       Eta: "Η",
+       Theta: "Θ",
+       Iota: "Ι",
+       Kappa: "Κ",
+       Lambda: "Λ",
+       Mu: "Μ",
+       Nu: "Ν",
+       Xi: "Ξ",
+       Omicron: "Ο",
+       Pi: "Π",
+       Rho: "Ρ",
+       Sigma: "Σ",
+       Tau: "Τ",
+       Upsilon: "Υ",
+       Phi: "Φ",
+       Chi: "Χ",
+       Psi: "Ψ",
+       Omega: "Ω",
+       alpha: "α",
+       beta: "β",
+       gamma: "γ",
+       delta: "δ",
+       epsilon: "ε",
+       zeta: "ζ",
+       eta: "η",
+       theta: "θ",
+       iota: "ι",
+       kappa: "κ",
+       lambda: "λ",
+       mu: "μ",
+       nu: "ν",
+       xi: "ξ",
+       omicron: "ο",
+       pi: "π",
+       rho: "ρ",
+       sigmaf: "ς",
+       sigma: "σ",
+       tau: "τ",
+       upsilon: "υ",
+       phi: "φ",
+       chi: "χ",
+       psi: "ψ",
+       omega: "ω",
+       thetasym: "ϑ",
+       upsih: "ϒ",
+       piv: "ϖ",
+       OElig: "Œ",
+       oelig: "œ",
+       Scaron: "Š",
+       scaron: "š",
+       Yuml: "Ÿ",
+       fnof: "ƒ",
+       circ: "ˆ",
+       tilde: "˜",
+       ensp: " ",
+       emsp: " ",
+       thinsp: " ",
+       zwnj: "‌",
+       zwj: "‍",
+       lrm: "‎",
+       rlm: "‏",
+       ndash: "–",
+       mdash: "—",
+       lsquo: "‘",
+       rsquo: "’",
+       sbquo: "‚",
+       ldquo: "“",
+       rdquo: "”",
+       bdquo: "„",
+       dagger: "†",
+       Dagger: "‡",
+       bull: "•",
+       hellip: "…",
+       permil: "‰",
+       prime: "′",
+       Prime: "″",
+       lsaquo: "‹",
+       rsaquo: "›",
+       oline: "‾",
+       euro: "€",
+       trade: "™",
+       larr: "←",
+       uarr: "↑",
+       rarr: "→",
+       darr: "↓",
+       harr: "↔",
+       crarr: "↵",
+       lceil: "⌈",
+       rceil: "⌉",
+       lfloor: "⌊",
+       rfloor: "⌋",
+       loz: "◊",
+       spades: "♠",
+       clubs: "♣",
+       hearts: "♥",
+       diams: "♦"
+};
+//for(var  n in exports.entityMap){console.log(exports.entityMap[n].charCodeAt())}

frontend/build-templates/wechatgame/libs/xmldom/sax.js

@@ -0,0 +1,616 @@
+//[4]   	NameStartChar	   ::=   	":" | [A-Z] | "_" | [a-z] | [#xC0-#xD6] | [#xD8-#xF6] | [#xF8-#x2FF] | [#x370-#x37D] | [#x37F-#x1FFF] | [#x200C-#x200D] | [#x2070-#x218F] | [#x2C00-#x2FEF] | [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD] | [#x10000-#xEFFFF]
+//[4a]   	NameChar	   ::=   	NameStartChar | "-" | "." | [0-9] | #xB7 | [#x0300-#x036F] | [#x203F-#x2040]
+//[5]   	Name	   ::=   	NameStartChar (NameChar)*
+var nameStartChar = /[A-Z_a-z\xC0-\xD6\xD8-\xF6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]///\u10000-\uEFFFF
+var nameChar = new RegExp("[\\-\\.0-9"+nameStartChar.source.slice(1,-1)+"\\u00B7\\u0300-\\u036F\\u203F-\\u2040]");
+var tagNamePattern = new RegExp('^'+nameStartChar.source+nameChar.source+'*(?:\:'+nameStartChar.source+nameChar.source+'*)?$');
+//var tagNamePattern = /^[a-zA-Z_][\w\-\.]*(?:\:[a-zA-Z_][\w\-\.]*)?$/
+//var handlers = 'resolveEntity,getExternalSubset,characters,endDocument,endElement,endPrefixMapping,ignorableWhitespace,processingInstruction,setDocumentLocator,skippedEntity,startDocument,startElement,startPrefixMapping,notationDecl,unparsedEntityDecl,error,fatalError,warning,attributeDecl,elementDecl,externalEntityDecl,internalEntityDecl,comment,endCDATA,endDTD,endEntity,startCDATA,startDTD,startEntity'.split(',')
+
+//S_TAG,	S_ATTR,	S_EQ,	S_ATTR_NOQUOT_VALUE
+//S_ATTR_SPACE,	S_ATTR_END,	S_TAG_SPACE, S_TAG_CLOSE
+var S_TAG = 0;//tag name offerring
+var S_ATTR = 1;//attr name offerring 
+var S_ATTR_SPACE=2;//attr name end and space offer
+var S_EQ = 3;//=space?
+var S_ATTR_NOQUOT_VALUE = 4;//attr value(no quot value only)
+var S_ATTR_END = 5;//attr value end and no space(quot end)
+var S_TAG_SPACE = 6;//(attr value end || tag end ) && (space offer)
+var S_TAG_CLOSE = 7;//closed el<el />
+
+function XMLReader(){
+	
+}
+
+XMLReader.prototype = {
+	parse:function(source,defaultNSMap,entityMap){
+		var domBuilder = this.domBuilder;
+		domBuilder.startDocument();
+		_copy(defaultNSMap ,defaultNSMap = {})
+		parse(source,defaultNSMap,entityMap,
+				domBuilder,this.errorHandler);
+		domBuilder.endDocument();
+	}
+}
+function parse(source,defaultNSMapCopy,entityMap,domBuilder,errorHandler){
+	function fixedFromCharCode(code) {
+		// String.prototype.fromCharCode does not supports
+		// > 2 bytes unicode chars directly
+		if (code > 0xffff) {
+			code -= 0x10000;
+			var surrogate1 = 0xd800 + (code >> 10)
+				, surrogate2 = 0xdc00 + (code & 0x3ff);
+
+			return String.fromCharCode(surrogate1, surrogate2);
+		} else {
+			return String.fromCharCode(code);
+		}
+	}
+	function entityReplacer(a){
+		var k = a.slice(1,-1);
+		if(k in entityMap){
+			return entityMap[k]; 
+		}else if(k.charAt(0) === '#'){
+			return fixedFromCharCode(parseInt(k.substr(1).replace('x','0x')))
+		}else{
+			errorHandler.error('entity not found:'+a);
+			return a;
+		}
+	}
+	function appendText(end){//has some bugs
+		if(end>start){
+			var xt = source.substring(start,end).replace(/&#?\w+;/g,entityReplacer);
+			locator&&position(start);
+			domBuilder.characters(xt,0,end-start);
+			start = end
+		}
+	}
+	function position(p,m){
+		while(p>=lineEnd && (m = linePattern.exec(source))){
+			lineStart = m.index;
+			lineEnd = lineStart + m[0].length;
+			locator.lineNumber++;
+			//console.log('line++:',locator,startPos,endPos)
+		}
+		locator.columnNumber = p-lineStart+1;
+	}
+	var lineStart = 0;
+	var lineEnd = 0;
+	var linePattern = /.*(?:\r\n?|\n)|.*$/g
+	var locator = domBuilder.locator;
+	
+	var parseStack = [{currentNSMap:defaultNSMapCopy}]
+	var closeMap = {};
+	var start = 0;
+	while(true){
+		try{
+			var tagStart = source.indexOf('<',start);
+			if(tagStart<0){
+				if(!source.substr(start).match(/^\s*$/)){
+					var doc = domBuilder.doc;
+	    			var text = doc.createTextNode(source.substr(start));
+	    			doc.appendChild(text);
+	    			domBuilder.currentElement = text;
+				}
+				return;
+			}
+			if(tagStart>start){
+				appendText(tagStart);
+			}
+			switch(source.charAt(tagStart+1)){
+			case '/':
+				var end = source.indexOf('>',tagStart+3);
+				var tagName = source.substring(tagStart+2,end);
+				var config = parseStack.pop();
+				if(end<0){
+					
+	        		tagName = source.substring(tagStart+2).replace(/[\s<].*/,'');
+	        		//console.error('#@@@@@@'+tagName)
+	        		errorHandler.error("end tag name: "+tagName+' is not complete:'+config.tagName);
+	        		end = tagStart+1+tagName.length;
+	        	}else if(tagName.match(/\s</)){
+	        		tagName = tagName.replace(/[\s<].*/,'');
+	        		errorHandler.error("end tag name: "+tagName+' maybe not complete');
+	        		end = tagStart+1+tagName.length;
+				}
+				//console.error(parseStack.length,parseStack)
+				//console.error(config);
+				var localNSMap = config.localNSMap;
+				var endMatch = config.tagName == tagName;
+				var endIgnoreCaseMach = endMatch || config.tagName&&config.tagName.toLowerCase() == tagName.toLowerCase()
+		        if(endIgnoreCaseMach){
+		        	domBuilder.endElement(config.uri,config.localName,tagName);
+					if(localNSMap){
+						for(var prefix in localNSMap){
+							domBuilder.endPrefixMapping(prefix) ;
+						}
+					}
+					if(!endMatch){
+		            	errorHandler.fatalError("end tag name: "+tagName+' is not match the current start tagName:'+config.tagName );
+					}
+		        }else{
+		        	parseStack.push(config)
+		        }
+				
+				end++;
+				break;
+				// end elment
+			case '?':// <?...?>
+				locator&&position(tagStart);
+				end = parseInstruction(source,tagStart,domBuilder);
+				break;
+			case '!':// <!doctype,<![CDATA,<!--
+				locator&&position(tagStart);
+				end = parseDCC(source,tagStart,domBuilder,errorHandler);
+				break;
+			default:
+				locator&&position(tagStart);
+				var el = new ElementAttributes();
+				var currentNSMap = parseStack[parseStack.length-1].currentNSMap;
+				//elStartEnd
+				var end = parseElementStartPart(source,tagStart,el,currentNSMap,entityReplacer,errorHandler);
+				var len = el.length;
+				
+				
+				if(!el.closed && fixSelfClosed(source,end,el.tagName,closeMap)){
+					el.closed = true;
+					if(!entityMap.nbsp){
+						errorHandler.warning('unclosed xml attribute');
+					}
+				}
+				if(locator && len){
+					var locator2 = copyLocator(locator,{});
+					//try{//attribute position fixed
+					for(var i = 0;i<len;i++){
+						var a = el[i];
+						position(a.offset);
+						a.locator = copyLocator(locator,{});
+					}
+					//}catch(e){console.error('@@@@@'+e)}
+					domBuilder.locator = locator2
+					if(appendElement(el,domBuilder,currentNSMap)){
+						parseStack.push(el)
+					}
+					domBuilder.locator = locator;
+				}else{
+					if(appendElement(el,domBuilder,currentNSMap)){
+						parseStack.push(el)
+					}
+				}
+				
+				
+				
+				if(el.uri === 'http://www.w3.org/1999/xhtml' && !el.closed){
+					end = parseHtmlSpecialContent(source,end,el.tagName,entityReplacer,domBuilder)
+				}else{
+					end++;
+				}
+			}
+		}catch(e){
+			errorHandler.error('element parse error: '+e)
+			//errorHandler.error('element parse error: '+e);
+			end = -1;
+			//throw e;
+		}
+		if(end>start){
+			start = end;
+		}else{
+			//TODO: 这里有可能sax回退，有位置错误风险
+			appendText(Math.max(tagStart,start)+1);
+		}
+	}
+}
+function copyLocator(f,t){
+	t.lineNumber = f.lineNumber;
+	t.columnNumber = f.columnNumber;
+	return t;
+}
+
+/**
+ * @see #appendElement(source,elStartEnd,el,selfClosed,entityReplacer,domBuilder,parseStack);
+ * @return end of the elementStartPart(end of elementEndPart for selfClosed el)
+ */
+function parseElementStartPart(source,start,el,currentNSMap,entityReplacer,errorHandler){
+	var attrName;
+	var value;
+	var p = ++start;
+	var s = S_TAG;//status
+	while(true){
+		var c = source.charAt(p);
+		switch(c){
+		case '=':
+			if(s === S_ATTR){//attrName
+				attrName = source.slice(start,p);
+				s = S_EQ;
+			}else if(s === S_ATTR_SPACE){
+				s = S_EQ;
+			}else{
+				//fatalError: equal must after attrName or space after attrName
+				throw new Error('attribute equal must after attrName');
+			}
+			break;
+		case '\'':
+		case '"':
+			if(s === S_EQ || s === S_ATTR //|| s == S_ATTR_SPACE
+				){//equal
+				if(s === S_ATTR){
+					errorHandler.warning('attribute value must after "="')
+					attrName = source.slice(start,p)
+				}
+				start = p+1;
+				p = source.indexOf(c,start)
+				if(p>0){
+					value = source.slice(start,p).replace(/&#?\w+;/g,entityReplacer);
+					el.add(attrName,value,start-1);
+					s = S_ATTR_END;
+				}else{
+					//fatalError: no end quot match
+					throw new Error('attribute value no end \''+c+'\' match');
+				}
+			}else if(s == S_ATTR_NOQUOT_VALUE){
+				value = source.slice(start,p).replace(/&#?\w+;/g,entityReplacer);
+				//console.log(attrName,value,start,p)
+				el.add(attrName,value,start);
+				//console.dir(el)
+				errorHandler.warning('attribute "'+attrName+'" missed start quot('+c+')!!');
+				start = p+1;
+				s = S_ATTR_END
+			}else{
+				//fatalError: no equal before
+				throw new Error('attribute value must after "="');
+			}
+			break;
+		case '/':
+			switch(s){
+			case S_TAG:
+				el.setTagName(source.slice(start,p));
+			case S_ATTR_END:
+			case S_TAG_SPACE:
+			case S_TAG_CLOSE:
+				s =S_TAG_CLOSE;
+				el.closed = true;
+			case S_ATTR_NOQUOT_VALUE:
+			case S_ATTR:
+			case S_ATTR_SPACE:
+				break;
+			//case S_EQ:
+			default:
+				throw new Error("attribute invalid close char('/')")
+			}
+			break;
+		case ''://end document
+			//throw new Error('unexpected end of input')
+			errorHandler.error('unexpected end of input');
+			if(s == S_TAG){
+				el.setTagName(source.slice(start,p));
+			}
+			return p;
+		case '>':
+			switch(s){
+			case S_TAG:
+				el.setTagName(source.slice(start,p));
+			case S_ATTR_END:
+			case S_TAG_SPACE:
+			case S_TAG_CLOSE:
+				break;//normal
+			case S_ATTR_NOQUOT_VALUE://Compatible state
+			case S_ATTR:
+				value = source.slice(start,p);
+				if(value.slice(-1) === '/'){
+					el.closed  = true;
+					value = value.slice(0,-1)
+				}
+			case S_ATTR_SPACE:
+				if(s === S_ATTR_SPACE){
+					value = attrName;
+				}
+				if(s == S_ATTR_NOQUOT_VALUE){
+					errorHandler.warning('attribute "'+value+'" missed quot(")!!');
+					el.add(attrName,value.replace(/&#?\w+;/g,entityReplacer),start)
+				}else{
+					if(currentNSMap[''] !== 'http://www.w3.org/1999/xhtml' || !value.match(/^(?:disabled|checked|selected)$/i)){
+						errorHandler.warning('attribute "'+value+'" missed value!! "'+value+'" instead!!')
+					}
+					el.add(value,value,start)
+				}
+				break;
+			case S_EQ:
+				throw new Error('attribute value missed!!');
+			}
+//			console.log(tagName,tagNamePattern,tagNamePattern.test(tagName))
+			return p;
+		/*xml space '\x20' | #x9 | #xD | #xA; */
+		case '\u0080':
+			c = ' ';
+		default:
+			if(c<= ' '){//space
+				switch(s){
+				case S_TAG:
+					el.setTagName(source.slice(start,p));//tagName
+					s = S_TAG_SPACE;
+					break;
+				case S_ATTR:
+					attrName = source.slice(start,p)
+					s = S_ATTR_SPACE;
+					break;
+				case S_ATTR_NOQUOT_VALUE:
+					var value = source.slice(start,p).replace(/&#?\w+;/g,entityReplacer);
+					errorHandler.warning('attribute "'+value+'" missed quot(")!!');
+					el.add(attrName,value,start)
+				case S_ATTR_END:
+					s = S_TAG_SPACE;
+					break;
+				//case S_TAG_SPACE:
+				//case S_EQ:
+				//case S_ATTR_SPACE:
+				//	void();break;
+				//case S_TAG_CLOSE:
+					//ignore warning
+				}
+			}else{//not space
+//S_TAG,	S_ATTR,	S_EQ,	S_ATTR_NOQUOT_VALUE
+//S_ATTR_SPACE,	S_ATTR_END,	S_TAG_SPACE, S_TAG_CLOSE
+				switch(s){
+				//case S_TAG:void();break;
+				//case S_ATTR:void();break;
+				//case S_ATTR_NOQUOT_VALUE:void();break;
+				case S_ATTR_SPACE:
+					var tagName =  el.tagName;
+					if(currentNSMap[''] !== 'http://www.w3.org/1999/xhtml' || !attrName.match(/^(?:disabled|checked|selected)$/i)){
+						errorHandler.warning('attribute "'+attrName+'" missed value!! "'+attrName+'" instead2!!')
+					}
+					el.add(attrName,attrName,start);
+					start = p;
+					s = S_ATTR;
+					break;
+				case S_ATTR_END:
+					errorHandler.warning('attribute space is required"'+attrName+'"!!')
+				case S_TAG_SPACE:
+					s = S_ATTR;
+					start = p;
+					break;
+				case S_EQ:
+					s = S_ATTR_NOQUOT_VALUE;
+					start = p;
+					break;
+				case S_TAG_CLOSE:
+					throw new Error("elements closed character '/' and '>' must be connected to");
+				}
+			}
+		}//end outer switch
+		//console.log('p++',p)
+		p++;
+	}
+}
+/**
+ * @return true if has new namespace define
+ */
+function appendElement(el,domBuilder,currentNSMap){
+	var tagName = el.tagName;
+	var localNSMap = null;
+	//var currentNSMap = parseStack[parseStack.length-1].currentNSMap;
+	var i = el.length;
+	while(i--){
+		var a = el[i];
+		var qName = a.qName;
+		var value = a.value;
+		var nsp = qName.indexOf(':');
+		if(nsp>0){
+			var prefix = a.prefix = qName.slice(0,nsp);
+			var localName = qName.slice(nsp+1);
+			var nsPrefix = prefix === 'xmlns' && localName
+		}else{
+			localName = qName;
+			prefix = null
+			nsPrefix = qName === 'xmlns' && ''
+		}
+		//can not set prefix,because prefix !== ''
+		a.localName = localName ;
+		//prefix == null for no ns prefix attribute 
+		if(nsPrefix !== false){//hack!!
+			if(localNSMap == null){
+				localNSMap = {}
+				//console.log(currentNSMap,0)
+				_copy(currentNSMap,currentNSMap={})
+				//console.log(currentNSMap,1)
+			}
+			currentNSMap[nsPrefix] = localNSMap[nsPrefix] = value;
+			a.uri = 'http://www.w3.org/2000/xmlns/'
+			domBuilder.startPrefixMapping(nsPrefix, value) 
+		}
+	}
+	var i = el.length;
+	while(i--){
+		a = el[i];
+		var prefix = a.prefix;
+		if(prefix){//no prefix attribute has no namespace
+			if(prefix === 'xml'){
+				a.uri = 'http://www.w3.org/XML/1998/namespace';
+			}if(prefix !== 'xmlns'){
+				a.uri = currentNSMap[prefix || '']
+				
+				//{console.log('###'+a.qName,domBuilder.locator.systemId+'',currentNSMap,a.uri)}
+			}
+		}
+	}
+	var nsp = tagName.indexOf(':');
+	if(nsp>0){
+		prefix = el.prefix = tagName.slice(0,nsp);
+		localName = el.localName = tagName.slice(nsp+1);
+	}else{
+		prefix = null;//important!!
+		localName = el.localName = tagName;
+	}
+	//no prefix element has default namespace
+	var ns = el.uri = currentNSMap[prefix || ''];
+	domBuilder.startElement(ns,localName,tagName,el);
+	//endPrefixMapping and startPrefixMapping have not any help for dom builder
+	//localNSMap = null
+	if(el.closed){
+		domBuilder.endElement(ns,localName,tagName);
+		if(localNSMap){
+			for(prefix in localNSMap){
+				domBuilder.endPrefixMapping(prefix) 
+			}
+		}
+	}else{
+		el.currentNSMap = currentNSMap;
+		el.localNSMap = localNSMap;
+		//parseStack.push(el);
+		return true;
+	}
+}
+function parseHtmlSpecialContent(source,elStartEnd,tagName,entityReplacer,domBuilder){
+	if(/^(?:script|textarea)$/i.test(tagName)){
+		var elEndStart =  source.indexOf('</'+tagName+'>',elStartEnd);
+		var text = source.substring(elStartEnd+1,elEndStart);
+		if(/[&<]/.test(text)){
+			if(/^script$/i.test(tagName)){
+				//if(!/\]\]>/.test(text)){
+					//lexHandler.startCDATA();
+					domBuilder.characters(text,0,text.length);
+					//lexHandler.endCDATA();
+					return elEndStart;
+				//}
+			}//}else{//text area
+				text = text.replace(/&#?\w+;/g,entityReplacer);
+				domBuilder.characters(text,0,text.length);
+				return elEndStart;
+			//}
+			
+		}
+	}
+	return elStartEnd+1;
+}
+function fixSelfClosed(source,elStartEnd,tagName,closeMap){
+	//if(tagName in closeMap){
+	var pos = closeMap[tagName];
+	if(pos == null){
+		//console.log(tagName)
+		pos =  source.lastIndexOf('</'+tagName+'>')
+		if(pos<elStartEnd){//忘记闭合
+			pos = source.lastIndexOf('</'+tagName)
+		}
+		closeMap[tagName] =pos
+	}
+	return pos<elStartEnd;
+	//} 
+}
+function _copy(source,target){
+	for(var n in source){target[n] = source[n]}
+}
+function parseDCC(source,start,domBuilder,errorHandler){//sure start with '<!'
+	var next= source.charAt(start+2)
+	switch(next){
+	case '-':
+		if(source.charAt(start + 3) === '-'){
+			var end = source.indexOf('-->',start+4);
+			//append comment source.substring(4,end)//<!--
+			if(end>start){
+				domBuilder.comment(source,start+4,end-start-4);
+				return end+3;
+			}else{
+				errorHandler.error("Unclosed comment");
+				return -1;
+			}
+		}else{
+			//error
+			return -1;
+		}
+	default:
+		if(source.substr(start+3,6) == 'CDATA['){
+			var end = source.indexOf(']]>',start+9);
+			domBuilder.startCDATA();
+			domBuilder.characters(source,start+9,end-start-9);
+			domBuilder.endCDATA() 
+			return end+3;
+		}
+		//<!DOCTYPE
+		//startDTD(java.lang.String name, java.lang.String publicId, java.lang.String systemId) 
+		var matchs = split(source,start);
+		var len = matchs.length;
+		if(len>1 && /!doctype/i.test(matchs[0][0])){
+			var name = matchs[1][0];
+			var pubid = len>3 && /^public$/i.test(matchs[2][0]) && matchs[3][0]
+			var sysid = len>4 && matchs[4][0];
+			var lastMatch = matchs[len-1]
+			domBuilder.startDTD(name,pubid && pubid.replace(/^(['"])(.*?)\1$/,'$2'),
+					sysid && sysid.replace(/^(['"])(.*?)\1$/,'$2'));
+			domBuilder.endDTD();
+			
+			return lastMatch.index+lastMatch[0].length
+		}
+	}
+	return -1;
+}
+
+
+
+function parseInstruction(source,start,domBuilder){
+	var end = source.indexOf('?>',start);
+	if(end){
+		var match = source.substring(start,end).match(/^<\?(\S*)\s*([\s\S]*?)\s*$/);
+		if(match){
+			var len = match[0].length;
+			domBuilder.processingInstruction(match[1], match[2]) ;
+			return end+2;
+		}else{//error
+			return -1;
+		}
+	}
+	return -1;
+}
+
+/**
+ * @param source
+ */
+function ElementAttributes(source){
+	
+}
+ElementAttributes.prototype = {
+	setTagName:function(tagName){
+		if(!tagNamePattern.test(tagName)){
+			throw new Error('invalid tagName:'+tagName)
+		}
+		this.tagName = tagName
+	},
+	add:function(qName,value,offset){
+		if(!tagNamePattern.test(qName)){
+			throw new Error('invalid attribute:'+qName)
+		}
+		this[this.length++] = {qName:qName,value:value,offset:offset}
+	},
+	length:0,
+	getLocalName:function(i){return this[i].localName},
+	getLocator:function(i){return this[i].locator},
+	getQName:function(i){return this[i].qName},
+	getURI:function(i){return this[i].uri},
+	getValue:function(i){return this[i].value}
+//	,getIndex:function(uri, localName)){
+//		if(localName){
+//			
+//		}else{
+//			var qName = uri
+//		}
+//	},
+//	getValue:function(){return this.getValue(this.getIndex.apply(this,arguments))},
+//	getType:function(uri,localName){}
+//	getType:function(i){},
+}
+
+
+
+function split(source,start){
+	var match;
+	var buf = [];
+	var reg = /'[^']+'|"[^"]+"|[^\s<>\/=]+=?|(\/?\s*>|<)/g;
+	reg.lastIndex = start;
+	reg.exec(source);//skip <
+	while(match = reg.exec(source)){
+		buf.push(match);
+		if(match[1])return buf;
+	}
+}
+
+exports.XMLReader = XMLReader;
+