1651 lines
70 KiB
JavaScript
1651 lines
70 KiB
JavaScript
// @ts-nocheck
|
||
import { formatIdentifier } from './unity-sdk/utils';
|
||
/* eslint-disable */
|
||
const isWK = false;
|
||
// try{
|
||
// isWK = wx.getSystemInfoSync().renderer == 'h5';
|
||
// }catch(e){
|
||
// isWK = typeof(window)!='undefined' && window.XMLHttpRequest;
|
||
// }
|
||
/** ****/ (function (modules) {
|
||
/** ****/ // The module cache
|
||
/** ****/ const installedModules = {};
|
||
/** ****/ // The require function
|
||
/** ****/ function __webpack_require__(moduleId) {
|
||
/** ****/ // Check if module is in cache
|
||
/** ****/ if (installedModules[moduleId])
|
||
/** ****/ return installedModules[moduleId].exports;
|
||
/** ****/ // Create a new module (and put it into the cache)
|
||
/** ****/ const module = installedModules[moduleId] = {
|
||
/** ****/ exports: {},
|
||
/** ****/ id: moduleId,
|
||
/** ****/ loaded: false,
|
||
/** ****/
|
||
};
|
||
/** ****/ // Execute the module function
|
||
/** ****/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
|
||
/** ****/ // Flag the module as loaded
|
||
/** ****/ module.loaded = true;
|
||
/** ****/ // Return the exports of the module
|
||
/** ****/ return module.exports;
|
||
/** ****/
|
||
}
|
||
/** ****/ // expose the modules object (__webpack_modules__)
|
||
/** ****/ __webpack_require__.m = modules;
|
||
/** ****/ // expose the module cache
|
||
/** ****/ __webpack_require__.c = installedModules;
|
||
/** ****/ // __webpack_public_path__
|
||
/** ****/ __webpack_require__.p = '';
|
||
/** ****/ // Load entry module and return exports
|
||
/** ****/ return __webpack_require__(0);
|
||
/** ****/
|
||
}([
|
||
/* 0 */
|
||
/***/ (function (module, exports, __webpack_require__) {
|
||
'use strict';
|
||
const _window2 = __webpack_require__(1);
|
||
const _window = _interopRequireWildcard(_window2);
|
||
const _HTMLElement = __webpack_require__(5);
|
||
const _HTMLElement2 = _interopRequireDefault(_HTMLElement);
|
||
function _interopRequireDefault(obj) {
|
||
return obj && obj.__esModule ? obj : { default: obj };
|
||
}
|
||
function _interopRequireWildcard(obj) {
|
||
if (obj && obj.__esModule) {
|
||
return obj;
|
||
}
|
||
const newObj = {};
|
||
if (obj != null) {
|
||
for (const key in obj) {
|
||
if (Object.prototype.hasOwnProperty.call(obj, key))
|
||
newObj[key] = obj[key];
|
||
}
|
||
}
|
||
newObj.default = obj;
|
||
return newObj;
|
||
}
|
||
const global = GameGlobal;
|
||
function inject() {
|
||
_window.addEventListener = function (type, listener) {
|
||
_window.document.addEventListener(type, listener);
|
||
};
|
||
_window.removeEventListener = function (type, listener) {
|
||
_window.document.removeEventListener(type, listener);
|
||
};
|
||
if (_window.canvas) {
|
||
_window.canvas.addEventListener = _window.addEventListener;
|
||
_window.canvas.removeEventListener = _window.removeEventListener;
|
||
}
|
||
const { platform } = wx.getDeviceInfo();
|
||
// 开发者工具无法重定义 window
|
||
if (platform === 'devtools') {
|
||
for (const key in _window) {
|
||
const descriptor = Object.getOwnPropertyDescriptor(global, key);
|
||
if (!descriptor || descriptor.configurable === true) {
|
||
Object.defineProperty(window, key, {
|
||
value: _window[key],
|
||
});
|
||
}
|
||
}
|
||
for (const _key in _window.document) {
|
||
const _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 (const _key2 in _window) {
|
||
global[_key2] = _window[_key2];
|
||
}
|
||
global.window = _window;
|
||
window = global;
|
||
window.top = window.parent = window;
|
||
}
|
||
}
|
||
if (!GameGlobal.__isAdapterInjected) {
|
||
GameGlobal.__isAdapterInjected = true;
|
||
inject();
|
||
}
|
||
/***/
|
||
}),
|
||
/* 1 */
|
||
/***/ (function (module, exports, __webpack_require__) {
|
||
'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.HTMLElement = exports.FileReader = exports.Audio = exports.Image = exports.WebSocket = /* exports.XMLHttpRequest =*/ exports.navigator = exports.document = undefined;
|
||
if (!isWK) {
|
||
exports.XMLHttpRequest = undefined;
|
||
}
|
||
const _WindowProperties = __webpack_require__(2);
|
||
Object.keys(_WindowProperties).forEach((key) => {
|
||
if (key === 'default' || key === '__esModule')
|
||
return;
|
||
Object.defineProperty(exports, key, {
|
||
enumerable: true,
|
||
get: function get() {
|
||
return _WindowProperties[key];
|
||
},
|
||
});
|
||
});
|
||
const _constructor = __webpack_require__(4);
|
||
Object.keys(_constructor).forEach((key) => {
|
||
if (key === 'default' || key === '__esModule')
|
||
return;
|
||
Object.defineProperty(exports, key, {
|
||
enumerable: true,
|
||
get: function get() {
|
||
return _constructor[key];
|
||
},
|
||
});
|
||
});
|
||
const _Canvas = __webpack_require__(10);
|
||
const _Canvas2 = _interopRequireDefault(_Canvas);
|
||
const _document2 = __webpack_require__(11);
|
||
const _document3 = _interopRequireDefault(_document2);
|
||
const _navigator2 = __webpack_require__(18);
|
||
const _navigator3 = _interopRequireDefault(_navigator2);
|
||
const _XMLHttpRequest2 = __webpack_require__(19);
|
||
const _XMLHttpRequest3 = _interopRequireDefault(_XMLHttpRequest2);
|
||
const _WebSocket2 = __webpack_require__(20);
|
||
const _WebSocket3 = _interopRequireDefault(_WebSocket2);
|
||
const _Image2 = __webpack_require__(12);
|
||
const _Image3 = _interopRequireDefault(_Image2);
|
||
const _Audio2 = __webpack_require__(13);
|
||
const _Audio3 = _interopRequireDefault(_Audio2);
|
||
const _FileReader2 = __webpack_require__(21);
|
||
const _FileReader3 = _interopRequireDefault(_FileReader2);
|
||
const _HTMLElement2 = __webpack_require__(5);
|
||
const _HTMLElement3 = _interopRequireDefault(_HTMLElement2);
|
||
const _localStorage2 = __webpack_require__(22);
|
||
const _localStorage3 = _interopRequireDefault(_localStorage2);
|
||
const _location2 = __webpack_require__(23);
|
||
const _location3 = _interopRequireDefault(_location2);
|
||
function _interopRequireDefault(obj) {
|
||
return obj && obj.__esModule ? obj : { default: obj };
|
||
}
|
||
exports.document = _document3.default;
|
||
exports.navigator = _navigator3.default;
|
||
if (!isWK) {
|
||
exports.XMLHttpRequest = _XMLHttpRequest3.default;
|
||
}
|
||
// exports.XMLHttpRequest = _XMLHttpRequest3.default;
|
||
exports.WebSocket = _WebSocket3.default;
|
||
exports.Image = _Image3.default;
|
||
exports.Audio = _Audio3.default;
|
||
exports.FileReader = _FileReader3.default;
|
||
exports.HTMLElement = _HTMLElement3.default;
|
||
exports.localStorage = _localStorage3.default;
|
||
exports.location = _location3.default;
|
||
// 模拟web中的CustomEvent接口
|
||
function CustomEvent(event, params) {
|
||
params = params || {
|
||
bubbles: false,
|
||
cancelable: false,
|
||
detail: undefined,
|
||
};
|
||
const evt = {
|
||
type: event,
|
||
bubbles: params.bubbles,
|
||
cancelable: params.cancelable,
|
||
detail: params.detail,
|
||
};
|
||
return evt;
|
||
}
|
||
;
|
||
exports.CustomEvent = CustomEvent;
|
||
// 暴露全局的 canvas
|
||
const canvas = new _Canvas2.default();
|
||
exports.canvas = canvas;
|
||
exports.setTimeout = setTimeout;
|
||
exports.setInterval = setInterval;
|
||
exports.clearTimeout = clearTimeout;
|
||
exports.clearInterval = clearInterval;
|
||
exports.requestAnimationFrame = requestAnimationFrame;
|
||
exports.cancelAnimationFrame = cancelAnimationFrame;
|
||
/***/
|
||
}),
|
||
/* 2 */
|
||
/***/ (function (module, exports, __webpack_require__) {
|
||
'use strict';
|
||
Object.defineProperty(exports, '__esModule', {
|
||
value: true,
|
||
});
|
||
exports.performance = exports.ontouchend = exports.ontouchmove = exports.ontouchstart = exports.screen = exports.devicePixelRatio = exports.innerHeight = exports.innerWidth = undefined;
|
||
const _performance2 = __webpack_require__(3);
|
||
const _performance3 = _interopRequireDefault(_performance2);
|
||
function _interopRequireDefault(obj) {
|
||
return obj && obj.__esModule ? obj : { default: obj };
|
||
}
|
||
const { screenWidth, screenHeight, pixelRatio } = wx.getWindowInfo();
|
||
const innerWidth = exports.innerWidth = screenWidth;
|
||
const innerHeight = exports.innerHeight = screenHeight;
|
||
exports.devicePixelRatio = pixelRatio;
|
||
const screen = exports.screen = {
|
||
availWidth: innerWidth,
|
||
availHeight: innerHeight,
|
||
};
|
||
const ontouchstart = exports.ontouchstart = null;
|
||
const ontouchmove = exports.ontouchmove = null;
|
||
const ontouchend = exports.ontouchend = null;
|
||
exports.performance = _performance3.default;
|
||
/***/
|
||
}),
|
||
/* 3 */
|
||
/***/ (function (module, exports) {
|
||
'use strict';
|
||
Object.defineProperty(exports, '__esModule', {
|
||
value: true,
|
||
});
|
||
let performance = void 0;
|
||
let ori_performance = wx.getPerformance();
|
||
const initTime = Date.now();
|
||
const ori_initTime = ori_performance.now();
|
||
const clientPerfAdapter = Object.assign({}, {
|
||
now: function now() {
|
||
if (GameGlobal.unityNamespace.isDevelopmentBuild
|
||
&& GameGlobal.unityNamespace.isProfilingBuild
|
||
&& !GameGlobal.unityNamespace.isDevtools
|
||
&& !GameGlobal.isIOSHighPerformanceMode) {
|
||
// 由于wx.getPerformance()获取到的是微秒级，因此这里需要/1000.0，进行单位的统一
|
||
return (ori_performance.now() - ori_initTime) * 0.001;
|
||
}
|
||
return (Date.now() - initTime);
|
||
},
|
||
});
|
||
performance = clientPerfAdapter;
|
||
exports.default = performance;
|
||
/***/
|
||
}),
|
||
/* 4 */
|
||
/***/ (function (module, exports, __webpack_require__) {
|
||
'use strict';
|
||
Object.defineProperty(exports, '__esModule', {
|
||
value: true,
|
||
});
|
||
exports.HTMLCanvasElement = exports.HTMLImageElement = undefined;
|
||
const _HTMLElement3 = __webpack_require__(5);
|
||
const _HTMLElement4 = _interopRequireDefault(_HTMLElement3);
|
||
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;
|
||
}
|
||
const HTMLImageElement = exports.HTMLImageElement = (function (_HTMLElement) {
|
||
_inherits(HTMLImageElement, _HTMLElement);
|
||
function HTMLImageElement() {
|
||
_classCallCheck(this, HTMLImageElement);
|
||
return _possibleConstructorReturn(this, (HTMLImageElement.__proto__ || Object.getPrototypeOf(HTMLImageElement)).call(this, 'img'));
|
||
}
|
||
return HTMLImageElement;
|
||
}(_HTMLElement4.default));
|
||
const HTMLCanvasElement = exports.HTMLCanvasElement = (function (_HTMLElement2) {
|
||
_inherits(HTMLCanvasElement, _HTMLElement2);
|
||
function HTMLCanvasElement() {
|
||
_classCallCheck(this, HTMLCanvasElement);
|
||
return _possibleConstructorReturn(this, (HTMLCanvasElement.__proto__ || Object.getPrototypeOf(HTMLCanvasElement)).call(this, 'canvas'));
|
||
}
|
||
return HTMLCanvasElement;
|
||
}(_HTMLElement4.default));
|
||
/***/
|
||
}),
|
||
/* 5 */
|
||
/***/ (function (module, exports, __webpack_require__) {
|
||
'use strict';
|
||
Object.defineProperty(exports, '__esModule', {
|
||
value: true,
|
||
});
|
||
const _createClass = (function () {
|
||
function defineProperties(target, props) {
|
||
for (let i = 0; i < props.length; i++) {
|
||
const 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;
|
||
};
|
||
}());
|
||
const _Element2 = __webpack_require__(6);
|
||
const _Element3 = _interopRequireDefault(_Element2);
|
||
const _util = __webpack_require__(9);
|
||
const _WindowProperties = __webpack_require__(2);
|
||
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;
|
||
}
|
||
const HTMLElement = (function (_Element) {
|
||
_inherits(HTMLElement, _Element);
|
||
function HTMLElement() {
|
||
const tagName = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
|
||
_classCallCheck(this, HTMLElement);
|
||
const _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 = _util.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() {
|
||
const ret = parseInt(this.style.fontSize, 10) * this.innerHTML.length;
|
||
return Number.isNaN(ret) ? 0 : ret;
|
||
},
|
||
}, {
|
||
key: 'clientHeight',
|
||
get: function get() {
|
||
const ret = parseInt(this.style.fontSize, 10);
|
||
return Number.isNaN(ret) ? 0 : ret;
|
||
},
|
||
}]);
|
||
return HTMLElement;
|
||
}(_Element3.default));
|
||
exports.default = HTMLElement;
|
||
/***/
|
||
}),
|
||
/* 6 */
|
||
/***/ (function (module, exports, __webpack_require__) {
|
||
'use strict';
|
||
Object.defineProperty(exports, '__esModule', {
|
||
value: true,
|
||
});
|
||
const _Node2 = __webpack_require__(7);
|
||
const _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;
|
||
}
|
||
const ELement = (function (_Node) {
|
||
_inherits(ELement, _Node);
|
||
function ELement() {
|
||
_classCallCheck(this, ELement);
|
||
const _this = _possibleConstructorReturn(this, (ELement.__proto__ || Object.getPrototypeOf(ELement)).call(this));
|
||
_this.className = '';
|
||
_this.children = [];
|
||
return _this;
|
||
}
|
||
return ELement;
|
||
}(_Node3.default));
|
||
exports.default = ELement;
|
||
/***/
|
||
}),
|
||
/* 7 */
|
||
/***/ (function (module, exports, __webpack_require__) {
|
||
'use strict';
|
||
Object.defineProperty(exports, '__esModule', {
|
||
value: true,
|
||
});
|
||
const _createClass = (function () {
|
||
function defineProperties(target, props) {
|
||
for (let i = 0; i < props.length; i++) {
|
||
const 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;
|
||
};
|
||
}());
|
||
const _EventTarget2 = __webpack_require__(8);
|
||
const _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;
|
||
}
|
||
const Node = (function (_EventTarget) {
|
||
_inherits(Node, _EventTarget);
|
||
function Node() {
|
||
_classCallCheck(this, Node);
|
||
const _this = _possibleConstructorReturn(this, (Node.__proto__ || Object.getPrototypeOf(Node)).call(this));
|
||
_this.childNodes = [];
|
||
return _this;
|
||
}
|
||
_createClass(Node, [{
|
||
key: 'appendChild',
|
||
value: function appendChild(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() {
|
||
const copyNode = Object.create(this);
|
||
Object.assign(copyNode, this);
|
||
return copyNode;
|
||
},
|
||
}, {
|
||
key: 'removeChild',
|
||
value: function removeChild(node) {
|
||
const index = this.childNodes.findIndex(child => child === node);
|
||
if (index > -1) {
|
||
return this.childNodes.splice(index, 1);
|
||
}
|
||
return null;
|
||
},
|
||
}]);
|
||
return Node;
|
||
}(_EventTarget3.default));
|
||
exports.default = Node;
|
||
/***/
|
||
}),
|
||
/* 8 */
|
||
/***/ (function (module, exports) {
|
||
'use strict';
|
||
Object.defineProperty(exports, '__esModule', {
|
||
value: true,
|
||
});
|
||
const _createClass = (function () {
|
||
function defineProperties(target, props) {
|
||
for (let i = 0; i < props.length; i++) {
|
||
const 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');
|
||
}
|
||
}
|
||
const _events = new WeakMap();
|
||
const EventTarget = (function () {
|
||
function EventTarget() {
|
||
_classCallCheck(this, EventTarget);
|
||
_events.set(this, {});
|
||
}
|
||
_createClass(EventTarget, [{
|
||
key: 'addEventListener',
|
||
value: function addEventListener(type, listener) {
|
||
const options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
|
||
let 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) {
|
||
const listeners = _events.get(this)[type];
|
||
if (listeners && listeners.length > 0) {
|
||
for (let i = listeners.length; i--; i > 0) {
|
||
if (listeners[i] === listener) {
|
||
listeners.splice(i, 1);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
},
|
||
}, {
|
||
key: 'dispatchEvent',
|
||
value: function dispatchEvent() {
|
||
const event = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
|
||
const listeners = _events.get(this)[event.type];
|
||
if (listeners) {
|
||
for (let i = 0; i < listeners.length; i++) {
|
||
listeners[i](event);
|
||
}
|
||
}
|
||
},
|
||
}]);
|
||
return EventTarget;
|
||
}());
|
||
exports.default = EventTarget;
|
||
/***/
|
||
}),
|
||
/* 9 */
|
||
/***/ (function (module, exports) {
|
||
'use strict';
|
||
Object.defineProperty(exports, '__esModule', {
|
||
value: true,
|
||
});
|
||
exports.noop = noop;
|
||
function noop() { }
|
||
/***/
|
||
}),
|
||
/* 10 */
|
||
/***/ (function (module, exports, __webpack_require__) {
|
||
'use strict';
|
||
Object.defineProperty(exports, '__esModule', {
|
||
value: true,
|
||
});
|
||
exports.default = Canvas;
|
||
const _constructor = __webpack_require__(4);
|
||
const _HTMLElement = __webpack_require__(5);
|
||
const _HTMLElement2 = _interopRequireDefault(_HTMLElement);
|
||
const _document = __webpack_require__(11);
|
||
const _document2 = _interopRequireDefault(_document);
|
||
function _interopRequireDefault(obj) {
|
||
return obj && obj.__esModule ? obj : { default: obj };
|
||
}
|
||
const hasModifiedCanvasPrototype = false;
|
||
const hasInit2DContextConstructor = false;
|
||
const hasInitWebGLContextConstructor = false;
|
||
function Canvas() {
|
||
const canvas = wx.createCanvas();
|
||
canvas.type = 'canvas';
|
||
canvas.__proto__.__proto__ = new _HTMLElement2.default('canvas');
|
||
const _getContext = canvas.getContext;
|
||
canvas.getBoundingClientRect = function () {
|
||
const ret = {
|
||
top: 0,
|
||
left: 0,
|
||
width: window.innerWidth,
|
||
height: window.innerHeight,
|
||
};
|
||
return ret;
|
||
};
|
||
return canvas;
|
||
}
|
||
/***/
|
||
}),
|
||
/* 11 */
|
||
/***/ (function (module, exports, __webpack_require__) {
|
||
'use strict';
|
||
Object.defineProperty(exports, '__esModule', {
|
||
value: true,
|
||
});
|
||
const _window = __webpack_require__(1);
|
||
const window = _interopRequireWildcard(_window);
|
||
const _HTMLElement = __webpack_require__(5);
|
||
const _HTMLElement2 = _interopRequireDefault(_HTMLElement);
|
||
const _Image = __webpack_require__(12);
|
||
const _Image2 = _interopRequireDefault(_Image);
|
||
const _Audio = __webpack_require__(13);
|
||
const _Audio2 = _interopRequireDefault(_Audio);
|
||
const _Canvas = __webpack_require__(10);
|
||
const _Canvas2 = _interopRequireDefault(_Canvas);
|
||
__webpack_require__(16);
|
||
function _interopRequireDefault(obj) {
|
||
return obj && obj.__esModule ? obj : { default: obj };
|
||
}
|
||
function _interopRequireWildcard(obj) {
|
||
if (obj && obj.__esModule) {
|
||
return obj;
|
||
}
|
||
const newObj = {};
|
||
if (obj != null) {
|
||
for (const key in obj) {
|
||
if (Object.prototype.hasOwnProperty.call(obj, key))
|
||
newObj[key] = obj[key];
|
||
}
|
||
}
|
||
newObj.default = obj;
|
||
return newObj;
|
||
}
|
||
const 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();
|
||
}
|
||
if (tagName === 'audio') {
|
||
return new _Audio2.default();
|
||
}
|
||
if (tagName === 'img') {
|
||
return new _Image2.default();
|
||
}
|
||
return new _HTMLElement2.default(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];
|
||
}
|
||
if (tagName === 'body') {
|
||
return [document.body];
|
||
}
|
||
if (tagName === 'canvas') {
|
||
return [window.canvas];
|
||
}
|
||
return [];
|
||
},
|
||
getElementsByName: function getElementsByName(tagName) {
|
||
if (tagName === 'head') {
|
||
return [document.head];
|
||
}
|
||
if (tagName === 'body') {
|
||
return [document.body];
|
||
}
|
||
if (tagName === 'canvas') {
|
||
return [window.canvas];
|
||
}
|
||
return [];
|
||
},
|
||
querySelector: function querySelector(query) {
|
||
if (query === 'head') {
|
||
return document.head;
|
||
}
|
||
if (query === 'body') {
|
||
return document.body;
|
||
}
|
||
if (query === 'canvas') {
|
||
return window.canvas;
|
||
}
|
||
if (query === `#${window.canvas.id}`) {
|
||
return window.canvas;
|
||
}
|
||
return null;
|
||
},
|
||
querySelectorAll: function querySelectorAll(query) {
|
||
if (query === 'head') {
|
||
return [document.head];
|
||
}
|
||
if (query === 'body') {
|
||
return [document.body];
|
||
}
|
||
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) {
|
||
const listeners = events[type];
|
||
if (listeners && listeners.length > 0) {
|
||
for (let i = listeners.length; i--; i > 0) {
|
||
if (listeners[i] === listener) {
|
||
listeners.splice(i, 1);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
},
|
||
dispatchEvent: function dispatchEvent(event) {
|
||
const listeners = events[event.type];
|
||
if (listeners) {
|
||
for (let i = 0; i < listeners.length; i++) {
|
||
listeners[i](event);
|
||
}
|
||
}
|
||
},
|
||
};
|
||
exports.default = document;
|
||
/***/
|
||
}),
|
||
/* 12 */
|
||
/***/ (function (module, exports) {
|
||
'use strict';
|
||
Object.defineProperty(exports, '__esModule', {
|
||
value: true,
|
||
});
|
||
exports.default = Image;
|
||
function Image() {
|
||
const image = wx.createImage();
|
||
return image;
|
||
}
|
||
/***/
|
||
}),
|
||
/* 13 */
|
||
/***/ (function (module, exports, __webpack_require__) {
|
||
'use strict';
|
||
Object.defineProperty(exports, '__esModule', {
|
||
value: true,
|
||
});
|
||
const _createClass = (function () {
|
||
function defineProperties(target, props) {
|
||
for (let i = 0; i < props.length; i++) {
|
||
const 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;
|
||
};
|
||
}());
|
||
const _HTMLAudioElement2 = __webpack_require__(14);
|
||
const _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;
|
||
}
|
||
const HAVE_NOTHING = 0;
|
||
const HAVE_METADATA = 1;
|
||
const HAVE_CURRENT_DATA = 2;
|
||
const HAVE_FUTURE_DATA = 3;
|
||
const HAVE_ENOUGH_DATA = 4;
|
||
const _innerAudioContext = new WeakMap();
|
||
const _src = new WeakMap();
|
||
const _loop = new WeakMap();
|
||
const _autoplay = new WeakMap();
|
||
const Audio = (function (_HTMLAudioElement) {
|
||
_inherits(Audio, _HTMLAudioElement);
|
||
function Audio(url) {
|
||
_classCallCheck(this, Audio);
|
||
const _this = _possibleConstructorReturn(this, (Audio.__proto__ || Object.getPrototypeOf(Audio)).call(this));
|
||
_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;
|
||
_src.set(_this, '');
|
||
const innerAudioContext = wx.createInnerAudioContext();
|
||
_innerAudioContext.set(_this, innerAudioContext);
|
||
innerAudioContext.onCanplay(() => {
|
||
_this.dispatchEvent({ type: 'load' });
|
||
_this.dispatchEvent({ type: 'loadend' });
|
||
_this.dispatchEvent({ type: 'canplay' });
|
||
_this.dispatchEvent({ type: 'canplaythrough' });
|
||
_this.dispatchEvent({ type: 'loadedmetadata' });
|
||
_this.readyState = HAVE_CURRENT_DATA;
|
||
});
|
||
innerAudioContext.onPlay(() => {
|
||
_this.dispatchEvent({ type: 'play' });
|
||
});
|
||
innerAudioContext.onPause(() => {
|
||
_this.dispatchEvent({ type: 'pause' });
|
||
});
|
||
innerAudioContext.onEnded(() => {
|
||
_this.dispatchEvent({ type: 'ended' });
|
||
_this.readyState = HAVE_ENOUGH_DATA;
|
||
});
|
||
innerAudioContext.onError(() => {
|
||
_this.dispatchEvent({ type: 'error' });
|
||
});
|
||
if (url) {
|
||
_innerAudioContext.get(_this).src = url;
|
||
}
|
||
return _this;
|
||
}
|
||
_createClass(Audio, [{
|
||
key: 'load',
|
||
value: function load() {
|
||
console.warn('HTMLAudioElement.load() is not implemented.');
|
||
},
|
||
}, {
|
||
key: 'play',
|
||
value: function play() {
|
||
_innerAudioContext.get(this).play();
|
||
},
|
||
}, {
|
||
key: 'pause',
|
||
value: function pause() {
|
||
_innerAudioContext.get(this).pause();
|
||
},
|
||
}, {
|
||
key: 'canPlayType',
|
||
value: function canPlayType() {
|
||
const 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() {
|
||
const newAudio = new Audio();
|
||
newAudio.loop = _innerAudioContext.get(this).loop;
|
||
newAudio.autoplay = _innerAudioContext.get(this).autoplay;
|
||
newAudio.src = this.src;
|
||
return newAudio;
|
||
},
|
||
}, {
|
||
key: 'currentTime',
|
||
get: function get() {
|
||
return _innerAudioContext.get(this).currentTime;
|
||
},
|
||
set: function set(value) {
|
||
_innerAudioContext.get(this).seek(value);
|
||
},
|
||
}, {
|
||
key: 'src',
|
||
get: function get() {
|
||
return _src.get(this);
|
||
},
|
||
set: function set(value) {
|
||
_src.set(this, value);
|
||
_innerAudioContext.get(this).src = value;
|
||
},
|
||
}, {
|
||
key: 'loop',
|
||
get: function get() {
|
||
return _innerAudioContext.get(this).loop;
|
||
},
|
||
set: function set(value) {
|
||
_innerAudioContext.get(this).loop = value;
|
||
},
|
||
}, {
|
||
key: 'autoplay',
|
||
get: function get() {
|
||
return _innerAudioContext.get(this).autoplay;
|
||
},
|
||
set: function set(value) {
|
||
_innerAudioContext.get(this).autoplay = value;
|
||
},
|
||
}, {
|
||
key: 'paused',
|
||
get: function get() {
|
||
return _innerAudioContext.get(this).paused;
|
||
},
|
||
}]);
|
||
return Audio;
|
||
}(_HTMLAudioElement3.default));
|
||
exports.default = Audio;
|
||
/***/
|
||
}),
|
||
/* 14 */
|
||
/***/ (function (module, exports, __webpack_require__) {
|
||
'use strict';
|
||
Object.defineProperty(exports, '__esModule', {
|
||
value: true,
|
||
});
|
||
const _HTMLMediaElement2 = __webpack_require__(15);
|
||
const _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;
|
||
}
|
||
const 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;
|
||
/***/
|
||
}),
|
||
/* 15 */
|
||
/***/ (function (module, exports, __webpack_require__) {
|
||
'use strict';
|
||
Object.defineProperty(exports, '__esModule', {
|
||
value: true,
|
||
});
|
||
const _createClass = (function () {
|
||
function defineProperties(target, props) {
|
||
for (let i = 0; i < props.length; i++) {
|
||
const 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;
|
||
};
|
||
}());
|
||
const _HTMLElement2 = __webpack_require__(5);
|
||
const _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;
|
||
}
|
||
const 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;
|
||
/***/
|
||
}),
|
||
/* 16 */
|
||
/***/ (function (module, exports, __webpack_require__) {
|
||
'use strict';
|
||
__webpack_require__(17);
|
||
/***/
|
||
}),
|
||
/* 17 */
|
||
/***/ (function (module, exports, __webpack_require__) {
|
||
'use strict';
|
||
const _window = __webpack_require__(1);
|
||
const window = _interopRequireWildcard(_window);
|
||
const _document = __webpack_require__(11);
|
||
const _document2 = _interopRequireDefault(_document);
|
||
const _util = __webpack_require__(9);
|
||
function _interopRequireDefault(obj) {
|
||
return obj && obj.__esModule ? obj : { default: obj };
|
||
}
|
||
function _interopRequireWildcard(obj) {
|
||
if (obj && obj.__esModule) {
|
||
return obj;
|
||
}
|
||
const newObj = {};
|
||
if (obj != null) {
|
||
for (const key in obj) {
|
||
if (Object.prototype.hasOwnProperty.call(obj, key))
|
||
newObj[key] = obj[key];
|
||
}
|
||
}
|
||
newObj.default = obj;
|
||
return newObj;
|
||
}
|
||
function _classCallCheck(instance, Constructor) {
|
||
if (!(instance instanceof Constructor)) {
|
||
throw new TypeError('Cannot call a class as a function');
|
||
}
|
||
}
|
||
const TouchEvent = function TouchEvent(type) {
|
||
_classCallCheck(this, TouchEvent);
|
||
this.target = window.canvas;
|
||
this.currentTarget = window.canvas;
|
||
this.touches = [];
|
||
this.targetTouches = [];
|
||
this.changedTouches = [];
|
||
this.preventDefault = _util.noop;
|
||
this.stopPropagation = _util.noop;
|
||
this.type = type;
|
||
};
|
||
function formatTouchEvent(v, type, changed) {
|
||
return {
|
||
...v,
|
||
identifier: formatIdentifier(v.identifier, type, changed)
|
||
};
|
||
}
|
||
function touchEventHandlerFactory(type) {
|
||
return function (event) {
|
||
const touchEvent = new TouchEvent(type);
|
||
touchEvent.touches = event.touches.map(v => formatTouchEvent(v, event.type));
|
||
touchEvent.targetTouches = Array.prototype.slice.call(event.touches).map(v => formatTouchEvent(v, event.type));
|
||
touchEvent.changedTouches = event.changedTouches.map(v => formatTouchEvent(v, event.type, 1));
|
||
touchEvent.timeStamp = event.timeStamp;
|
||
_document2.default.dispatchEvent(touchEvent);
|
||
};
|
||
}
|
||
wx.onTouchStart(touchEventHandlerFactory('touchstart'));
|
||
wx.onTouchMove(touchEventHandlerFactory('touchmove'));
|
||
wx.onTouchEnd(touchEventHandlerFactory('touchend'));
|
||
wx.onTouchCancel(touchEventHandlerFactory('touchcancel'));
|
||
/***/
|
||
}),
|
||
/* 18 */
|
||
/***/ (function (module, exports, __webpack_require__) {
|
||
'use strict';
|
||
Object.defineProperty(exports, '__esModule', {
|
||
value: true,
|
||
});
|
||
const _util = __webpack_require__(9);
|
||
// TODO 需要 wx.getSystemInfo 获取更详细信息
|
||
const { platform } = wx.getDeviceInfo();
|
||
const navigator = {
|
||
platform,
|
||
language: 'zh-cn',
|
||
appVersion: '5.0 (iPhone; CPU iPhone OS 9_1 like Mac OS X) AppleWebKit/601.1.46 (KHTML, like Gecko) Version/9.0 Mobile/13B143 Safari/601.1',
|
||
userAgent: 'Mozilla/5.0 (iPhone; CPU iPhone OS 10_3_1 like Mac OS X) AppleWebKit/603.1.30 (KHTML, like Gecko) Mobile/14E8301 MicroMessenger/6.6.0 MiniGame NetType/WIFI Language/zh_CN',
|
||
onLine: true,
|
||
// TODO 用 wx.getLocation 来封装 geolocation
|
||
geolocation: {
|
||
getCurrentPosition: _util.noop,
|
||
watchPosition: _util.noop,
|
||
clearWatch: _util.noop,
|
||
},
|
||
};
|
||
exports.default = navigator;
|
||
/***/
|
||
}),
|
||
/* 19 */
|
||
/***/ (function (module, exports) {
|
||
'use strict';
|
||
Object.defineProperty(exports, '__esModule', {
|
||
value: true,
|
||
});
|
||
const _createClass = (function () {
|
||
function defineProperties(target, props) {
|
||
for (let i = 0; i < props.length; i++) {
|
||
const 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');
|
||
}
|
||
}
|
||
const _url = new WeakMap();
|
||
const _method = new WeakMap();
|
||
const _requestHeader = new WeakMap();
|
||
const _responseHeader = new WeakMap();
|
||
const _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');
|
||
}
|
||
const XMLHttpRequest = (function () {
|
||
// TODO 没法模拟 HEADERS_RECEIVED 和 LOADING 两个状态
|
||
function XMLHttpRequest() {
|
||
_classCallCheck(this, XMLHttpRequest);
|
||
this.onabort = null;
|
||
this.onerror = null;
|
||
this.onload = null;
|
||
this.onloadstart = null;
|
||
this.onprogress = null;
|
||
this.ontimeout = null;
|
||
this.onloadend = null;
|
||
this.onreadystatechange = null;
|
||
this.readyState = 0;
|
||
this.response = null;
|
||
this.responseText = null;
|
||
this.responseType = '';
|
||
this.responseXML = null;
|
||
this.status = 0;
|
||
this.statusText = '';
|
||
this.upload = {};
|
||
this.withCredentials = false;
|
||
this.timeout = 60000;
|
||
_requestHeader.set(this, {
|
||
'content-type': 'application/x-www-form-urlencoded',
|
||
});
|
||
_responseHeader.set(this, {});
|
||
}
|
||
/*
|
||
* TODO 这一批事件应该是在 XMLHttpRequestEventTarget.prototype 上面的
|
||
*/
|
||
_createClass(XMLHttpRequest, [{
|
||
key: 'abort',
|
||
value: function abort() {
|
||
const myRequestTask = _requestTask.get(this);
|
||
if (myRequestTask) {
|
||
myRequestTask.abort();
|
||
}
|
||
},
|
||
}, {
|
||
key: 'getAllResponseHeaders',
|
||
value: function getAllResponseHeaders() {
|
||
const responseHeader = _responseHeader.get(this);
|
||
return Object.keys(responseHeader).map(header => `${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() {
|
||
const _this = this;
|
||
let 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 {
|
||
if (data instanceof Uint8Array) {
|
||
// unity 过来的请求会出现Uint8Array的数组，而客户端这里处理有问题，先这样兼容
|
||
data = Uint8Array.from(data).buffer;
|
||
}
|
||
const { responseType } = this;
|
||
wx.request({
|
||
data,
|
||
url: _url.get(this),
|
||
method: _method.get(this),
|
||
header: _requestHeader.get(this),
|
||
responseType: this.responseType,
|
||
enableHttp2: true,
|
||
enableQuic: true,
|
||
timeout: this.timeout ? this.timeout : 60000,
|
||
success: function success(_ref) {
|
||
let { data } = _ref;
|
||
const { statusCode } = _ref;
|
||
const { header } = _ref;
|
||
if (typeof data !== 'string' && !(data instanceof ArrayBuffer)) {
|
||
try {
|
||
data = JSON.stringify(data);
|
||
}
|
||
catch (e) {
|
||
data = data;
|
||
}
|
||
}
|
||
_this.status = statusCode;
|
||
_responseHeader.set(_this, header);
|
||
_triggerEvent.call(_this, 'loadstart');
|
||
_changeReadyState.call(_this, XMLHttpRequest.HEADERS_RECEIVED);
|
||
_changeReadyState.call(_this, XMLHttpRequest.LOADING);
|
||
_this.response = data;
|
||
_this.profile = _ref.profile;
|
||
if (responseType === 'text') {
|
||
if (data instanceof ArrayBuffer) {
|
||
_this.responseText = '';
|
||
const bytes = new Uint8Array(data);
|
||
const len = bytes.byteLength;
|
||
for (let i = 0; i < len; i++) {
|
||
_this.responseText += String.fromCharCode(bytes[i]);
|
||
}
|
||
}
|
||
else {
|
||
_this.responseText = data;
|
||
}
|
||
}
|
||
_changeReadyState.call(_this, XMLHttpRequest.DONE);
|
||
_triggerEvent.call(_this, 'load');
|
||
_triggerEvent.call(_this, 'loadend');
|
||
},
|
||
fail: function fail(_ref2) {
|
||
const { errMsg } = _ref2;
|
||
// TODO 规范错误
|
||
if (errMsg.indexOf('abort') !== -1) {
|
||
_triggerEvent.call(_this, 'abort');
|
||
}
|
||
else {
|
||
_triggerEvent.call(_this, 'error', errMsg);
|
||
}
|
||
_triggerEvent.call(_this, 'loadend');
|
||
},
|
||
});
|
||
}
|
||
},
|
||
}, {
|
||
key: 'setRequestHeader',
|
||
value: function setRequestHeader(header, value) {
|
||
const myHeader = _requestHeader.get(this);
|
||
myHeader[header] = value;
|
||
_requestHeader.set(this, myHeader);
|
||
},
|
||
}]);
|
||
return XMLHttpRequest;
|
||
}());
|
||
XMLHttpRequest.UNSEND = 0;
|
||
XMLHttpRequest.OPENED = 1;
|
||
XMLHttpRequest.HEADERS_RECEIVED = 2;
|
||
XMLHttpRequest.LOADING = 3;
|
||
XMLHttpRequest.DONE = 4;
|
||
if (!isWK) {
|
||
exports.default = XMLHttpRequest;
|
||
}
|
||
/***/
|
||
}),
|
||
/* 20 */
|
||
/***/ (function (module, exports) {
|
||
'use strict';
|
||
Object.defineProperty(exports, '__esModule', {
|
||
value: true,
|
||
});
|
||
const _createClass = (function () {
|
||
function defineProperties(target, props) {
|
||
for (let i = 0; i < props.length; i++) {
|
||
const 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');
|
||
}
|
||
}
|
||
const _socketTask = new WeakMap();
|
||
const WebSocket = (function () {
|
||
// TODO 更新 binaryType
|
||
// The connection is in the process of closing.
|
||
// The connection is not yet open.
|
||
function WebSocket(url) {
|
||
const _this = this;
|
||
const 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;
|
||
const socketTask = wx.connectSocket({
|
||
url,
|
||
protocols: Array.isArray(protocols) ? protocols : [protocols],
|
||
});
|
||
_socketTask.set(this, socketTask);
|
||
socketTask.onClose((res) => {
|
||
_this.readyState = WebSocket.CLOSED;
|
||
if (typeof _this.onclose === 'function') {
|
||
_this.onclose(res);
|
||
}
|
||
});
|
||
socketTask.onMessage((res) => {
|
||
if (typeof _this.onmessage === 'function') {
|
||
_this.onmessage(res);
|
||
}
|
||
});
|
||
socketTask.onOpen(() => {
|
||
_this.readyState = WebSocket.OPEN;
|
||
if (typeof _this.onopen === 'function') {
|
||
_this.onopen();
|
||
}
|
||
});
|
||
socketTask.onError((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;
|
||
const socketTask = _socketTask.get(this);
|
||
socketTask.close({
|
||
code,
|
||
reason,
|
||
});
|
||
},
|
||
}, {
|
||
key: 'send',
|
||
value: function send(data) {
|
||
if (typeof data !== 'string' && !(data instanceof ArrayBuffer) && !((typeof data) === 'object')) {
|
||
throw new TypeError(`Failed to send message: The data ${data} is invalid`);
|
||
}
|
||
const socketTask = _socketTask.get(this);
|
||
socketTask.send({
|
||
data,
|
||
});
|
||
},
|
||
}]);
|
||
return WebSocket;
|
||
}());
|
||
WebSocket.CONNECTING = 0;
|
||
WebSocket.OPEN = 1;
|
||
WebSocket.CLOSING = 2;
|
||
WebSocket.CLOSED = 3;
|
||
exports.default = WebSocket;
|
||
/***/
|
||
}),
|
||
/* 21 */
|
||
/***/ (function (module, exports) {
|
||
'use strict';
|
||
Object.defineProperty(exports, '__esModule', {
|
||
value: true,
|
||
});
|
||
const _createClass = (function () {
|
||
function defineProperties(target, props) {
|
||
for (let i = 0; i < props.length; i++) {
|
||
const 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
|
||
*/
|
||
const FileReader = (function () {
|
||
function FileReader() {
|
||
_classCallCheck(this, FileReader);
|
||
}
|
||
_createClass(FileReader, [{
|
||
key: 'construct',
|
||
value: function construct() { },
|
||
}]);
|
||
return FileReader;
|
||
}());
|
||
exports.default = FileReader;
|
||
/***/
|
||
}),
|
||
/* 22 */
|
||
/***/ (function (module, exports) {
|
||
'use strict';
|
||
Object.defineProperty(exports, '__esModule', {
|
||
value: true,
|
||
});
|
||
const localStorage = {
|
||
get length() {
|
||
const _wx$getStorageInfoSyn = wx.getStorageInfoSync();
|
||
const { keys } = _wx$getStorageInfoSyn;
|
||
return keys.length;
|
||
},
|
||
key: function key(n) {
|
||
const _wx$getStorageInfoSyn2 = wx.getStorageInfoSync();
|
||
const { keys } = _wx$getStorageInfoSyn2;
|
||
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;
|
||
/***/
|
||
}),
|
||
/* 23 */
|
||
/***/ (function (module, exports) {
|
||
'use strict';
|
||
Object.defineProperty(exports, '__esModule', {
|
||
value: true,
|
||
});
|
||
const location = {
|
||
href: 'game.js',
|
||
reload: function reload() { },
|
||
};
|
||
exports.default = location;
|
||
/***/
|
||
}),
|
||
/** ****/
|
||
]));
|