@nativescript/core 8.9.0-alpha.3 → 8.9.0-napi-es5.0

package/xhr/index.js

@@ -1,4 +1,4 @@
-var _a, _b, _c;
+var _a, _b;
 import * as http from '../http';
 import * as types from '../utils/types';
 import { Trace } from '../trace';
@@ -10,61 +10,8 @@ var XMLHttpRequestResponseType;
     XMLHttpRequestResponseType.blob = 'blob';
     XMLHttpRequestResponseType.arraybuffer = 'arraybuffer';
 })(XMLHttpRequestResponseType || (XMLHttpRequestResponseType = {}));
-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() {
+var XMLHttpRequest = /** @class */ (function () {
+    function XMLHttpRequest() {
         this.UNSENT = 0;
         this.OPENED = 1;
         this.HEADERS_RECEIVED = 2;
@@ -74,15 +21,96 @@ export class XMLHttpRequest {
         this._listeners = new Map();
         this._readyState = this.UNSENT;
     }
-    _loadResponse(r) {
+    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) {
         this._status = r.statusCode;
         this._headers = r.headers;
         this._setReadyState(this.HEADERS_RECEIVED);
         this._setReadyState(this.LOADING);
-        this._responseTextReader = () => r.content.toString();
-        const contentType = this.getResponseHeader('Content-Type');
-        const mimeType = (contentType && contentType.toLowerCase()) || 'text/xml';
-        const finalMimeType = this._overrideMimeType || mimeType;
+        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;
         if (this._responseType === XMLHttpRequestResponseType.json) {
             this._response = r.content.toJSON();
         }
@@ -100,17 +128,21 @@ export class XMLHttpRequest {
         this.emitEvent('progress');
         this._sendFlag = false;
         this._setReadyState(this.DONE);
-    }
-    emitEvent(eventName, ...args) {
+    };
+    XMLHttpRequest.prototype.emitEvent = function (eventName) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
         if (types.isFunction(this['on' + eventName])) {
-            this['on' + eventName](...args);
+            this['on' + eventName].apply(this, args);
         }
-        const handlers = this._listeners.get(eventName) || [];
-        handlers.forEach((handler) => {
-            handler(...args);
+        var handlers = this._listeners.get(eventName) || [];
+        handlers.forEach(function (handler) {
+            handler.apply(void 0, args);
         });
-    }
-    _setReadyState(value) {
+    };
+    XMLHttpRequest.prototype._setReadyState = function (value) {
         if (this._readyState !== value) {
             this._readyState = value;
             this.emitEvent('readystatechange');
@@ -119,30 +151,30 @@ export class XMLHttpRequest {
             this.emitEvent('load');
             this.emitEvent('loadend');
         }
-    }
-    _setRequestError(eventName, error) {
+    };
+    XMLHttpRequest.prototype._setRequestError = function (eventName, error) {
         this._readyState = this.DONE;
         this._response = error;
         this.emitEvent('readystatechange');
         this.emitEvent(eventName, error);
         this.emitEvent('loadend');
-    }
-    addEventListener(eventName, handler) {
+    };
+    XMLHttpRequest.prototype.addEventListener = function (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);
             }
         }
-        const handlers = this._listeners.get(eventName) || [];
+        var handlers = this._listeners.get(eventName) || [];
         handlers.push(handler);
         this._listeners.set(eventName, handlers);
-    }
-    removeEventListener(eventName, toDetach) {
-        let handlers = this._listeners.get(eventName) || [];
-        handlers = handlers.filter((handler) => handler !== toDetach);
+    };
+    XMLHttpRequest.prototype.removeEventListener = function (eventName, toDetach) {
+        var handlers = this._listeners.get(eventName) || [];
+        handlers = handlers.filter(function (handler) { return handler !== toDetach; });
         this._listeners.set(eventName, handlers);
-    }
-    open(method, url, async, user, password) {
+    };
+    XMLHttpRequest.prototype.open = function (method, url, async, user, password) {
         if (types.isString(method) && types.isString(url)) {
             this._options = { url: url, method: method };
             this._options.headers = {};
@@ -154,8 +186,8 @@ export class XMLHttpRequest {
             }
             this._setReadyState(this.OPENED);
         }
-    }
-    abort() {
+    };
+    XMLHttpRequest.prototype.abort = function () {
         this._response = null;
         this._responseTextReader = null;
         this._headers = null;
@@ -168,8 +200,9 @@ export class XMLHttpRequest {
         if (this._readyState === this.DONE) {
             this._readyState = this.UNSENT;
         }
-    }
-    send(data) {
+    };
+    XMLHttpRequest.prototype.send = function (data) {
+        var _this = this;
         this._errorFlag = false;
         this._response = null;
         this._responseTextReader = null;
@@ -198,54 +231,56 @@ export class XMLHttpRequest {
         this.emitEvent('loadstart');
         http
             .request(this._options)
-            .then((r) => {
-            if (!this._errorFlag && this._sendFlag) {
-                this._loadResponse(r);
+            .then(function (r) {
+            if (!_this._errorFlag && _this._sendFlag) {
+                _this._loadResponse(r);
             }
         })
-            .catch((e) => {
-            this._errorFlag = true;
-            this._sendFlag = false;
-            this._setRequestError('error', e);
+            .catch(function (e) {
+            _this._errorFlag = true;
+            _this._sendFlag = false;
+            _this._setRequestError('error', e);
         });
-    }
-    setRequestHeader(header, value) {
+    };
+    XMLHttpRequest.prototype.setRequestHeader = function (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;
         }
-    }
-    getAllResponseHeaders() {
+    };
+    XMLHttpRequest.prototype.getAllResponseHeaders = function () {
         if (this._readyState < 2 || this._errorFlag) {
             return '';
         }
-        let result = '';
-        for (const i in this._headers) {
+        var result = '';
+        for (var i in this._headers) {
             result += i + ': ' + this._headers[i] + '\r\n';
         }
         return result.substr(0, result.length - 2);
-    }
-    getResponseHeader(header) {
+    };
+    XMLHttpRequest.prototype.getResponseHeader = function (header) {
         if (types.isString(header) && this._readyState > 1 && this._headers && !this._errorFlag) {
             header = header.toLowerCase();
-            for (const i in this._headers) {
+            for (var i in this._headers) {
                 if (i.toLowerCase() === header) {
                     return this._headers[i];
                 }
             }
         }
         return null;
-    }
-    overrideMimeType(mime) {
+    };
+    XMLHttpRequest.prototype.overrideMimeType = function (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;
-    }
-}
-const statuses = {
+    };
+    return XMLHttpRequest;
+}());
+export { XMLHttpRequest };
+var statuses = {
     100: 'Continue',
     101: 'Switching Protocols',
     200: 'OK',
@@ -287,37 +322,36 @@ const statuses = {
     504: 'Gateway Timeout',
     505: 'HTTP Version Not Supported',
 };
-export class FormData {
-    constructor() {
+var FormData = /** @class */ (function () {
+    function FormData() {
         this._data = new Map();
     }
-    append(name, value) {
+    FormData.prototype.append = function (name, value) {
         this._data.set(name, value);
-    }
-    toString() {
-        const arr = new Array();
+    };
+    FormData.prototype.toString = function () {
+        var arr = new Array();
         this._data.forEach(function (value, name, map) {
-            arr.push(`${encodeURIComponent(name)}=${encodeURIComponent(value)}`);
+            arr.push("".concat(encodeURIComponent(name), "=").concat(encodeURIComponent(value)));
         });
         return arr.join('&');
-    }
-}
-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) {
+    };
+    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];
             if (chunk instanceof Blob) {
                 dataChunks.push(chunk._buffer);
             }
             else if (typeof chunk === 'string') {
-                const textEncoder = new TextEncoder();
+                var textEncoder = new TextEncoder();
                 dataChunks.push(textEncoder.encode(chunk));
             }
             else if (chunk instanceof DataView) {
@@ -327,15 +361,15 @@ export class Blob {
                 dataChunks.push(new Uint8Array(ArrayBuffer.isView(chunk) ? chunk.buffer.slice(0) : chunk.slice(0)));
             }
             else {
-                const textEncoder = new TextEncoder();
+                var textEncoder = new TextEncoder();
                 dataChunks.push(textEncoder.encode(String(chunk)));
             }
         }
-        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];
+        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];
             buffer.set(chunk, offset);
             offset += chunk.byteLength;
         }
@@ -349,77 +383,118 @@ export class Blob {
             this._type = this._type.toLowerCase();
         }
     }
-    arrayBuffer() {
+    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 () {
         return Promise.resolve(this._buffer);
-    }
-    text() {
-        const textDecoder = new TextDecoder();
+    };
+    Blob.prototype.text = function () {
+        var textDecoder = new TextDecoder();
         return Promise.resolve(textDecoder.decode(this._buffer));
-    }
-    slice(start, end, type) {
-        const slice = this._buffer.slice(start || 0, end || this._buffer.length);
+    };
+    Blob.prototype.slice = function (start, end, type) {
+        var slice = this._buffer.slice(start || 0, end || this._buffer.length);
         return new Blob([slice], { type: type });
-    }
-    stream() {
+    };
+    Blob.prototype.stream = function () {
         throw new Error('stream is currently not supported');
-    }
-    toString() {
+    };
+    Blob.prototype.toString = function () {
         return '[object Blob]';
-    }
-}
-_a = Symbol.toStringTag;
-// 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() {
+    };
+    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]';
-    }
-}
-_b = Symbol.toStringTag;
-export class FileReader {
-    get readyState() {
-        return this._readyState;
-    }
-    get result() {
-        return this._result;
-    }
-    constructor() {
+    };
+    return File;
+}(Blob));
+export { File };
+_a = Symbol.toStringTag;
+var FileReader = /** @class */ (function () {
+    function FileReader() {
         this.EMPTY = 0;
         this.LOADING = 1;
         this.DONE = 2;
         this._listeners = new Map();
-        this[_c] = 'FileReader';
+        this[_b] = 'FileReader';
         //
     }
-    _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;
+    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;
             if (!haveByte3) {
                 outByte4 = 64;
                 if (!haveByte2) {
@@ -429,59 +504,66 @@ export class FileReader {
             output.push(byteToCharMap[outByte1], byteToCharMap[outByte2], byteToCharMap[outByte3], byteToCharMap[outByte4]);
         }
         return output.join('');
-    }
-    _read(blob, kind) {
+    };
+    FileReader.prototype._read = function (blob, kind) {
+        var _this = this;
         if (!(blob instanceof Blob)) {
-            throw new TypeError(`Failed to execute '${kind}' on 'FileReader': parameter 1 is not of type 'Blob'.`);
+            throw new TypeError("Failed to execute '".concat(kind, "' on 'FileReader': parameter 1 is not of type 'Blob'."));
         }
         this._result = '';
-        setTimeout(() => {
-            this._readyState = this.LOADING;
-            this.emitEvent('load');
-            this.emitEvent('loadend');
+        setTimeout(function () {
+            _this._readyState = _this.LOADING;
+            _this.emitEvent('load');
+            _this.emitEvent('loadend');
         });
-    }
-    emitEvent(eventName, ...args) {
+    };
+    FileReader.prototype.emitEvent = function (eventName) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
         if (types.isFunction(this['on' + eventName])) {
-            this['on' + eventName](...args);
+            this['on' + eventName].apply(this, args);
         }
-        const handlers = this._listeners.get(eventName) || [];
-        handlers.forEach((handler) => {
-            handler(...args);
+        var handlers = this._listeners.get(eventName) || [];
+        handlers.forEach(function (handler) {
+            handler.apply(void 0, args);
         });
-    }
-    addEventListener(eventName, handler) {
+    };
+    FileReader.prototype.addEventListener = function (eventName, handler) {
         if (['abort', 'error', 'load', 'loadend', 'loadstart', 'progress'].indexOf(eventName) === -1) {
             throw new Error('Event not supported: ' + eventName);
         }
-        const handlers = this._listeners.get(eventName) || [];
+        var handlers = this._listeners.get(eventName) || [];
         handlers.push(handler);
         this._listeners.set(eventName, handlers);
-    }
-    removeEventListener(eventName, toDetach) {
-        let handlers = this._listeners.get(eventName) || [];
-        handlers = handlers.filter((handler) => handler !== toDetach);
+    };
+    FileReader.prototype.removeEventListener = function (eventName, toDetach) {
+        var handlers = this._listeners.get(eventName) || [];
+        handlers = handlers.filter(function (handler) { return handler !== toDetach; });
         this._listeners.set(eventName, handlers);
-    }
-    readAsDataURL(blob) {
+    };
+    FileReader.prototype.readAsDataURL = function (blob) {
         this._read(blob, 'readAsDataURL');
-        this._result = `data:${blob.type};base64,${this._array2base64(Blob.InternalAccessor.getBuffer(blob))}`;
-    }
-    readAsText(blob) {
+        this._result = "data:".concat(blob.type, ";base64,").concat(this._array2base64(Blob.InternalAccessor.getBuffer(blob)));
+    };
+    FileReader.prototype.readAsText = function (blob) {
         this._read(blob, 'readAsText');
-        const textDecoder = new TextDecoder();
+        var textDecoder = new TextDecoder();
         this._result = textDecoder.decode(Blob.InternalAccessor.getBuffer(blob));
-    }
-    readAsArrayBuffer(blob) {
+    };
+    FileReader.prototype.readAsArrayBuffer = function (blob) {
         this._read(blob, 'readAsArrayBuffer');
         this._result = Blob.InternalAccessor.getBuffer(blob).buffer.slice(0);
-    }
-    abort() {
+    };
+    FileReader.prototype.abort = function () {
         //
-    }
-    toString() {
+    };
+    FileReader.prototype.toString = function () {
         return '[object FileReader]';
-    }
-}
-_c = Symbol.toStringTag;
+    };
+    return FileReader;
+}());
+export { FileReader };
+_b = Symbol.toStringTag;
 //# sourceMappingURL=index.js.map