@nativescript/core 8.9.0-napi-es5.0 → 8.9.0-napi.1

package/xhr/index.js

@@ -1,4 +1,4 @@
-var _a, _b;
+var _a, _b, _c;
 import * as http from '../http';
 import * as types from '../utils/types';
 import { Trace } from '../trace';
@@ -10,8 +10,61 @@ var XMLHttpRequestResponseType;
     XMLHttpRequestResponseType.blob = 'blob';
     XMLHttpRequestResponseType.arraybuffer = 'arraybuffer';
 })(XMLHttpRequestResponseType || (XMLHttpRequestResponseType = {}));
-var XMLHttpRequest = /** @class */ (function () {
-    function XMLHttpRequest() {
+export class XMLHttpRequest {
+    get upload() {
+        return this;
+    }
+    get readyState() {
+        return this._readyState;
+    }
+    get responseType() {
+        return this._responseType;
+    }
+    set responseType(value) {
+        if (value === XMLHttpRequestResponseType.empty || value in XMLHttpRequestResponseType) {
+            this._responseType = value;
+        }
+        else {
+            throw new Error(`Response type of '${value}' not supported.`);
+        }
+    }
+    get responseText() {
+        if (this._responseType !== XMLHttpRequestResponseType.empty && this._responseType !== XMLHttpRequestResponseType.text) {
+            throw new Error("Failed to read the 'responseText' property from 'XMLHttpRequest': " + "The value is only accessible if the object's 'responseType' is '' or 'text' " + `(was '${this._responseType}').`);
+        }
+        if (types.isFunction(this._responseTextReader)) {
+            return this._responseTextReader();
+        }
+        return '';
+    }
+    get response() {
+        if (this._responseType === XMLHttpRequestResponseType.empty || this._responseType === XMLHttpRequestResponseType.text) {
+            if (this._readyState !== this.LOADING && this._readyState !== this.DONE) {
+                return '';
+            }
+            else {
+                return this._response;
+            }
+        }
+        else {
+            if (this._readyState !== this.DONE) {
+                return null;
+            }
+            else {
+                return this._response;
+            }
+        }
+    }
+    get status() {
+        return this._status;
+    }
+    get statusText() {
+        if (this._readyState === this.UNSENT || this._readyState === this.OPENED || this._errorFlag) {
+            return '';
+        }
+        return statuses[this._status];
+    }
+    constructor() {
         this.UNSENT = 0;
         this.OPENED = 1;
         this.HEADERS_RECEIVED = 2;
@@ -21,96 +74,15 @@ var XMLHttpRequest = /** @class */ (function () {
         this._listeners = new Map();
         this._readyState = this.UNSENT;
     }
-    Object.defineProperty(XMLHttpRequest.prototype, "upload", {
-        get: function () {
-            return this;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(XMLHttpRequest.prototype, "readyState", {
-        get: function () {
-            return this._readyState;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(XMLHttpRequest.prototype, "responseType", {
-        get: function () {
-            return this._responseType;
-        },
-        set: function (value) {
-            if (value === XMLHttpRequestResponseType.empty || value in XMLHttpRequestResponseType) {
-                this._responseType = value;
-            }
-            else {
-                throw new Error("Response type of '".concat(value, "' not supported."));
-            }
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(XMLHttpRequest.prototype, "responseText", {
-        get: function () {
-            if (this._responseType !== XMLHttpRequestResponseType.empty && this._responseType !== XMLHttpRequestResponseType.text) {
-                throw new Error("Failed to read the 'responseText' property from 'XMLHttpRequest': " + "The value is only accessible if the object's 'responseType' is '' or 'text' " + "(was '".concat(this._responseType, "')."));
-            }
-            if (types.isFunction(this._responseTextReader)) {
-                return this._responseTextReader();
-            }
-            return '';
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(XMLHttpRequest.prototype, "response", {
-        get: function () {
-            if (this._responseType === XMLHttpRequestResponseType.empty || this._responseType === XMLHttpRequestResponseType.text) {
-                if (this._readyState !== this.LOADING && this._readyState !== this.DONE) {
-                    return '';
-                }
-                else {
-                    return this._response;
-                }
-            }
-            else {
-                if (this._readyState !== this.DONE) {
-                    return null;
-                }
-                else {
-                    return this._response;
-                }
-            }
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(XMLHttpRequest.prototype, "status", {
-        get: function () {
-            return this._status;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(XMLHttpRequest.prototype, "statusText", {
-        get: function () {
-            if (this._readyState === this.UNSENT || this._readyState === this.OPENED || this._errorFlag) {
-                return '';
-            }
-            return statuses[this._status];
-        },
-        enumerable: false,
-        configurable: true
-    });
-    XMLHttpRequest.prototype._loadResponse = function (r) {
+    _loadResponse(r) {
         this._status = r.statusCode;
         this._headers = r.headers;
         this._setReadyState(this.HEADERS_RECEIVED);
         this._setReadyState(this.LOADING);
-        this._responseTextReader = function () { return r.content.toString(); };
-        var contentType = this.getResponseHeader('Content-Type');
-        var mimeType = (contentType && contentType.toLowerCase()) || 'text/xml';
-        var finalMimeType = this._overrideMimeType || mimeType;
+        this._responseTextReader = () => r.content.toString();
+        const contentType = this.getResponseHeader('Content-Type');
+        const mimeType = (contentType && contentType.toLowerCase()) || 'text/xml';
+        const finalMimeType = this._overrideMimeType || mimeType;
         if (this._responseType === XMLHttpRequestResponseType.json) {
             this._response = r.content.toJSON();
         }
@@ -128,21 +100,17 @@ var XMLHttpRequest = /** @class */ (function () {
         this.emitEvent('progress');
         this._sendFlag = false;
         this._setReadyState(this.DONE);
-    };
-    XMLHttpRequest.prototype.emitEvent = function (eventName) {
-        var args = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            args[_i - 1] = arguments[_i];
-        }
+    }
+    emitEvent(eventName, ...args) {
         if (types.isFunction(this['on' + eventName])) {
-            this['on' + eventName].apply(this, args);
+            this['on' + eventName](...args);
         }
-        var handlers = this._listeners.get(eventName) || [];
-        handlers.forEach(function (handler) {
-            handler.apply(void 0, args);
+        const handlers = this._listeners.get(eventName) || [];
+        handlers.forEach((handler) => {
+            handler(...args);
         });
-    };
-    XMLHttpRequest.prototype._setReadyState = function (value) {
+    }
+    _setReadyState(value) {
         if (this._readyState !== value) {
             this._readyState = value;
             this.emitEvent('readystatechange');
@@ -151,30 +119,30 @@ var XMLHttpRequest = /** @class */ (function () {
             this.emitEvent('load');
             this.emitEvent('loadend');
         }
-    };
-    XMLHttpRequest.prototype._setRequestError = function (eventName, error) {
+    }
+    _setRequestError(eventName, error) {
         this._readyState = this.DONE;
         this._response = error;
         this.emitEvent('readystatechange');
         this.emitEvent(eventName, error);
         this.emitEvent('loadend');
-    };
-    XMLHttpRequest.prototype.addEventListener = function (eventName, handler) {
+    }
+    addEventListener(eventName, handler) {
         if (['abort', 'error', 'load', 'loadend', 'loadstart', 'progress', 'readystatechange'].indexOf(eventName) === -1) {
             if (Trace.isEnabled()) {
                 Trace.write('XHR Event not supported: ' + eventName, Trace.categories.Debug, Trace.messageType.warn);
             }
         }
-        var handlers = this._listeners.get(eventName) || [];
+        const handlers = this._listeners.get(eventName) || [];
         handlers.push(handler);
         this._listeners.set(eventName, handlers);
-    };
-    XMLHttpRequest.prototype.removeEventListener = function (eventName, toDetach) {
-        var handlers = this._listeners.get(eventName) || [];
-        handlers = handlers.filter(function (handler) { return handler !== toDetach; });
+    }
+    removeEventListener(eventName, toDetach) {
+        let handlers = this._listeners.get(eventName) || [];
+        handlers = handlers.filter((handler) => handler !== toDetach);
         this._listeners.set(eventName, handlers);
-    };
-    XMLHttpRequest.prototype.open = function (method, url, async, user, password) {
+    }
+    open(method, url, async, user, password) {
         if (types.isString(method) && types.isString(url)) {
             this._options = { url: url, method: method };
             this._options.headers = {};
@@ -186,8 +154,8 @@ var XMLHttpRequest = /** @class */ (function () {
             }
             this._setReadyState(this.OPENED);
         }
-    };
-    XMLHttpRequest.prototype.abort = function () {
+    }
+    abort() {
         this._response = null;
         this._responseTextReader = null;
         this._headers = null;
@@ -200,9 +168,8 @@ var XMLHttpRequest = /** @class */ (function () {
         if (this._readyState === this.DONE) {
             this._readyState = this.UNSENT;
         }
-    };
-    XMLHttpRequest.prototype.send = function (data) {
-        var _this = this;
+    }
+    send(data) {
         this._errorFlag = false;
         this._response = null;
         this._responseTextReader = null;
@@ -231,56 +198,54 @@ var XMLHttpRequest = /** @class */ (function () {
         this.emitEvent('loadstart');
         http
             .request(this._options)
-            .then(function (r) {
-            if (!_this._errorFlag && _this._sendFlag) {
-                _this._loadResponse(r);
+            .then((r) => {
+            if (!this._errorFlag && this._sendFlag) {
+                this._loadResponse(r);
             }
         })
-            .catch(function (e) {
-            _this._errorFlag = true;
-            _this._sendFlag = false;
-            _this._setRequestError('error', e);
+            .catch((e) => {
+            this._errorFlag = true;
+            this._sendFlag = false;
+            this._setRequestError('error', e);
         });
-    };
-    XMLHttpRequest.prototype.setRequestHeader = function (header, value) {
+    }
+    setRequestHeader(header, value) {
         if (this._readyState !== this.OPENED || this._sendFlag) {
             throw new Error("Failed to execute 'setRequestHeader' on 'XMLHttpRequest': " + "The object's state must be OPENED.");
         }
         if (types.isString(header) && types.isString(value)) {
             this._options.headers[header] = value;
         }
-    };
-    XMLHttpRequest.prototype.getAllResponseHeaders = function () {
+    }
+    getAllResponseHeaders() {
         if (this._readyState < 2 || this._errorFlag) {
             return '';
         }
-        var result = '';
-        for (var i in this._headers) {
+        let result = '';
+        for (const i in this._headers) {
             result += i + ': ' + this._headers[i] + '\r\n';
         }
         return result.substr(0, result.length - 2);
-    };
-    XMLHttpRequest.prototype.getResponseHeader = function (header) {
+    }
+    getResponseHeader(header) {
         if (types.isString(header) && this._readyState > 1 && this._headers && !this._errorFlag) {
             header = header.toLowerCase();
-            for (var i in this._headers) {
+            for (const i in this._headers) {
                 if (i.toLowerCase() === header) {
                     return this._headers[i];
                 }
             }
         }
         return null;
-    };
-    XMLHttpRequest.prototype.overrideMimeType = function (mime) {
+    }
+    overrideMimeType(mime) {
         if (this._readyState === this.LOADING || this._readyState === this.DONE) {
             throw new Error("Failed to execute 'overrideMimeType' on 'XMLHttpRequest': " + 'MimeType cannot be overridden when the state is LOADING or DONE.');
         }
         this._overrideMimeType = mime;
-    };
-    return XMLHttpRequest;
-}());
-export { XMLHttpRequest };
-var statuses = {
+    }
+}
+const statuses = {
     100: 'Continue',
     101: 'Switching Protocols',
     200: 'OK',
@@ -322,36 +287,37 @@ var statuses = {
     504: 'Gateway Timeout',
     505: 'HTTP Version Not Supported',
 };
-var FormData = /** @class */ (function () {
-    function FormData() {
+export class FormData {
+    constructor() {
         this._data = new Map();
     }
-    FormData.prototype.append = function (name, value) {
+    append(name, value) {
         this._data.set(name, value);
-    };
-    FormData.prototype.toString = function () {
-        var arr = new Array();
+    }
+    toString() {
+        const arr = new Array();
         this._data.forEach(function (value, name, map) {
-            arr.push("".concat(encodeURIComponent(name), "=").concat(encodeURIComponent(value)));
+            arr.push(`${encodeURIComponent(name)}=${encodeURIComponent(value)}`);
         });
         return arr.join('&');
-    };
-    return FormData;
-}());
-export { FormData };
-var Blob = /** @class */ (function () {
-    function Blob(chunks, opts) {
-        if (chunks === void 0) { chunks = []; }
-        if (opts === void 0) { opts = {}; }
-        this[_c] = 'Blob';
-        var dataChunks = [];
-        for (var _i = 0, chunks_1 = chunks; _i < chunks_1.length; _i++) {
-            var chunk = chunks_1[_i];
+    }
+}
+export class Blob {
+    get size() {
+        return this._size;
+    }
+    get type() {
+        return this._type;
+    }
+    constructor(chunks = [], opts = {}) {
+        this[_a] = 'Blob';
+        const dataChunks = [];
+        for (const chunk of chunks) {
             if (chunk instanceof Blob) {
                 dataChunks.push(chunk._buffer);
             }
             else if (typeof chunk === 'string') {
-                var textEncoder = new TextEncoder();
+                const textEncoder = new TextEncoder();
                 dataChunks.push(textEncoder.encode(chunk));
             }
             else if (chunk instanceof DataView) {
@@ -361,15 +327,15 @@ var Blob = /** @class */ (function () {
                 dataChunks.push(new Uint8Array(ArrayBuffer.isView(chunk) ? chunk.buffer.slice(0) : chunk.slice(0)));
             }
             else {
-                var textEncoder = new TextEncoder();
+                const textEncoder = new TextEncoder();
                 dataChunks.push(textEncoder.encode(String(chunk)));
             }
         }
-        var size = dataChunks.reduce(function (size, chunk) { return size + chunk.byteLength; }, 0);
-        var buffer = new Uint8Array(size);
-        var offset = 0;
-        for (var i = 0; i < dataChunks.length; i++) {
-            var chunk = dataChunks[i];
+        const size = dataChunks.reduce((size, chunk) => size + chunk.byteLength, 0);
+        const buffer = new Uint8Array(size);
+        let offset = 0;
+        for (let i = 0; i < dataChunks.length; i++) {
+            const chunk = dataChunks[i];
             buffer.set(chunk, offset);
             offset += chunk.byteLength;
         }
@@ -383,118 +349,77 @@ var Blob = /** @class */ (function () {
             this._type = this._type.toLowerCase();
         }
     }
-    Object.defineProperty(Blob.prototype, "size", {
-        get: function () {
-            return this._size;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Blob.prototype, "type", {
-        get: function () {
-            return this._type;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Blob.prototype.arrayBuffer = function () {
+    arrayBuffer() {
         return Promise.resolve(this._buffer);
-    };
-    Blob.prototype.text = function () {
-        var textDecoder = new TextDecoder();
+    }
+    text() {
+        const textDecoder = new TextDecoder();
         return Promise.resolve(textDecoder.decode(this._buffer));
-    };
-    Blob.prototype.slice = function (start, end, type) {
-        var slice = this._buffer.slice(start || 0, end || this._buffer.length);
+    }
+    slice(start, end, type) {
+        const slice = this._buffer.slice(start || 0, end || this._buffer.length);
         return new Blob([slice], { type: type });
-    };
-    Blob.prototype.stream = function () {
+    }
+    stream() {
         throw new Error('stream is currently not supported');
-    };
-    Blob.prototype.toString = function () {
+    }
+    toString() {
         return '[object Blob]';
-    };
-    var _c;
-    _c = Symbol.toStringTag;
-    // Note: only for use by XHR
-    Blob.InternalAccessor = /** @class */ (function () {
-        function class_1() {
-        }
-        class_1.getBuffer = function (blob) {
-            return blob._buffer;
-        };
-        return class_1;
-    }());
-    return Blob;
-}());
-export { Blob };
-var File = /** @class */ (function (_super) {
-    __extends(File, _super);
-    function File(chunks, name, opts) {
-        if (opts === void 0) { opts = {}; }
-        var _this = _super.call(this, chunks, opts) || this;
-        _this[_a] = 'File';
-        _this._name = name.replace(/\//g, ':');
-        _this._lastModified = opts.lastModified ? new Date(opts.lastModified).valueOf() : Date.now();
-        return _this;
-    }
-    Object.defineProperty(File.prototype, "name", {
-        get: function () {
-            return this._name;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(File.prototype, "lastModified", {
-        get: function () {
-            return this._lastModified;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    File.prototype.toString = function () {
-        return '[object File]';
-    };
-    return File;
-}(Blob));
-export { File };
+    }
+}
 _a = Symbol.toStringTag;
-var FileReader = /** @class */ (function () {
-    function FileReader() {
+// Note: only for use by XHR
+Blob.InternalAccessor = class {
+    static getBuffer(blob) {
+        return blob._buffer;
+    }
+};
+export class File extends Blob {
+    get name() {
+        return this._name;
+    }
+    get lastModified() {
+        return this._lastModified;
+    }
+    constructor(chunks, name, opts = {}) {
+        super(chunks, opts);
+        this[_b] = 'File';
+        this._name = name.replace(/\//g, ':');
+        this._lastModified = opts.lastModified ? new Date(opts.lastModified).valueOf() : Date.now();
+    }
+    toString() {
+        return '[object File]';
+    }
+}
+_b = Symbol.toStringTag;
+export class FileReader {
+    get readyState() {
+        return this._readyState;
+    }
+    get result() {
+        return this._result;
+    }
+    constructor() {
         this.EMPTY = 0;
         this.LOADING = 1;
         this.DONE = 2;
         this._listeners = new Map();
-        this[_b] = 'FileReader';
+        this[_c] = 'FileReader';
         //
     }
-    Object.defineProperty(FileReader.prototype, "readyState", {
-        get: function () {
-            return this._readyState;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(FileReader.prototype, "result", {
-        get: function () {
-            return this._result;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    FileReader.prototype._array2base64 = function (input) {
-        var byteToCharMap = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
-        var output = [];
-        for (var i = 0; i < input.length; i += 3) {
-            var byte1 = input[i];
-            var haveByte2 = i + 1 < input.length;
-            var byte2 = haveByte2 ? input[i + 1] : 0;
-            var haveByte3 = i + 2 < input.length;
-            var byte3 = haveByte3 ? input[i + 2] : 0;
-            var outByte1 = byte1 >> 2;
-            var outByte2 = ((byte1 & 0x03) << 4) | (byte2 >> 4);
-            var outByte3 = ((byte2 & 0x0f) << 2) | (byte3 >> 6);
-            var outByte4 = byte3 & 0x3f;
+    _array2base64(input) {
+        const byteToCharMap = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+        const output = [];
+        for (let i = 0; i < input.length; i += 3) {
+            const byte1 = input[i];
+            const haveByte2 = i + 1 < input.length;
+            const byte2 = haveByte2 ? input[i + 1] : 0;
+            const haveByte3 = i + 2 < input.length;
+            const byte3 = haveByte3 ? input[i + 2] : 0;
+            const outByte1 = byte1 >> 2;
+            const outByte2 = ((byte1 & 0x03) << 4) | (byte2 >> 4);
+            let outByte3 = ((byte2 & 0x0f) << 2) | (byte3 >> 6);
+            let outByte4 = byte3 & 0x3f;
             if (!haveByte3) {
                 outByte4 = 64;
                 if (!haveByte2) {
@@ -504,66 +429,59 @@ var FileReader = /** @class */ (function () {
             output.push(byteToCharMap[outByte1], byteToCharMap[outByte2], byteToCharMap[outByte3], byteToCharMap[outByte4]);
         }
         return output.join('');
-    };
-    FileReader.prototype._read = function (blob, kind) {
-        var _this = this;
+    }
+    _read(blob, kind) {
         if (!(blob instanceof Blob)) {
-            throw new TypeError("Failed to execute '".concat(kind, "' on 'FileReader': parameter 1 is not of type 'Blob'."));
+            throw new TypeError(`Failed to execute '${kind}' on 'FileReader': parameter 1 is not of type 'Blob'.`);
         }
         this._result = '';
-        setTimeout(function () {
-            _this._readyState = _this.LOADING;
-            _this.emitEvent('load');
-            _this.emitEvent('loadend');
+        setTimeout(() => {
+            this._readyState = this.LOADING;
+            this.emitEvent('load');
+            this.emitEvent('loadend');
         });
-    };
-    FileReader.prototype.emitEvent = function (eventName) {
-        var args = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            args[_i - 1] = arguments[_i];
-        }
+    }
+    emitEvent(eventName, ...args) {
         if (types.isFunction(this['on' + eventName])) {
-            this['on' + eventName].apply(this, args);
+            this['on' + eventName](...args);
         }
-        var handlers = this._listeners.get(eventName) || [];
-        handlers.forEach(function (handler) {
-            handler.apply(void 0, args);
+        const handlers = this._listeners.get(eventName) || [];
+        handlers.forEach((handler) => {
+            handler(...args);
         });
-    };
-    FileReader.prototype.addEventListener = function (eventName, handler) {
+    }
+    addEventListener(eventName, handler) {
         if (['abort', 'error', 'load', 'loadend', 'loadstart', 'progress'].indexOf(eventName) === -1) {
             throw new Error('Event not supported: ' + eventName);
         }
-        var handlers = this._listeners.get(eventName) || [];
+        const handlers = this._listeners.get(eventName) || [];
         handlers.push(handler);
         this._listeners.set(eventName, handlers);
-    };
-    FileReader.prototype.removeEventListener = function (eventName, toDetach) {
-        var handlers = this._listeners.get(eventName) || [];
-        handlers = handlers.filter(function (handler) { return handler !== toDetach; });
+    }
+    removeEventListener(eventName, toDetach) {
+        let handlers = this._listeners.get(eventName) || [];
+        handlers = handlers.filter((handler) => handler !== toDetach);
         this._listeners.set(eventName, handlers);
-    };
-    FileReader.prototype.readAsDataURL = function (blob) {
+    }
+    readAsDataURL(blob) {
         this._read(blob, 'readAsDataURL');
-        this._result = "data:".concat(blob.type, ";base64,").concat(this._array2base64(Blob.InternalAccessor.getBuffer(blob)));
-    };
-    FileReader.prototype.readAsText = function (blob) {
+        this._result = `data:${blob.type};base64,${this._array2base64(Blob.InternalAccessor.getBuffer(blob))}`;
+    }
+    readAsText(blob) {
         this._read(blob, 'readAsText');
-        var textDecoder = new TextDecoder();
+        const textDecoder = new TextDecoder();
         this._result = textDecoder.decode(Blob.InternalAccessor.getBuffer(blob));
-    };
-    FileReader.prototype.readAsArrayBuffer = function (blob) {
+    }
+    readAsArrayBuffer(blob) {
         this._read(blob, 'readAsArrayBuffer');
         this._result = Blob.InternalAccessor.getBuffer(blob).buffer.slice(0);
-    };
-    FileReader.prototype.abort = function () {
+    }
+    abort() {
         //
-    };
-    FileReader.prototype.toString = function () {
+    }
+    toString() {
         return '[object FileReader]';
-    };
-    return FileReader;
-}());
-export { FileReader };
-_b = Symbol.toStringTag;
+    }
+}
+_c = Symbol.toStringTag;
 //# sourceMappingURL=index.js.map