javascript/NativeScript
1
0
Fork 0
mirror of https://github.com/NativeScript/NativeScript.git synced 2025-11-05 13:26:48 +08:00
Code Issues Packages Projects Releases Wiki Activity

refactor: circular deps part 3

Browse Source
This commit is contained in:
Nathan Walker
2025-07-07 22:29:13 -07:00
parent 47c72081dd
commit 1fdc933d8f
3 changed files with 687 additions and 538 deletions
Download Patch File Download Diff File Expand all files Collapse all files

817
packages/core/fetch/index.js
View File

@@ -1,539 +1,636 @@
(function () { var g = global;
"use strict";
var support = { var support = {
searchParams: "URLSearchParams" in global, searchParams: 'URLSearchParams' in g,
iterable: "Symbol" in global && "iterator" in Symbol, iterable: 'Symbol' in g && 'iterator' in Symbol,
blob: blob:
"FileReader" in global && 'FileReader' in g &&
"Blob" in global && 'Blob' in g &&
(function () { (function() {
try { try {
new Blob(); new Blob()
return true; return true
} catch (e) { } catch (e) {
return false; return false
} }
})(), })(),
formData: "FormData" in global, formData: 'FormData' in g,
arrayBuffer: "ArrayBuffer" in global arrayBuffer: 'ArrayBuffer' in g
}; }
function isDataView(obj) { function isDataView(obj) {
return obj && DataView.prototype.isPrototypeOf(obj); return obj && DataView.prototype.isPrototypeOf(obj)
} }
if (support.arrayBuffer) { if (support.arrayBuffer) {
var viewClasses = [ var viewClasses = [
"[object Int8Array]", '[object Int8Array]',
"[object Uint8Array]", '[object Uint8Array]',
"[object Uint8ClampedArray]", '[object Uint8ClampedArray]',
"[object Int16Array]", '[object Int16Array]',
"[object Uint16Array]", '[object Uint16Array]',
"[object Int32Array]", '[object Int32Array]',
"[object Uint32Array]", '[object Uint32Array]',
"[object Float32Array]", '[object Float32Array]',
"[object Float64Array]" '[object Float64Array]'
]; ]
var isArrayBufferView = var isArrayBufferView =
ArrayBuffer.isView || ArrayBuffer.isView ||
function (obj) { function(obj) {
return ( return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1
obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1
);
};
} }
}
function normalizeName(name) { function normalizeName(name) {
if (typeof name !== "string") { if (typeof name !== 'string') {
name = String(name); name = String(name)
} }
if (/[^a-z0-9\-#$%&'*+.^_`|~]/i.test(name)) { if (/[^a-z0-9\-#$%&'*+.^_`|~!]/i.test(name) || name === '') {
throw new TypeError("Invalid character in header field name"); throw new TypeError('Invalid character in header field name: "' + name + '"')
}
return name.toLowerCase();
} }
return name.toLowerCase()
}
function normalizeValue(value) { function normalizeValue(value) {
if (typeof value !== "string") { if (typeof value !== 'string') {
value = String(value); value = String(value)
}
return value;
} }
return value
}
// Build a destructive iterator for the value list // Build a destructive iterator for the value list
function iteratorFor(items) { function iteratorFor(items) {
var iterator = { var iterator = {
next: function () { next: function() {
var value = items.shift(); var value = items.shift()
return { done: value === undefined, value: value }; return {done: value === undefined, value: value}
}
} }
};
if (support.iterable) { if (support.iterable) {
iterator[Symbol.iterator] = function () { iterator[Symbol.iterator] = function() {
return iterator; return iterator
}; }
} }
return iterator; return iterator
} }
function Headers(headers) { export function Headers(headers) {
this.map = {}; this.map = {}
if (headers instanceof Headers) { if (headers instanceof Headers) {
headers.forEach(function (value, name) { headers.forEach(function(value, name) {
this.append(name, value); this.append(name, value)
}, this); }, this)
} else if (Array.isArray(headers)) { } else if (Array.isArray(headers)) {
headers.forEach(function (header) { headers.forEach(function(header) {
this.append(header[0], header[1]); if (header.length != 2) {
}, this); throw new TypeError('Headers constructor: expected name/value pair to be length 2, found' + header.length)
}
this.append(header[0], header[1])
}, this)
} else if (headers) { } else if (headers) {
Object.getOwnPropertyNames(headers).forEach(function (name) { Object.getOwnPropertyNames(headers).forEach(function(name) {
this.append(name, headers[name]); this.append(name, headers[name])
}, this); }, this)
}
} }
}
Headers.prototype.append = function (name, value) { Headers.prototype.append = function(name, value) {
name = normalizeName(name); name = normalizeName(name)
value = normalizeValue(value); value = normalizeValue(value)
var oldValue = this.map[name]; var oldValue = this.map[name]
this.map[name] = oldValue ? oldValue + ", " + value : value; this.map[name] = oldValue ? oldValue + ', ' + value : value
}; }
Headers.prototype["delete"] = function (name) { Headers.prototype['delete'] = function(name) {
delete this.map[normalizeName(name)]; delete this.map[normalizeName(name)]
}; }
Headers.prototype.get = function (name) { Headers.prototype.get = function(name) {
name = normalizeName(name); name = normalizeName(name)
return this.has(name) ? this.map[name] : null; return this.has(name) ? this.map[name] : null
}; }
Headers.prototype.has = function (name) { Headers.prototype.has = function(name) {
return this.map.hasOwnProperty(normalizeName(name)); return this.map.hasOwnProperty(normalizeName(name))
}; }
Headers.prototype.set = function (name, value) { Headers.prototype.set = function(name, value) {
this.map[normalizeName(name)] = normalizeValue(value); this.map[normalizeName(name)] = normalizeValue(value)
}; }
Headers.prototype.forEach = function (callback, thisArg) { Headers.prototype.forEach = function(callback, thisArg) {
for (var name in this.map) { for (var name in this.map) {
if (this.map.hasOwnProperty(name)) { if (this.map.hasOwnProperty(name)) {
callback.call(thisArg, this.map[name], name, this); callback.call(thisArg, this.map[name], name, this)
} }
} }
}; }
Headers.prototype.keys = function () { Headers.prototype.keys = function() {
var items = []; var items = []
this.forEach(function (value, name) { this.forEach(function(value, name) {
items.push(name); items.push(name)
}); })
return iteratorFor(items); return iteratorFor(items)
}; }
Headers.prototype.values = function () { Headers.prototype.values = function() {
var items = []; var items = []
this.forEach(function (value) { this.forEach(function(value) {
items.push(value); items.push(value)
}); })
return iteratorFor(items); return iteratorFor(items)
}; }
Headers.prototype.entries = function () { Headers.prototype.entries = function() {
var items = []; var items = []
this.forEach(function (value, name) { this.forEach(function(value, name) {
items.push([name, value]); items.push([name, value])
}); })
return iteratorFor(items); return iteratorFor(items)
}; }
if (support.iterable) { if (support.iterable) {
Headers.prototype[Symbol.iterator] = Headers.prototype.entries; Headers.prototype[Symbol.iterator] = Headers.prototype.entries
} }
function consumed(body) { function consumed(body) {
if (body._noBody) return
if (body.bodyUsed) { if (body.bodyUsed) {
return Promise.reject(new TypeError("Already read")); return Promise.reject(new TypeError('Already read'))
}
body.bodyUsed = true;
} }
body.bodyUsed = true
}
function fileReaderReady(reader) { function fileReaderReady(reader) {
return new Promise(function (resolve, reject) { return new Promise(function(resolve, reject) {
reader.onload = function () { reader.onload = function() {
resolve(reader.result); resolve(reader.result)
};
reader.onerror = function () {
reject(reader.error);
};
});
} }
reader.onerror = function() {
function readBlobAsArrayBuffer(blob) { reject(reader.error)
var reader = new FileReader();
var promise = fileReaderReady(reader);
reader.readAsArrayBuffer(blob);
return promise;
} }
})
}
function readBlobAsText(blob) { function readBlobAsArrayBuffer(blob) {
var reader = new FileReader(); var reader = new FileReader()
var promise = fileReaderReady(reader); var promise = fileReaderReady(reader)
reader.readAsText(blob); reader.readAsArrayBuffer(blob)
return promise; return promise
} }
function readArrayBufferAsText(buf) { function readBlobAsText(blob) {
var view = new Uint8Array(buf); var reader = new FileReader()
var chars = new Array(view.length); var promise = fileReaderReady(reader)
var match = /charset=([A-Za-z0-9_-]+)/.exec(blob.type)
var encoding = match ? match[1] : 'utf-8'
reader.readAsText(blob, encoding)
return promise
}
function readArrayBufferAsText(buf) {
var view = new Uint8Array(buf)
var chars = new Array(view.length)
for (var i = 0; i < view.length; i++) { for (var i = 0; i < view.length; i++) {
chars[i] = String.fromCharCode(view[i]); chars[i] = String.fromCharCode(view[i])
}
return chars.join("");
} }
return chars.join('')
}
function bufferClone(buf) { function bufferClone(buf) {
if (buf.slice) { if (buf.slice) {
return buf.slice(0); return buf.slice(0)
} else { } else {
var view = new Uint8Array(buf.byteLength); var view = new Uint8Array(buf.byteLength)
view.set(new Uint8Array(buf)); view.set(new Uint8Array(buf))
return view.buffer; return view.buffer
}
} }
}
function Body() { function Body() {
this.bodyUsed = false; this.bodyUsed = false
this._initBody = function (body) { this._initBody = function(body) {
this._bodyInit = body; /*
fetch-mock wraps the Response object in an ES6 Proxy to
provide useful test harness features such as flush. However, on
ES5 browsers without fetch or Proxy support pollyfills must be used;
the proxy-pollyfill is unable to proxy an attribute unless it exists
on the object before the Proxy is created. This change ensures
Response.bodyUsed exists on the instance, while maintaining the
semantic of setting Request.bodyUsed in the constructor before
_initBody is called.
*/
// eslint-disable-next-line no-self-assign
this.bodyUsed = this.bodyUsed
this._bodyInit = body
if (!body) { if (!body) {
this._bodyText = ""; this._noBody = true;
} else if (typeof body === "string") { this._bodyText = ''
this._bodyText = body; } else if (typeof body === 'string') {
this._bodyText = body
} else if (support.blob && Blob.prototype.isPrototypeOf(body)) { } else if (support.blob && Blob.prototype.isPrototypeOf(body)) {
this._bodyBlob = body; this._bodyBlob = body
} else if (support.formData && FormData.prototype.isPrototypeOf(body)) { } else if (support.formData && FormData.prototype.isPrototypeOf(body)) {
this._bodyFormData = body; this._bodyFormData = body
} else if ( } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
support.searchParams && this._bodyText = body.toString()
URLSearchParams.prototype.isPrototypeOf(body)
) {
this._bodyText = body.toString();
} else if (support.arrayBuffer && support.blob && isDataView(body)) { } else if (support.arrayBuffer && support.blob && isDataView(body)) {
this._bodyArrayBuffer = bufferClone(body.buffer); this._bodyArrayBuffer = bufferClone(body.buffer)
// IE 10-11 can't handle a DataView body. // IE 10-11 can't handle a DataView body.
this._bodyInit = new Blob([this._bodyArrayBuffer]); this._bodyInit = new Blob([this._bodyArrayBuffer])
} else if ( } else if (support.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body))) {
support.arrayBuffer && this._bodyArrayBuffer = bufferClone(body)
(ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body))
) {
this._bodyArrayBuffer = bufferClone(body);
} else { } else {
this._bodyText = body = Object.prototype.toString.call(body); this._bodyText = body = Object.prototype.toString.call(body)
} }
if (!this.headers.get("content-type")) { if (!this.headers.get('content-type')) {
if (typeof body === "string") { if (typeof body === 'string') {
this.headers.set("content-type", "text/plain;charset=UTF-8"); this.headers.set('content-type', 'text/plain;charset=UTF-8')
} else if (this._bodyBlob && this._bodyBlob.type) { } else if (this._bodyBlob && this._bodyBlob.type) {
this.headers.set("content-type", this._bodyBlob.type); this.headers.set('content-type', this._bodyBlob.type)
} else if ( } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
support.searchParams && this.headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8')
URLSearchParams.prototype.isPrototypeOf(body) }
) {
this.headers.set(
"content-type",
"application/x-www-form-urlencoded;charset=UTF-8"
);
} }
} }
};
if (support.blob) { if (support.blob) {
this.blob = function () { this.blob = function() {
var rejected = consumed(this); var rejected = consumed(this)
if (rejected) { if (rejected) {
return rejected; return rejected
} }
if (this._bodyBlob) { if (this._bodyBlob) {
return Promise.resolve(this._bodyBlob); return Promise.resolve(this._bodyBlob)
} else if (this._bodyArrayBuffer) { } else if (this._bodyArrayBuffer) {
return Promise.resolve(new Blob([this._bodyArrayBuffer])); return Promise.resolve(new Blob([this._bodyArrayBuffer]))
} else if (this._bodyFormData) { } else if (this._bodyFormData) {
throw new Error("could not read FormData body as blob"); throw new Error('could not read FormData body as blob')
} else { } else {
return Promise.resolve(new Blob([this._bodyText])); return Promise.resolve(new Blob([this._bodyText]))
}
}
} }
};
this.arrayBuffer = function () { this.arrayBuffer = function() {
if (this._bodyArrayBuffer) { if (this._bodyArrayBuffer) {
return consumed(this) || Promise.resolve(this._bodyArrayBuffer); var isConsumed = consumed(this)
if (isConsumed) {
return isConsumed
} else if (ArrayBuffer.isView(this._bodyArrayBuffer)) {
return Promise.resolve(
this._bodyArrayBuffer.buffer.slice(
this._bodyArrayBuffer.byteOffset,
this._bodyArrayBuffer.byteOffset + this._bodyArrayBuffer.byteLength
)
)
} else { } else {
return this.blob().then(readBlobAsArrayBuffer); return Promise.resolve(this._bodyArrayBuffer)
}
} else if (support.blob) {
return this.blob().then(readBlobAsArrayBuffer)
} else {
throw new Error('could not read as ArrayBuffer')
} }
};
} }
this.text = function () { this.text = function() {
var rejected = consumed(this); var rejected = consumed(this)
if (rejected) { if (rejected) {
return rejected; return rejected
} }
if (this._bodyBlob) { if (this._bodyBlob) {
return readBlobAsText(this._bodyBlob); return readBlobAsText(this._bodyBlob)
} else if (this._bodyArrayBuffer) { } else if (this._bodyArrayBuffer) {
return Promise.resolve(readArrayBufferAsText(this._bodyArrayBuffer)); return Promise.resolve(readArrayBufferAsText(this._bodyArrayBuffer))
} else if (this._bodyFormData) { } else if (this._bodyFormData) {
throw new Error("could not read FormData body as text"); throw new Error('could not read FormData body as text')
} else { } else {
return Promise.resolve(this._bodyText); return Promise.resolve(this._bodyText)
}
} }
};
if (support.formData) { if (support.formData) {
this.formData = function () { this.formData = function() {
return this.text().then(decode); return this.text().then(decode)
}; }
} }
this.json = function () { this.json = function() {
return this.text().then(JSON.parse); return this.text().then(JSON.parse)
};
return this;
} }
// HTTP methods whose capitalization should be normalized return this
var methods = ["DELETE", "GET", "HEAD", "OPTIONS", "POST", "PUT"]; }
function normalizeMethod(method) { // HTTP methods whose capitalization should be normalized
var upcased = method.toUpperCase(); var methods = ['CONNECT', 'DELETE', 'GET', 'HEAD', 'OPTIONS', 'PATCH', 'POST', 'PUT', 'TRACE']
return methods.indexOf(upcased) > -1 ? upcased : method;
function normalizeMethod(method) {
var upcased = method.toUpperCase()
return methods.indexOf(upcased) > -1 ? upcased : method
}
export function Request(input, options) {
if (!(this instanceof Request)) {
throw new TypeError('Please use the "new" operator, this DOM object constructor cannot be called as a function.')
} }
function Request(input, options) { options = options || {}
options = options || {}; var body = options.body
var body = options.body;
if (input instanceof Request) { if (input instanceof Request) {
if (input.bodyUsed) { if (input.bodyUsed) {
throw new TypeError("Already read"); throw new TypeError('Already read')
} }
this.url = input.url; this.url = input.url
this.credentials = input.credentials; this.credentials = input.credentials
if (!options.headers) { if (!options.headers) {
this.headers = new Headers(input.headers); this.headers = new Headers(input.headers)
} }
this.method = input.method; this.method = input.method
this.mode = input.mode; this.mode = input.mode
this.signal = input.signal; this.signal = input.signal
if (!body && input._bodyInit != null) { if (!body && input._bodyInit != null) {
body = input._bodyInit; body = input._bodyInit
input.bodyUsed = true; input.bodyUsed = true
} }
} else { } else {
this.url = String(input); this.url = String(input)
} }
this.credentials = options.credentials || this.credentials || "same-origin"; this.credentials = options.credentials || this.credentials || 'same-origin'
if (options.headers || !this.headers) { if (options.headers || !this.headers) {
this.headers = new Headers(options.headers); this.headers = new Headers(options.headers)
} }
this.method = normalizeMethod(options.method || this.method || "GET"); this.method = normalizeMethod(options.method || this.method || 'GET')
this.mode = options.mode || this.mode || null; this.mode = options.mode || this.mode || null
this.signal = options.signal || this.signal; this.signal = options.signal || this.signal || (function () {
this.referrer = null; if ('AbortController' in g) {
var ctrl = new AbortController();
if ((this.method === "GET" || this.method === "HEAD") && body) { return ctrl.signal;
throw new TypeError("Body not allowed for GET or HEAD requests");
} }
this._initBody(body); }());
this.referrer = null
if ((this.method === 'GET' || this.method === 'HEAD') && body) {
throw new TypeError('Body not allowed for GET or HEAD requests')
} }
this._initBody(body)
Request.prototype.clone = function () { if (this.method === 'GET' || this.method === 'HEAD') {
return new Request(this, { body: this._bodyInit }); if (options.cache === 'no-store' || options.cache === 'no-cache') {
}; // Search for a '_' parameter in the query string
var reParamSearch = /([?&])_=[^&]*/
if (reParamSearch.test(this.url)) {
// If it already exists then set the value with the current time
this.url = this.url.replace(reParamSearch, '$1_=' + new Date().getTime())
} else {
// Otherwise add a new '_' parameter to the end with the current time
var reQueryString = /\?/
this.url += (reQueryString.test(this.url) ? '&' : '?') + '_=' + new Date().getTime()
}
}
}
}
function decode(body) { Request.prototype.clone = function() {
var form = new FormData(); return new Request(this, {body: this._bodyInit})
}
function decode(body) {
var form = new FormData()
body body
.trim() .trim()
.split("&") .split('&')
.forEach(function (bytes) { .forEach(function(bytes) {
if (bytes) { if (bytes) {
var split = bytes.split("="); var split = bytes.split('=')
var name = split.shift().replace(/\+/g, " "); var name = split.shift().replace(/\+/g, ' ')
var value = split.join("=").replace(/\+/g, " "); var value = split.join('=').replace(/\+/g, ' ')
form.append(decodeURIComponent(name), decodeURIComponent(value)); form.append(decodeURIComponent(name), decodeURIComponent(value))
}
});
return form;
} }
})
return form
}
function parseHeaders(rawHeaders) { function parseHeaders(rawHeaders) {
var headers = new Headers(); var headers = new Headers()
// Replace instances of \r\n and \n followed by at least one space or horizontal tab with a space // Replace instances of \r\n and \n followed by at least one space or horizontal tab with a space
// https://tools.ietf.org/html/rfc7230#section-3.2 // https://tools.ietf.org/html/rfc7230#section-3.2
var preProcessedHeaders = rawHeaders.replace(/\r?\n[\t ]+/g, " "); var preProcessedHeaders = rawHeaders.replace(/\r?\n[\t ]+/g, ' ')
preProcessedHeaders.split(/\r?\n/).forEach(function (line) { // Avoiding split via regex to work around a common IE11 bug with the core-js 3.6.0 regex polyfill
var parts = line.split(":"); // https://github.com/github/fetch/issues/748
var key = parts.shift().trim(); // https://github.com/zloirock/core-js/issues/751
preProcessedHeaders
.split('\r')
.map(function(header) {
return header.indexOf('\n') === 0 ? header.substr(1, header.length) : header
})
.forEach(function(line) {
var parts = line.split(':')
var key = parts.shift().trim()
if (key) { if (key) {
var value = parts.join(":").trim(); var value = parts.join(':').trim()
headers.append(key, value); try {
headers.append(key, value)
} catch (error) {
console.warn('Response ' + error.message)
} }
});
return headers;
} }
})
return headers
}
Body.call(Request.prototype); Body.call(Request.prototype)
function Response(bodyInit, options) { export function Response(bodyInit, options) {
if (!(this instanceof Response)) {
throw new TypeError('Please use the "new" operator, this DOM object constructor cannot be called as a function.')
}
if (!options) { if (!options) {
options = {}; options = {}
} }
this.type = "default"; this.type = 'default'
this.status = options.status === undefined ? 200 : options.status; this.status = options.status === undefined ? 200 : options.status
this.ok = this.status >= 200 && this.status < 300; if (this.status < 200 || this.status > 599) {
this.statusText = "statusText" in options ? options.statusText : "OK"; throw new RangeError("Failed to construct 'Response': The status provided (0) is outside the range [200, 599].")
this.headers = new Headers(options.headers);
this.url = options.url || "";
this._initBody(bodyInit);
} }
this.ok = this.status >= 200 && this.status < 300
this.statusText = options.statusText === undefined ? '' : '' + options.statusText
this.headers = new Headers(options.headers)
this.url = options.url || ''
this._initBody(bodyInit)
}
Body.call(Response.prototype); Body.call(Response.prototype)
Response.prototype.clone = function () { Response.prototype.clone = function() {
return new Response(this._bodyInit, { return new Response(this._bodyInit, {
status: this.status, status: this.status,
statusText: this.statusText, statusText: this.statusText,
headers: new Headers(this.headers), headers: new Headers(this.headers),
url: this.url url: this.url
}); })
}; }
Response.error = function () { Response.error = function() {
var response = new Response(null, { status: 0, statusText: "" }); var response = new Response(null, {status: 200, statusText: ''})
response.type = "error"; response.ok = false
return response; response.status = 0
}; response.type = 'error'
return response
}
var redirectStatuses = [301, 302, 303, 307, 308]; var redirectStatuses = [301, 302, 303, 307, 308]
Response.redirect = function (url, status) { Response.redirect = function(url, status) {
if (redirectStatuses.indexOf(status) === -1) { if (redirectStatuses.indexOf(status) === -1) {
throw new RangeError("Invalid status code"); throw new RangeError('Invalid status code')
} }
return new Response(null, { status: status, headers: { location: url } }); return new Response(null, {status: status, headers: {location: url}})
}; }
exports.DOMException = global.DOMException; export var DOMException = g.DOMException
try { try {
new exports.DOMException(); new DOMException()
} catch (err) { } catch (err) {
exports.DOMException = function (message, name) { DOMException = function(message, name) {
this.message = message; this.message = message
this.name = name; this.name = name
var error = Error(message); var error = Error(message)
this.stack = error.stack; this.stack = error.stack
};
exports.DOMException.prototype = Object.create(Error.prototype);
exports.DOMException.prototype.constructor = exports.DOMException;
} }
DOMException.prototype = Object.create(Error.prototype)
DOMException.prototype.constructor = DOMException
}
function fetch(input, init) { export function fetch(input, init) {
return new Promise(function (resolve, reject) { return new Promise(function(resolve, reject) {
var request = new Request(input, init); var request = new Request(input, init)
if (request.signal && request.signal.aborted) { if (request.signal && request.signal.aborted) {
return reject(new exports.DOMException("Aborted", "AbortError")); return reject(new DOMException('Aborted', 'AbortError'))
} }
var xhr = new XMLHttpRequest(); var xhr = new XMLHttpRequest()
function abortXhr() { function abortXhr() {
xhr.abort(); xhr.abort()
} }
xhr.onload = function () { xhr.onload = function() {
var options = { var options = {
status: xhr.status,
statusText: xhr.statusText, statusText: xhr.statusText,
headers: parseHeaders(xhr.getAllResponseHeaders() || "") headers: parseHeaders(xhr.getAllResponseHeaders() || '')
}; }
options.url = // This check if specifically for when a user fetches a file locally from the file system
"responseURL" in xhr // Only if the status is out of a normal range
? xhr.responseURL if (request.url.indexOf('file://') === 0 && (xhr.status < 200 || xhr.status > 599)) {
: options.headers.get("X-Request-URL"); options.status = 200;
var body = "response" in xhr ? xhr.response : xhr.responseText; } else {
resolve(new Response(body, options)); options.status = xhr.status;
}; }
options.url = 'responseURL' in xhr ? xhr.responseURL : options.headers.get('X-Request-URL')
xhr.onerror = function () { var body = 'response' in xhr ? xhr.response : xhr.responseText
reject(new TypeError("Network request failed")); setTimeout(function() {
}; resolve(new Response(body, options))
}, 0)
xhr.ontimeout = function () {
reject(new TypeError("Network request failed"));
};
xhr.onabort = function () {
reject(new exports.DOMException("Aborted", "AbortError"));
};
xhr.open(request.method, request.url, true);
if (request.credentials === "include") {
xhr.withCredentials = true;
} else if (request.credentials === "omit") {
xhr.withCredentials = false;
} }
if ("responseType" in xhr && support.blob) { xhr.onerror = function() {
xhr.responseType = "blob"; setTimeout(function() {
reject(new TypeError('Network request failed'))
}, 0)
} }
request.headers.forEach(function (value, name) { xhr.ontimeout = function() {
xhr.setRequestHeader(name, value); setTimeout(function() {
}); reject(new TypeError('Network request timed out'))
}, 0)
}
xhr.onabort = function() {
setTimeout(function() {
reject(new DOMException('Aborted', 'AbortError'))
}, 0)
}
function fixUrl(url) {
try {
return url === '' && g.location.href ? g.location.href : url
} catch (e) {
return url
}
}
xhr.open(request.method, fixUrl(request.url), true)
if (request.credentials === 'include') {
xhr.withCredentials = true
} else if (request.credentials === 'omit') {
xhr.withCredentials = false
}
if ('responseType' in xhr) {
if (support.blob) {
xhr.responseType = 'blob'
} else if (
support.arrayBuffer
) {
xhr.responseType = 'arraybuffer'
}
}
if (init && typeof init.headers === 'object' && !(init.headers instanceof Headers || (g.Headers && init.headers instanceof g.Headers))) {
var names = [];
Object.getOwnPropertyNames(init.headers).forEach(function(name) {
names.push(normalizeName(name))
xhr.setRequestHeader(name, normalizeValue(init.headers[name]))
})
request.headers.forEach(function(value, name) {
if (names.indexOf(name) === -1) {
xhr.setRequestHeader(name, value)
}
})
} else {
request.headers.forEach(function(value, name) {
xhr.setRequestHeader(name, value)
})
}
if (request.signal) { if (request.signal) {
request.signal.addEventListener("abort", abortXhr); request.signal.addEventListener('abort', abortXhr)
xhr.onreadystatechange = function () { xhr.onreadystatechange = function() {
// DONE (success or failure) // DONE (success or failure)
if (xhr.readyState === 4) { if (xhr.readyState === 4) {
request.signal.removeEventListener("abort", abortXhr); request.signal.removeEventListener('abort', abortXhr)
}
} }
};
} }
xhr.send( xhr.send(typeof request._bodyInit === 'undefined' ? null : request._bodyInit)
typeof request._bodyInit === "undefined" ? null : request._bodyInit })
); }
});
}
fetch.polyfill = true; fetch.polyfill = true
exports.Headers = Headers; if (!g.fetch) {
exports.Request = Request; g.fetch = fetch
exports.Response = Response; g.Headers = Headers
exports.fetch = fetch; g.Request = Request
g.Response = Response
Object.defineProperty(exports, "__esModule", { value: true }); }
})();

56
packages/core/globals/index.ts
View File

@@ -1,7 +1,37 @@
import type * as tslibType from 'tslib'; import tslib from 'tslib';
const tslib: typeof tslibType = require('tslib');
import { Observable } from '../data/observable'; import { Observable } from '../data/observable';
import { trace as profilingTrace, time, uptime, level as profilingLevel } from '../profiling'; import { trace as profilingTrace, time, uptime, level as profilingLevel } from '../profiling';
import * as timer from '../timer';
import * as animationFrame from '../animation-frame';
import * as mediaQueryList from '../media-query-list';
import * as uiDialogs from '../ui/dialogs';
import * as text from '../text';
import * as xhrImpl from '../xhr';
import '../fetch';
import * as wgc from '../wgc';
import * as cryptoImpl from '../wgc/crypto';
import * as subtleCryptoImpl from '../wgc/crypto/SubtleCrypto';
if (typeof global.__metadata === 'undefined') {
/**
* TS decorator metadata helper.
* @param metadataKey the metadata key (e.g. "design:type")
* @param metadataValue the metadata value (e.g. the constructor function)
* @returns a decorator function, or undefined if Reflect.metadata isn’t available
*/
global.__metadata = (metadataKey, metadataValue) => {
if (
typeof Reflect === 'object' &&
// @ts-expect-error
typeof Reflect.metadata === 'function'
) {
// Delegate to the reflect-metadata shim
// @ts-expect-error
return Reflect.metadata(metadataKey, metadataValue);
}
// no-op if no Reflect.metadata
};
}
type ModuleLoader = (name?: string) => any; type ModuleLoader = (name?: string) => any;
@@ -301,34 +331,34 @@ export function initGlobal() {
}; };
// DOM api polyfills // DOM api polyfills
global.registerModule('timer', () => require('../timer')); global.registerModule('timer', () => timer);
installPolyfills('timer', ['setTimeout', 'clearTimeout', 'setInterval', 'clearInterval']); installPolyfills('timer', ['setTimeout', 'clearTimeout', 'setInterval', 'clearInterval']);
global.registerModule('animation', () => require('../animation-frame')); global.registerModule('animation', () => animationFrame);
installPolyfills('animation', ['requestAnimationFrame', 'cancelAnimationFrame']); installPolyfills('animation', ['requestAnimationFrame', 'cancelAnimationFrame']);
global.registerModule('media-query-list', () => require('../media-query-list')); global.registerModule('media-query-list', () => mediaQueryList);
installPolyfills('media-query-list', ['matchMedia', 'MediaQueryList']); installPolyfills('media-query-list', ['matchMedia', 'MediaQueryList']);
global.registerModule('ui-dialogs', () => require('../ui/dialogs')); global.registerModule('ui-dialogs', () => uiDialogs);
installPolyfills('ui-dialogs', ['alert', 'confirm', 'prompt', 'login', 'action']); installPolyfills('ui-dialogs', ['alert', 'confirm', 'prompt', 'login', 'action']);
global.registerModule('text', () => require('../text')); global.registerModule('text', () => text);
installPolyfills('text', ['TextDecoder', 'TextEncoder']); installPolyfills('text', ['TextDecoder', 'TextEncoder']);
global.registerModule('xhr', () => require('../xhr')); global.registerModule('xhr', () => xhrImpl);
installPolyfills('xhr', ['XMLHttpRequest', 'FormData', 'Blob', 'File', 'FileReader']); installPolyfills('xhr', ['XMLHttpRequest', 'FormData', 'Blob', 'File', 'FileReader']);
global.registerModule('fetch', () => require('../fetch')); // global.registerModule('fetch', () => require('../fetch'));
installPolyfills('fetch', ['fetch', 'Headers', 'Request', 'Response']); // installPolyfills('fetch', ['fetch', 'Headers', 'Request', 'Response']);
global.registerModule('wgc', () => require('../wgc')); global.registerModule('wgc', () => wgc);
installPolyfills('wgc', ['atob', 'btoa']); installPolyfills('wgc', ['atob', 'btoa']);
global.registerModule('crypto', () => require('../wgc/crypto')); global.registerModule('crypto', () => cryptoImpl);
installPolyfills('crypto', ['Crypto']); installPolyfills('crypto', ['Crypto']);
global.registerModule('subtle', () => require('../wgc/crypto/SubtleCrypto')); global.registerModule('subtle', () => subtleCryptoImpl);
installPolyfills('subtle-crypto', ['Subtle']); installPolyfills('subtle-crypto', ['Subtle']);
global.crypto = new global.Crypto(); global.crypto = new global.Crypto();

22
packages/core/ui/builder/xml2ui.ts
View File

@@ -8,6 +8,28 @@ import { Device } from '../../platform';
import { profile } from '../../profiling'; import { profile } from '../../profiling';
import { android, ios, visionos, apple, loadCustomComponent, defaultNameSpaceMatcher, getExports, Builder } from './index'; import { android, ios, visionos, apple, loadCustomComponent, defaultNameSpaceMatcher, getExports, Builder } from './index';
// Note: after all circulars are resolve, try importing this from single place or see if globals/index.ts properly handles it
if (typeof global.__metadata === 'undefined') {
/**
* TS decorator metadata helper.
* @param metadataKey the metadata key (e.g. "design:type")
* @param metadataValue the metadata value (e.g. the constructor function)
* @returns a decorator function, or undefined if Reflect.metadata isn’t available
*/
global.__metadata = (metadataKey, metadataValue) => {
if (
typeof Reflect === 'object' &&
// @ts-expect-error
typeof Reflect.metadata === 'function'
) {
// Delegate to the reflect-metadata shim
// @ts-expect-error
return Reflect.metadata(metadataKey, metadataValue);
}
// no-op if no Reflect.metadata
};
}
export namespace xml2ui { export namespace xml2ui {
/** /**
* Pipes and filters: * Pipes and filters: