tabris 3.8.0-dev.20210928 → 3.8.0-dev.20211003

package/tabris.js

@@ -1,5 +1,5 @@
 /*!
- * Tabris.js 3.8.0-dev.20210928+0310
+ * Tabris.js 3.8.0-dev.20211003+0318
  * 
  * Copyright (c) 2014, 2020 EclipseSource Inc.
  * All rights reserved.
@@ -689,7 +689,7 @@ class Console {
         for (const level of ['debug', 'info', 'log', 'warn', 'error']) {
             this._console[level] = (...args) => {
                 const message = this._prepareOutput(...args);
-                tabris.trigger('log', { level, message });
+                tabris.trigger('log', { level, message, logTime: Date.now() });
                 nativeConsole.print(level, message);
             };
         }
@@ -4705,12 +4705,299 @@ class NativeObjectRegistry {
     }
 }
 
+const PHASE_CONSTANTS = {
+    NONE: { value: 0 },
+    CAPTURING_PHASE: { value: 1 },
+    AT_TARGET: { value: 2 },
+    BUBBLING_PHASE: { value: 3 }
+};
+class Event {
+    constructor(type, config) {
+        if (arguments.length < 1) {
+            throw new Error('Not enough arguments to Event');
+        }
+        Object.defineProperties(this, {
+            $timeStamp: { enumerable: false, writable: true, value: Date.now() },
+            $type: { enumerable: false, writable: true, value: type || '' },
+            $bubbles: { enumerable: false, writable: true, value: config && !!config.bubbles || false },
+            $cancelable: { enumerable: false, writable: true, value: config && !!config.cancelable || false },
+            $target: { enumerable: false, writable: true, value: null },
+            $defaultPrevented: { enumerable: false, writable: true, value: false }
+        });
+    }
+    initEvent(type, bubbles, cancelable) {
+        if (arguments.length < 3) {
+            throw new Error('Not enough arguments to initEvent');
+        }
+        this.$type = type + '';
+        this.$bubbles = !!bubbles;
+        this.$cancelable = !!cancelable;
+    }
+    get type() {
+        return this.$type;
+    }
+    get timeStamp() {
+        return this.$timeStamp;
+    }
+    get bubbles() {
+        return this.$bubbles;
+    }
+    get cancelable() {
+        return this.$cancelable;
+    }
+    get target() {
+        return this.$target;
+    }
+    get currentTarget() {
+        return this.$target;
+    }
+    get defaultPrevented() {
+        return this.$defaultPrevented;
+    }
+    get eventPhase() {
+        return 0;
+    }
+    get isTrusted() {
+        return false;
+    }
+    stopPropagation() {
+    }
+    stopImmediatePropagation() {
+    }
+    preventDefault() {
+        if (this.$cancelable) {
+            this.$defaultPrevented = true;
+        }
+    }
+}
+Object.defineProperties(Event, PHASE_CONSTANTS);
+Object.defineProperties(Event.prototype, PHASE_CONSTANTS);
+function addDOMEventTargetMethods(target) {
+    if (typeof target.addEventListener === 'function') {
+        return;
+    }
+    let listeners;
+    target.addEventListener = function (type, listener /* , useCapture*/) {
+        if (arguments.length < 2) {
+            throw new Error('Not enough arguments to addEventListener');
+        }
+        if (!listeners) {
+            listeners = [];
+        }
+        if (!(type in listeners)) {
+            listeners[type] = [];
+        }
+        if (!listeners[type].includes(listener)) {
+            listeners[type].push(listener);
+        }
+    };
+    target.removeEventListener = function (type, listener /* , useCapture */) {
+        if (arguments.length < 2) {
+            throw new Error('Not enough arguments to removeEventListener');
+        }
+        if (listeners && type in listeners) {
+            const index = listeners[type].indexOf(listener);
+            if (index !== -1) {
+                listeners[type].splice(index, 1);
+            }
+        }
+    };
+    target.dispatchEvent = function (event) {
+        if (arguments.length < 1) {
+            throw new Error('Not enough arguments to dispatchEvent');
+        }
+        if (!(event instanceof Event)) {
+            throw new Error('Invalid event given to dispatchEvent');
+        }
+        event.$target = target;
+        if (listeners && event.type in listeners) {
+            for (const listener of listeners[event.type]) {
+                listener.call(this, event);
+            }
+        }
+        return !event.defaultPrevented;
+    };
+}
+function defineEventHandlerProperties(target, types) {
+    types.forEach(type => defineEventHandlerProperty(target, type));
+}
+function defineEventHandlerProperty(target, type) {
+    const handler = 'on' + type;
+    if (handler in target) {
+        return;
+    }
+    let listener = null;
+    Object.defineProperty(target, handler, {
+        get() {
+            return listener;
+        },
+        set(value) {
+            // ignore other types, mimicks the behavior of Firefox and Chromium
+            if (typeof value === 'function') {
+                if (listener) {
+                    target.removeEventListener(type, listener);
+                }
+                listener = value;
+                target.addEventListener(type, listener);
+            }
+        }
+    });
+}
+
+class ImageData {
+    constructor() {
+        if (arguments.length < 2) {
+            throw new TypeError('Not enough arguments to ImageData');
+        }
+        let array, width, height;
+        if (arguments[0] instanceof Uint8ClampedArray) {
+            array = checkArray(arguments[0]);
+            width = checkSize(arguments[1]);
+            height = arguments.length > 2 ? checkSize(arguments[2]) : array.byteLength / 4 / width;
+            if (array.byteLength !== width * height * 4) {
+                throw new Error('Wrong array size');
+            }
+        }
+        else {
+            width = checkSize(arguments[0]);
+            height = checkSize(arguments[1]);
+            array = new Uint8ClampedArray(width * height * 4);
+        }
+        Object.defineProperties(this, {
+            data: { value: array },
+            width: { value: width },
+            height: { value: height }
+        });
+    }
+}
+Object.defineProperty(ImageData.prototype, 'data', { value: /** @type {Uint8ClampedArray} */ (null) });
+Object.defineProperty(ImageData.prototype, 'width', { value: 0 });
+Object.defineProperty(ImageData.prototype, 'height', { value: 0 });
+function checkArray(array) {
+    if (array.byteLength % 4 !== 0) {
+        throw new Error('Illegal array length');
+    }
+    return array;
+}
+function checkSize(input) {
+    const size = Math.floor(input);
+    if (size <= 0 || !isFinite(size)) {
+        throw new Error('Illegal size for ImageData');
+    }
+    return size;
+}
+
+const EVENT_TYPES = ['message', 'error', 'messageerror'];
+class _Worker extends NativeObject {
+    get _nativeType() {
+        return 'tabris.Worker';
+    }
+    postMessage(param) {
+        this._nativeCall('postMessage', param);
+    }
+    terminate() {
+        this._nativeCall('terminate');
+    }
+}
+NativeObject.defineProperties(_Worker.prototype, {
+    scriptPath: { type: 'string', const: true, default: '' }
+});
+NativeObject.defineEvents(_Worker.prototype, {
+    message: { native: true },
+    error: { native: true },
+    messageError: true
+});
+class Worker {
+    constructor(scriptPath) {
+        if (typeof scriptPath !== 'string') {
+            throw new Error('The Worker script path has to be of type string');
+        }
+        addDOMEventTargetMethods(this);
+        defineEventHandlerProperties(this, EVENT_TYPES);
+        Object.defineProperty(this, '_nativeObject', {
+            enumerable: false, writable: false, value: this.$createNativeObject(scriptPath)
+        });
+    }
+    $createNativeObject(scriptPath) {
+        return new _Worker({
+            scriptPath
+        }).on({
+            _message: ({ data, logs, internal }) => {
+                try {
+                    if (logs instanceof Array) {
+                        for (const logData of logs) {
+                            tabris.trigger('log', logData);
+                        }
+                    }
+                }
+                finally {
+                    if (!internal) {
+                        this.dispatchEvent(Object.assign(new Event('message'), { data }));
+                    }
+                }
+            },
+            _error: ({ message }) => {
+                this.dispatchEvent(Object.assign(new Event('error'), { message }));
+            },
+            _messageError: ({ message }) => {
+                this.dispatchEvent(Object.assign(new Event('messageerror'), { message }));
+            }
+        });
+    }
+    postMessage(data, transferList) {
+        validateMessage(data);
+        this._nativeObject._nativeCall('postMessage', { data, transferList });
+    }
+    terminate() {
+        this._nativeObject._nativeCall('postMessage', { internal: true, data: 'terminate' });
+        this._nativeObject._nativeCall('terminate');
+    }
+}
+function validateMessage(message) {
+    if (!isValidMessage(message)) {
+        throw new TypeError('The message could not be cloned');
+    }
+    else {
+        if (message instanceof Array) {
+            for (const messageEntry of message) {
+                validateMessage(messageEntry);
+            }
+        }
+        else if (typeof (message) === 'object') {
+            for (const property in message) {
+                if (Object.prototype.hasOwnProperty.call(message, property)) {
+                    validateMessage(message[property]);
+                }
+            }
+        }
+    }
+}
+function isValidMessage(message) {
+    return message === undefined ||
+        message === null ||
+        typeof message === 'string' ||
+        typeof message === 'number' ||
+        typeof message === 'boolean' ||
+        message && typeof message === 'object' &&
+            (message.constructor === Object ||
+                message.constructor === Array ||
+                message.constructor === DataView ||
+                message.constructor === ArrayBuffer ||
+                message.constructor === ImageData);
+}
+
 class Tabris extends NativeObject {
     constructor() {
         super();
+        this._logPushInterval = -1;
+        this._logBuffer = null;
+        this._pushBufferTimer = null;
         Object.defineProperties(this, {
             _started: { enumerable: false, writable: true, value: false },
             _init: { enumerable: false, writable: true, value: this._init.bind(this) },
+            postMessage: { enumerable: false, value: this.postMessage.bind(this) },
+            close: { enumerable: false, value: this.close.bind(this) },
+            $sendLogBufferInternal: { enumerable: false, value: this.$sendLogBufferInternal.bind(this) },
             _notify: { enumerable: false, writable: true, value: this._notify.bind(this) },
             _stackTraceStack: { enumerable: false, writable: true, value: [] },
             _nativeObjectRegistry: { enumerable: false, writable: true, value: null },
@@ -4721,17 +5008,48 @@ class Tabris extends NativeObject {
         this.$publishProxies();
     }
     get version() {
-        return '3.8.0-dev.20210928+0310';
+        return '3.8.0-dev.20211003+0318';
     }
     get started() {
         return !!this._started;
     }
+    get logPushInterval() {
+        return this._logPushInterval;
+    }
+    set logPushInterval(value) {
+        this._logPushInterval = value;
+        if (this.headless && this.logPushInterval > -1) {
+            this.on('_log', this.$logToBuffer, this);
+            this.$logToBuffer({});
+        }
+        else {
+            this._logBuffer = null;
+            this.off('_log', this.$logToBuffer, this);
+        }
+    }
     flush() {
         this.trigger('tick');
         this.trigger('flush');
         this._nativeBridge.clearCache();
         this._nativeBridge.flush();
     }
+    postMessage(data, transferList) {
+        if (this.headless) {
+            validateMessage(data);
+            const logs = this.logPushInterval >= 0 ? this._logBuffer : null;
+            const internal = false;
+            this._nativeCall('postMessage', { data, transferList, logs, internal });
+            if (logs) {
+                this._logBuffer = null;
+            }
+        }
+    }
+    close() {
+        if (this.headless) {
+            this.$sendLogBufferInternal();
+            this._nativeCall('close', {});
+        }
+    }
     get _nativeType() {
         return 'tabris.Tabris';
     }
@@ -4744,12 +5062,23 @@ class Tabris extends NativeObject {
         Object.defineProperty(this, 'cid', { value: cid });
     }
     _init(client, options) {
+        var _a;
         this._client = client;
+        Object.defineProperty(this, 'headless', { writable: false, value: !!(options === null || options === void 0 ? void 0 : options.headless) });
         this._nativeBridge = new NativeBridge(client);
         this._register();
         this._nativeBridge.create(this.cid, this._nativeType);
+        if (this.headless) {
+            this.on('_log', this.$logToBuffer, this);
+            this._listen('message', true);
+        }
         this.trigger('start', options || { headless: false });
+        if ((_a = this.$app) === null || _a === void 0 ? void 0 : _a.debugBuild) {
+            this.logPushInterval = 2000;
+        }
         this._started = true;
+        global.postMessage = this.postMessage;
+        global.close = this.close;
     }
     _setEntryPoint(entryPoint) {
         this._entryPoint = entryPoint;
@@ -4777,6 +5106,15 @@ class Tabris extends NativeObject {
         }
         return returnValue;
     }
+    _trigger(event, param) {
+        if (event === 'message') {
+            return this.$handleMessage(param);
+        }
+        else if (event === 'messageError') {
+            return this.$handleMessageError(param);
+        }
+        return super._trigger(event, param);
+    }
     $publishProxies() {
         [
             'contentView', 'drawer', 'navigationBar', 'statusBar', 'permission', 'printer', 'device', 'app', 'localStorage',
@@ -4786,12 +5124,57 @@ class Tabris extends NativeObject {
             Object.defineProperty(this, name, { value });
         });
     }
+    $logToBuffer({ level, message }) {
+        if (!this._logBuffer) {
+            this._logBuffer = [];
+        }
+        if (level) {
+            this._logBuffer.push({ level, message, logTime: Date.now() });
+        }
+        if (this.logPushInterval > -1 && this._pushBufferTimer === null) {
+            this._pushBufferTimer = setTimeout(this.$sendLogBufferInternal, this.logPushInterval);
+        }
+    }
+    $handleMessage({ internal, data }) {
+        if (internal) {
+            if (data === 'terminate') {
+                this.$sendLogBufferInternal();
+            }
+        }
+        else {
+            this.trigger('message', { data });
+            const event = Object.assign(new Event('message'), { data });
+            global.dispatchEvent(event);
+        }
+        return false;
+    }
+    $sendLogBufferInternal() {
+        const logs = this._logBuffer;
+        this._pushBufferTimer = null;
+        this._logBuffer = null;
+        if (this.logPushInterval === -1) {
+            this.off('_log', this.$logToBuffer, this);
+            return;
+        }
+        if (!logs) {
+            return;
+        }
+        this._nativeCall('postMessage', { logs, internal: true });
+    }
+    $handleMessageError(rawEvent) {
+        this.trigger('messageError', rawEvent);
+        const event = Object.assign(new Event('messageerror'), { data: rawEvent.data });
+        global.dispatchEvent(event);
+        return false;
+    }
 }
 NativeObject.defineEvents(Tabris.prototype, {
     start: {},
     flush: {},
     layout: {},
-    log: {}
+    log: {},
+    message: { native: true },
+    messageError: { native: true }
 });
 
 const SUPPORTED_ENCODINGS = ['ascii', 'utf-8'];
@@ -5096,49 +5479,6 @@ function defineReadOnlyProperty(target, name, getter) {
     });
 }
 
-class ImageData {
-    constructor() {
-        if (arguments.length < 2) {
-            throw new TypeError('Not enough arguments to ImageData');
-        }
-        let array, width, height;
-        if (arguments[0] instanceof Uint8ClampedArray) {
-            array = checkArray(arguments[0]);
-            width = checkSize(arguments[1]);
-            height = arguments.length > 2 ? checkSize(arguments[2]) : array.byteLength / 4 / width;
-            if (array.byteLength !== width * height * 4) {
-                throw new Error('Wrong array size');
-            }
-        }
-        else {
-            width = checkSize(arguments[0]);
-            height = checkSize(arguments[1]);
-            array = new Uint8ClampedArray(width * height * 4);
-        }
-        Object.defineProperties(this, {
-            data: { value: array },
-            width: { value: width },
-            height: { value: height }
-        });
-    }
-}
-Object.defineProperty(ImageData.prototype, 'data', { value: /** @type {Uint8ClampedArray} */ (null) });
-Object.defineProperty(ImageData.prototype, 'width', { value: 0 });
-Object.defineProperty(ImageData.prototype, 'height', { value: 0 });
-function checkArray(array) {
-    if (array.byteLength % 4 !== 0) {
-        throw new Error('Illegal array length');
-    }
-    return array;
-}
-function checkSize(input) {
-    const size = Math.floor(input);
-    if (size <= 0 || !isFinite(size)) {
-        throw new Error('Illegal size for ImageData');
-    }
-    return size;
-}
-
 const OPCODES = {
     arc: 1,
     arcTo: 2,
@@ -7945,142 +8285,6 @@ function create$7() {
     return new DevTools(true);
 }
 
-const PHASE_CONSTANTS = {
-    NONE: { value: 0 },
-    CAPTURING_PHASE: { value: 1 },
-    AT_TARGET: { value: 2 },
-    BUBBLING_PHASE: { value: 3 }
-};
-class Event {
-    constructor(type, config) {
-        if (arguments.length < 1) {
-            throw new Error('Not enough arguments to Event');
-        }
-        Object.defineProperties(this, {
-            $timeStamp: { enumerable: false, writable: true, value: Date.now() },
-            $type: { enumerable: false, writable: true, value: type || '' },
-            $bubbles: { enumerable: false, writable: true, value: config && !!config.bubbles || false },
-            $cancelable: { enumerable: false, writable: true, value: config && !!config.cancelable || false },
-            $target: { enumerable: false, writable: true, value: null },
-            $defaultPrevented: { enumerable: false, writable: true, value: false }
-        });
-    }
-    initEvent(type, bubbles, cancelable) {
-        if (arguments.length < 3) {
-            throw new Error('Not enough arguments to initEvent');
-        }
-        this.$type = type + '';
-        this.$bubbles = !!bubbles;
-        this.$cancelable = !!cancelable;
-    }
-    get type() {
-        return this.$type;
-    }
-    get timeStamp() {
-        return this.$timeStamp;
-    }
-    get bubbles() {
-        return this.$bubbles;
-    }
-    get cancelable() {
-        return this.$cancelable;
-    }
-    get target() {
-        return this.$target;
-    }
-    get currentTarget() {
-        return this.$target;
-    }
-    get defaultPrevented() {
-        return this.$defaultPrevented;
-    }
-    get eventPhase() {
-        return 0;
-    }
-    get isTrusted() {
-        return false;
-    }
-    stopPropagation() {
-    }
-    stopImmediatePropagation() {
-    }
-    preventDefault() {
-        if (this.$cancelable) {
-            this.$defaultPrevented = true;
-        }
-    }
-}
-Object.defineProperties(Event, PHASE_CONSTANTS);
-Object.defineProperties(Event.prototype, PHASE_CONSTANTS);
-function addDOMEventTargetMethods(target) {
-    if (typeof target.addEventListener === 'function') {
-        return;
-    }
-    let listeners;
-    target.addEventListener = function (type, listener /* , useCapture*/) {
-        if (arguments.length < 2) {
-            throw new Error('Not enough arguments to addEventListener');
-        }
-        if (!listeners) {
-            listeners = [];
-        }
-        if (!(type in listeners)) {
-            listeners[type] = [];
-        }
-        if (!listeners[type].includes(listener)) {
-            listeners[type].push(listener);
-        }
-    };
-    target.removeEventListener = function (type, listener /* , useCapture */) {
-        if (arguments.length < 2) {
-            throw new Error('Not enough arguments to removeEventListener');
-        }
-        if (listeners && type in listeners) {
-            const index = listeners[type].indexOf(listener);
-            if (index !== -1) {
-                listeners[type].splice(index, 1);
-            }
-        }
-    };
-    target.dispatchEvent = function (event) {
-        if (arguments.length < 1) {
-            throw new Error('Not enough arguments to dispatchEvent');
-        }
-        if (!(event instanceof Event)) {
-            throw new Error('Invalid event given to dispatchEvent');
-        }
-        event.$target = target;
-        if (listeners && event.type in listeners) {
-            for (const listener of listeners[event.type]) {
-                listener.call(this, event);
-            }
-        }
-        return !event.defaultPrevented;
-    };
-}
-function defineEventHandlerProperties(target, types) {
-    types.forEach(type => defineEventHandlerProperty(target, type));
-}
-function defineEventHandlerProperty(target, type) {
-    const handler = 'on' + type;
-    let listener = null;
-    Object.defineProperty(target, handler, {
-        get() {
-            return listener;
-        },
-        set(value) {
-            // ignore other types, mimicks the behavior of Firefox and Chromium
-            if (typeof value === 'function') {
-                if (listener) {
-                    target.removeEventListener(type, listener);
-                }
-                listener = value;
-                target.addEventListener(type, listener);
-            }
-        }
-    });
-}
-
 function addDOMDocument(target) {
     class HTMLElement {
         constructor(tagName) {
@@ -11975,13 +12179,13 @@ NativeObject.defineProperties(Video.prototype, {
     state: { readonly: true, nocache: true }
 });
 
-const EVENT_TYPES = ['navigate', 'load', 'download', 'message'];
+const EVENT_TYPES$1 = ['navigate', 'load', 'download', 'message'];
 class WebView extends Widget {
     get _nativeType() {
         return 'tabris.WebView';
     }
     _listen(name, listening) {
-        if (EVENT_TYPES.includes(name)) {
+        if (EVENT_TYPES$1.includes(name)) {
             this._nativeListen(name, listening);
         }
         else {
@@ -12042,11 +12246,11 @@ const CONSTANTS = {
     CLOSING: { value: CLOSING },
     CLOSED: { value: CLOSED }
 };
-const EVENT_TYPES$1 = ['open', 'message', 'close', 'error'];
+const EVENT_TYPES$2 = ['open', 'message', 'close', 'error'];
 class _WebSocket extends NativeObject {
     constructor(properties) {
         super(properties);
-        EVENT_TYPES$1.forEach(type => this._nativeListen(type, true));
+        EVENT_TYPES$2.forEach(type => this._nativeListen(type, true));
     }
     get _nativeType() {
         return 'tabris.WebSocket';
@@ -12076,7 +12280,7 @@ class WebSocket {
         this.protocol = '';
         this.extensions = '';
         addDOMEventTargetMethods(this);
-        defineEventHandlerProperties(this, EVENT_TYPES$1);
+        defineEventHandlerProperties(this, EVENT_TYPES$2);
         Object.defineProperty(this, '_nativeObject', {
             enumerable: false, writable: false, value: this.$createProxy(url, protocols)
         });
@@ -12185,80 +12389,6 @@ function extractScheme(url) {
     return match ? match[1] : null;
 }
 
-const EVENT_TYPES$2 = ['message', 'error', 'messageerror'];
-class _Worker extends NativeObject {
-    get _nativeType() {
-        return 'tabris.Worker';
-    }
-}
-NativeObject.defineProperty(_Worker.prototype, 'scriptPath', { type: 'string', default: '' });
-NativeObject.defineEvents(_Worker.prototype, {
-    message: { native: true },
-    error: { native: true },
-    messageError: true
-});
-class Worker {
-    constructor(scriptPath) {
-        if (typeof scriptPath !== 'string') {
-            throw new Error('The Worker script path has to be of type string');
-        }
-        addDOMEventTargetMethods(this);
-        defineEventHandlerProperties(this, EVENT_TYPES$2);
-        Object.defineProperty(this, '_nativeObject', {
-            enumerable: false, writable: false, value: this.$createProxy({ scriptPath })
-        });
-    }
-    $createProxy(scriptPath) {
-        return new _Worker(scriptPath)
-            .onMessage((event) => {
-            this.dispatchEvent(Object.assign(new Event('message'), omit(event, ['target', 'type', 'timeStamp'])));
-        }).onError((event) => {
-            this.dispatchEvent(Object.assign(new Event('error'), omit(event, ['target', 'type', 'timeStamp'])));
-        }).onMessageError((event) => {
-            this.dispatchEvent(Object.assign(new Event('messageerror'), omit(event, ['target', 'type', 'timeStamp'])));
-        });
-    }
-    postMessage(message, transferList) {
-        this._validateMessage(message);
-        this._nativeObject._nativeCall('postMessage', { message, transferList });
-    }
-    _validateMessage(message) {
-        if (!this._isValidMessage(message)) {
-            this.dispatchEvent(Object.assign(new Event('messageerror')));
-        }
-        else {
-            if (message instanceof Array) {
-                for (let i = 0; i < message.length; i++) {
-                    this._validateMessage(message[i]);
-                }
-            }
-            else if (typeof (message) === 'object') {
-                for (const property in message) {
-                    if (Object.prototype.hasOwnProperty.call(message, property)) {
-                        this._validateMessage(message[property]);
-                    }
-                }
-            }
-        }
-    }
-    _isValidMessage(message) {
-        return message === undefined ||
-            message === null ||
-            typeof message === 'string' ||
-            typeof message === 'number' ||
-            typeof message === 'boolean' ||
-            message &&
-                (message.constructor === Object ||
-                    message.constructor === Array ||
-                    message.constructor === DataView ||
-                    message.constructor === ArrayBuffer ||
-                    message.constructor === ImageData);
-    }
-    terminate() {
-        this._nativeObject._nativeCall('terminate');
-    }
-}
-
 class HttpRequest extends NativeObject {
     constructor() {
         super();
@@ -13169,6 +13299,7 @@ else {
     Object.assign(global, WHATWG, { $ });
     addDOMDocument(global);
     addDOMEventTargetMethods(global);
+    defineEventHandlerProperties(global, ['message', 'messageerror', 'error']);
     addWindowTimerMethods(global);
 }
 tabrisMain.on('start', (options) => {