@wutiange/log-listener-plugin 2.0.2-alpha.5 → 2.0.2

package/dist/index.cjs.js

@@ -1,7 +1,1462 @@
 'use strict';
 
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const logPlugin_1 = tslib_1.__importDefault(require("./src/logPlugin"));
-exports.default = logPlugin_1.default;
+var XHRInterceptor = require('react-native/Libraries/Network/XHRInterceptor');
+var BlobFileReader = require('react-native/Libraries/Blob/FileReader');
+
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+var requiresPort;
+var hasRequiredRequiresPort;
+
+function requireRequiresPort () {
+	if (hasRequiredRequiresPort) return requiresPort;
+	hasRequiredRequiresPort = 1;
+
+	/**
+	 * Check if we're required to add a port number.
+	 *
+	 * @see https://url.spec.whatwg.org/#default-port
+	 * @param {Number|String} port Port number we need to check
+	 * @param {String} protocol Protocol we need to check against.
+	 * @returns {Boolean} Is it a default port for the given protocol
+	 * @api private
+	 */
+	requiresPort = function required(port, protocol) {
+	  protocol = protocol.split(':')[0];
+	  port = +port;
+
+	  if (!port) return false;
+
+	  switch (protocol) {
+	    case 'http':
+	    case 'ws':
+	    return port !== 80;
+
+	    case 'https':
+	    case 'wss':
+	    return port !== 443;
+
+	    case 'ftp':
+	    return port !== 21;
+
+	    case 'gopher':
+	    return port !== 70;
+
+	    case 'file':
+	    return false;
+	  }
+
+	  return port !== 0;
+	};
+	return requiresPort;
+}
+
+var querystringify = {};
+
+var hasRequiredQuerystringify;
+
+function requireQuerystringify () {
+	if (hasRequiredQuerystringify) return querystringify;
+	hasRequiredQuerystringify = 1;
+
+	var has = Object.prototype.hasOwnProperty
+	  , undef;
+
+	/**
+	 * Decode a URI encoded string.
+	 *
+	 * @param {String} input The URI encoded string.
+	 * @returns {String|Null} The decoded string.
+	 * @api private
+	 */
+	function decode(input) {
+	  try {
+	    return decodeURIComponent(input.replace(/\+/g, ' '));
+	  } catch (e) {
+	    return null;
+	  }
+	}
+
+	/**
+	 * Attempts to encode a given input.
+	 *
+	 * @param {String} input The string that needs to be encoded.
+	 * @returns {String|Null} The encoded string.
+	 * @api private
+	 */
+	function encode(input) {
+	  try {
+	    return encodeURIComponent(input);
+	  } catch (e) {
+	    return null;
+	  }
+	}
+
+	/**
+	 * Simple query string parser.
+	 *
+	 * @param {String} query The query string that needs to be parsed.
+	 * @returns {Object}
+	 * @api public
+	 */
+	function querystring(query) {
+	  var parser = /([^=?#&]+)=?([^&]*)/g
+	    , result = {}
+	    , part;
+
+	  while (part = parser.exec(query)) {
+	    var key = decode(part[1])
+	      , value = decode(part[2]);
+
+	    //
+	    // Prevent overriding of existing properties. This ensures that build-in
+	    // methods like `toString` or __proto__ are not overriden by malicious
+	    // querystrings.
+	    //
+	    // In the case if failed decoding, we want to omit the key/value pairs
+	    // from the result.
+	    //
+	    if (key === null || value === null || key in result) continue;
+	    result[key] = value;
+	  }
+
+	  return result;
+	}
+
+	/**
+	 * Transform a query string to an object.
+	 *
+	 * @param {Object} obj Object that should be transformed.
+	 * @param {String} prefix Optional prefix.
+	 * @returns {String}
+	 * @api public
+	 */
+	function querystringify$1(obj, prefix) {
+	  prefix = prefix || '';
+
+	  var pairs = []
+	    , value
+	    , key;
+
+	  //
+	  // Optionally prefix with a '?' if needed
+	  //
+	  if ('string' !== typeof prefix) prefix = '?';
+
+	  for (key in obj) {
+	    if (has.call(obj, key)) {
+	      value = obj[key];
+
+	      //
+	      // Edge cases where we actually want to encode the value to an empty
+	      // string instead of the stringified value.
+	      //
+	      if (!value && (value === null || value === undef || isNaN(value))) {
+	        value = '';
+	      }
+
+	      key = encode(key);
+	      value = encode(value);
+
+	      //
+	      // If we failed to encode the strings, we should bail out as we don't
+	      // want to add invalid strings to the query.
+	      //
+	      if (key === null || value === null) continue;
+	      pairs.push(key +'='+ value);
+	    }
+	  }
+
+	  return pairs.length ? prefix + pairs.join('&') : '';
+	}
+
+	//
+	// Expose the module.
+	//
+	querystringify.stringify = querystringify$1;
+	querystringify.parse = querystring;
+	return querystringify;
+}
+
+var urlParse;
+var hasRequiredUrlParse;
+
+function requireUrlParse () {
+	if (hasRequiredUrlParse) return urlParse;
+	hasRequiredUrlParse = 1;
+
+	var required = requireRequiresPort()
+	  , qs = requireQuerystringify()
+	  , controlOrWhitespace = /^[\x00-\x20\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]+/
+	  , CRHTLF = /[\n\r\t]/g
+	  , slashes = /^[A-Za-z][A-Za-z0-9+-.]*:\/\//
+	  , port = /:\d+$/
+	  , protocolre = /^([a-z][a-z0-9.+-]*:)?(\/\/)?([\\/]+)?([\S\s]*)/i
+	  , windowsDriveLetter = /^[a-zA-Z]:/;
+
+	/**
+	 * Remove control characters and whitespace from the beginning of a string.
+	 *
+	 * @param {Object|String} str String to trim.
+	 * @returns {String} A new string representing `str` stripped of control
+	 *     characters and whitespace from its beginning.
+	 * @public
+	 */
+	function trimLeft(str) {
+	  return (str ? str : '').toString().replace(controlOrWhitespace, '');
+	}
+
+	/**
+	 * These are the parse rules for the URL parser, it informs the parser
+	 * about:
+	 *
+	 * 0. The char it Needs to parse, if it's a string it should be done using
+	 *    indexOf, RegExp using exec and NaN means set as current value.
+	 * 1. The property we should set when parsing this value.
+	 * 2. Indication if it's backwards or forward parsing, when set as number it's
+	 *    the value of extra chars that should be split off.
+	 * 3. Inherit from location if non existing in the parser.
+	 * 4. `toLowerCase` the resulting value.
+	 */
+	var rules = [
+	  ['#', 'hash'],                        // Extract from the back.
+	  ['?', 'query'],                       // Extract from the back.
+	  function sanitize(address, url) {     // Sanitize what is left of the address
+	    return isSpecial(url.protocol) ? address.replace(/\\/g, '/') : address;
+	  },
+	  ['/', 'pathname'],                    // Extract from the back.
+	  ['@', 'auth', 1],                     // Extract from the front.
+	  [NaN, 'host', undefined, 1, 1],       // Set left over value.
+	  [/:(\d*)$/, 'port', undefined, 1],    // RegExp the back.
+	  [NaN, 'hostname', undefined, 1, 1]    // Set left over.
+	];
+
+	/**
+	 * These properties should not be copied or inherited from. This is only needed
+	 * for all non blob URL's as a blob URL does not include a hash, only the
+	 * origin.
+	 *
+	 * @type {Object}
+	 * @private
+	 */
+	var ignore = { hash: 1, query: 1 };
+
+	/**
+	 * The location object differs when your code is loaded through a normal page,
+	 * Worker or through a worker using a blob. And with the blobble begins the
+	 * trouble as the location object will contain the URL of the blob, not the
+	 * location of the page where our code is loaded in. The actual origin is
+	 * encoded in the `pathname` so we can thankfully generate a good "default"
+	 * location from it so we can generate proper relative URL's again.
+	 *
+	 * @param {Object|String} loc Optional default location object.
+	 * @returns {Object} lolcation object.
+	 * @public
+	 */
+	function lolcation(loc) {
+	  var globalVar;
+
+	  if (typeof window !== 'undefined') globalVar = window;
+	  else if (typeof commonjsGlobal !== 'undefined') globalVar = commonjsGlobal;
+	  else if (typeof self !== 'undefined') globalVar = self;
+	  else globalVar = {};
+
+	  var location = globalVar.location || {};
+	  loc = loc || location;
+
+	  var finaldestination = {}
+	    , type = typeof loc
+	    , key;
+
+	  if ('blob:' === loc.protocol) {
+	    finaldestination = new Url(unescape(loc.pathname), {});
+	  } else if ('string' === type) {
+	    finaldestination = new Url(loc, {});
+	    for (key in ignore) delete finaldestination[key];
+	  } else if ('object' === type) {
+	    for (key in loc) {
+	      if (key in ignore) continue;
+	      finaldestination[key] = loc[key];
+	    }
+
+	    if (finaldestination.slashes === undefined) {
+	      finaldestination.slashes = slashes.test(loc.href);
+	    }
+	  }
+
+	  return finaldestination;
+	}
+
+	/**
+	 * Check whether a protocol scheme is special.
+	 *
+	 * @param {String} The protocol scheme of the URL
+	 * @return {Boolean} `true` if the protocol scheme is special, else `false`
+	 * @private
+	 */
+	function isSpecial(scheme) {
+	  return (
+	    scheme === 'file:' ||
+	    scheme === 'ftp:' ||
+	    scheme === 'http:' ||
+	    scheme === 'https:' ||
+	    scheme === 'ws:' ||
+	    scheme === 'wss:'
+	  );
+	}
+
+	/**
+	 * @typedef ProtocolExtract
+	 * @type Object
+	 * @property {String} protocol Protocol matched in the URL, in lowercase.
+	 * @property {Boolean} slashes `true` if protocol is followed by "//", else `false`.
+	 * @property {String} rest Rest of the URL that is not part of the protocol.
+	 */
+
+	/**
+	 * Extract protocol information from a URL with/without double slash ("//").
+	 *
+	 * @param {String} address URL we want to extract from.
+	 * @param {Object} location
+	 * @return {ProtocolExtract} Extracted information.
+	 * @private
+	 */
+	function extractProtocol(address, location) {
+	  address = trimLeft(address);
+	  address = address.replace(CRHTLF, '');
+	  location = location || {};
+
+	  var match = protocolre.exec(address);
+	  var protocol = match[1] ? match[1].toLowerCase() : '';
+	  var forwardSlashes = !!match[2];
+	  var otherSlashes = !!match[3];
+	  var slashesCount = 0;
+	  var rest;
+
+	  if (forwardSlashes) {
+	    if (otherSlashes) {
+	      rest = match[2] + match[3] + match[4];
+	      slashesCount = match[2].length + match[3].length;
+	    } else {
+	      rest = match[2] + match[4];
+	      slashesCount = match[2].length;
+	    }
+	  } else {
+	    if (otherSlashes) {
+	      rest = match[3] + match[4];
+	      slashesCount = match[3].length;
+	    } else {
+	      rest = match[4];
+	    }
+	  }
+
+	  if (protocol === 'file:') {
+	    if (slashesCount >= 2) {
+	      rest = rest.slice(2);
+	    }
+	  } else if (isSpecial(protocol)) {
+	    rest = match[4];
+	  } else if (protocol) {
+	    if (forwardSlashes) {
+	      rest = rest.slice(2);
+	    }
+	  } else if (slashesCount >= 2 && isSpecial(location.protocol)) {
+	    rest = match[4];
+	  }
+
+	  return {
+	    protocol: protocol,
+	    slashes: forwardSlashes || isSpecial(protocol),
+	    slashesCount: slashesCount,
+	    rest: rest
+	  };
+	}
+
+	/**
+	 * Resolve a relative URL pathname against a base URL pathname.
+	 *
+	 * @param {String} relative Pathname of the relative URL.
+	 * @param {String} base Pathname of the base URL.
+	 * @return {String} Resolved pathname.
+	 * @private
+	 */
+	function resolve(relative, base) {
+	  if (relative === '') return base;
+
+	  var path = (base || '/').split('/').slice(0, -1).concat(relative.split('/'))
+	    , i = path.length
+	    , last = path[i - 1]
+	    , unshift = false
+	    , up = 0;
+
+	  while (i--) {
+	    if (path[i] === '.') {
+	      path.splice(i, 1);
+	    } else if (path[i] === '..') {
+	      path.splice(i, 1);
+	      up++;
+	    } else if (up) {
+	      if (i === 0) unshift = true;
+	      path.splice(i, 1);
+	      up--;
+	    }
+	  }
+
+	  if (unshift) path.unshift('');
+	  if (last === '.' || last === '..') path.push('');
+
+	  return path.join('/');
+	}
+
+	/**
+	 * The actual URL instance. Instead of returning an object we've opted-in to
+	 * create an actual constructor as it's much more memory efficient and
+	 * faster and it pleases my OCD.
+	 *
+	 * It is worth noting that we should not use `URL` as class name to prevent
+	 * clashes with the global URL instance that got introduced in browsers.
+	 *
+	 * @constructor
+	 * @param {String} address URL we want to parse.
+	 * @param {Object|String} [location] Location defaults for relative paths.
+	 * @param {Boolean|Function} [parser] Parser for the query string.
+	 * @private
+	 */
+	function Url(address, location, parser) {
+	  address = trimLeft(address);
+	  address = address.replace(CRHTLF, '');
+
+	  if (!(this instanceof Url)) {
+	    return new Url(address, location, parser);
+	  }
+
+	  var relative, extracted, parse, instruction, index, key
+	    , instructions = rules.slice()
+	    , type = typeof location
+	    , url = this
+	    , i = 0;
+
+	  //
+	  // The following if statements allows this module two have compatibility with
+	  // 2 different API:
+	  //
+	  // 1. Node.js's `url.parse` api which accepts a URL, boolean as arguments
+	  //    where the boolean indicates that the query string should also be parsed.
+	  //
+	  // 2. The `URL` interface of the browser which accepts a URL, object as
+	  //    arguments. The supplied object will be used as default values / fall-back
+	  //    for relative paths.
+	  //
+	  if ('object' !== type && 'string' !== type) {
+	    parser = location;
+	    location = null;
+	  }
+
+	  if (parser && 'function' !== typeof parser) parser = qs.parse;
+
+	  location = lolcation(location);
+
+	  //
+	  // Extract protocol information before running the instructions.
+	  //
+	  extracted = extractProtocol(address || '', location);
+	  relative = !extracted.protocol && !extracted.slashes;
+	  url.slashes = extracted.slashes || relative && location.slashes;
+	  url.protocol = extracted.protocol || location.protocol || '';
+	  address = extracted.rest;
+
+	  //
+	  // When the authority component is absent the URL starts with a path
+	  // component.
+	  //
+	  if (
+	    extracted.protocol === 'file:' && (
+	      extracted.slashesCount !== 2 || windowsDriveLetter.test(address)) ||
+	    (!extracted.slashes &&
+	      (extracted.protocol ||
+	        extracted.slashesCount < 2 ||
+	        !isSpecial(url.protocol)))
+	  ) {
+	    instructions[3] = [/(.*)/, 'pathname'];
+	  }
+
+	  for (; i < instructions.length; i++) {
+	    instruction = instructions[i];
+
+	    if (typeof instruction === 'function') {
+	      address = instruction(address, url);
+	      continue;
+	    }
+
+	    parse = instruction[0];
+	    key = instruction[1];
+
+	    if (parse !== parse) {
+	      url[key] = address;
+	    } else if ('string' === typeof parse) {
+	      index = parse === '@'
+	        ? address.lastIndexOf(parse)
+	        : address.indexOf(parse);
+
+	      if (~index) {
+	        if ('number' === typeof instruction[2]) {
+	          url[key] = address.slice(0, index);
+	          address = address.slice(index + instruction[2]);
+	        } else {
+	          url[key] = address.slice(index);
+	          address = address.slice(0, index);
+	        }
+	      }
+	    } else if ((index = parse.exec(address))) {
+	      url[key] = index[1];
+	      address = address.slice(0, index.index);
+	    }
+
+	    url[key] = url[key] || (
+	      relative && instruction[3] ? location[key] || '' : ''
+	    );
+
+	    //
+	    // Hostname, host and protocol should be lowercased so they can be used to
+	    // create a proper `origin`.
+	    //
+	    if (instruction[4]) url[key] = url[key].toLowerCase();
+	  }
+
+	  //
+	  // Also parse the supplied query string in to an object. If we're supplied
+	  // with a custom parser as function use that instead of the default build-in
+	  // parser.
+	  //
+	  if (parser) url.query = parser(url.query);
+
+	  //
+	  // If the URL is relative, resolve the pathname against the base URL.
+	  //
+	  if (
+	      relative
+	    && location.slashes
+	    && url.pathname.charAt(0) !== '/'
+	    && (url.pathname !== '' || location.pathname !== '')
+	  ) {
+	    url.pathname = resolve(url.pathname, location.pathname);
+	  }
+
+	  //
+	  // Default to a / for pathname if none exists. This normalizes the URL
+	  // to always have a /
+	  //
+	  if (url.pathname.charAt(0) !== '/' && isSpecial(url.protocol)) {
+	    url.pathname = '/' + url.pathname;
+	  }
+
+	  //
+	  // We should not add port numbers if they are already the default port number
+	  // for a given protocol. As the host also contains the port number we're going
+	  // override it with the hostname which contains no port number.
+	  //
+	  if (!required(url.port, url.protocol)) {
+	    url.host = url.hostname;
+	    url.port = '';
+	  }
+
+	  //
+	  // Parse down the `auth` for the username and password.
+	  //
+	  url.username = url.password = '';
+
+	  if (url.auth) {
+	    index = url.auth.indexOf(':');
+
+	    if (~index) {
+	      url.username = url.auth.slice(0, index);
+	      url.username = encodeURIComponent(decodeURIComponent(url.username));
+
+	      url.password = url.auth.slice(index + 1);
+	      url.password = encodeURIComponent(decodeURIComponent(url.password));
+	    } else {
+	      url.username = encodeURIComponent(decodeURIComponent(url.auth));
+	    }
+
+	    url.auth = url.password ? url.username +':'+ url.password : url.username;
+	  }
+
+	  url.origin = url.protocol !== 'file:' && isSpecial(url.protocol) && url.host
+	    ? url.protocol +'//'+ url.host
+	    : 'null';
+
+	  //
+	  // The href is just the compiled result.
+	  //
+	  url.href = url.toString();
+	}
+
+	/**
+	 * This is convenience method for changing properties in the URL instance to
+	 * insure that they all propagate correctly.
+	 *
+	 * @param {String} part          Property we need to adjust.
+	 * @param {Mixed} value          The newly assigned value.
+	 * @param {Boolean|Function} fn  When setting the query, it will be the function
+	 *                               used to parse the query.
+	 *                               When setting the protocol, double slash will be
+	 *                               removed from the final url if it is true.
+	 * @returns {URL} URL instance for chaining.
+	 * @public
+	 */
+	function set(part, value, fn) {
+	  var url = this;
+
+	  switch (part) {
+	    case 'query':
+	      if ('string' === typeof value && value.length) {
+	        value = (fn || qs.parse)(value);
+	      }
+
+	      url[part] = value;
+	      break;
+
+	    case 'port':
+	      url[part] = value;
+
+	      if (!required(value, url.protocol)) {
+	        url.host = url.hostname;
+	        url[part] = '';
+	      } else if (value) {
+	        url.host = url.hostname +':'+ value;
+	      }
+
+	      break;
+
+	    case 'hostname':
+	      url[part] = value;
+
+	      if (url.port) value += ':'+ url.port;
+	      url.host = value;
+	      break;
+
+	    case 'host':
+	      url[part] = value;
+
+	      if (port.test(value)) {
+	        value = value.split(':');
+	        url.port = value.pop();
+	        url.hostname = value.join(':');
+	      } else {
+	        url.hostname = value;
+	        url.port = '';
+	      }
+
+	      break;
+
+	    case 'protocol':
+	      url.protocol = value.toLowerCase();
+	      url.slashes = !fn;
+	      break;
+
+	    case 'pathname':
+	    case 'hash':
+	      if (value) {
+	        var char = part === 'pathname' ? '/' : '#';
+	        url[part] = value.charAt(0) !== char ? char + value : value;
+	      } else {
+	        url[part] = value;
+	      }
+	      break;
+
+	    case 'username':
+	    case 'password':
+	      url[part] = encodeURIComponent(value);
+	      break;
+
+	    case 'auth':
+	      var index = value.indexOf(':');
+
+	      if (~index) {
+	        url.username = value.slice(0, index);
+	        url.username = encodeURIComponent(decodeURIComponent(url.username));
+
+	        url.password = value.slice(index + 1);
+	        url.password = encodeURIComponent(decodeURIComponent(url.password));
+	      } else {
+	        url.username = encodeURIComponent(decodeURIComponent(value));
+	      }
+	  }
+
+	  for (var i = 0; i < rules.length; i++) {
+	    var ins = rules[i];
+
+	    if (ins[4]) url[ins[1]] = url[ins[1]].toLowerCase();
+	  }
+
+	  url.auth = url.password ? url.username +':'+ url.password : url.username;
+
+	  url.origin = url.protocol !== 'file:' && isSpecial(url.protocol) && url.host
+	    ? url.protocol +'//'+ url.host
+	    : 'null';
+
+	  url.href = url.toString();
+
+	  return url;
+	}
+
+	/**
+	 * Transform the properties back in to a valid and full URL string.
+	 *
+	 * @param {Function} stringify Optional query stringify function.
+	 * @returns {String} Compiled version of the URL.
+	 * @public
+	 */
+	function toString(stringify) {
+	  if (!stringify || 'function' !== typeof stringify) stringify = qs.stringify;
+
+	  var query
+	    , url = this
+	    , host = url.host
+	    , protocol = url.protocol;
+
+	  if (protocol && protocol.charAt(protocol.length - 1) !== ':') protocol += ':';
+
+	  var result =
+	    protocol +
+	    ((url.protocol && url.slashes) || isSpecial(url.protocol) ? '//' : '');
+
+	  if (url.username) {
+	    result += url.username;
+	    if (url.password) result += ':'+ url.password;
+	    result += '@';
+	  } else if (url.password) {
+	    result += ':'+ url.password;
+	    result += '@';
+	  } else if (
+	    url.protocol !== 'file:' &&
+	    isSpecial(url.protocol) &&
+	    !host &&
+	    url.pathname !== '/'
+	  ) {
+	    //
+	    // Add back the empty userinfo, otherwise the original invalid URL
+	    // might be transformed into a valid one with `url.pathname` as host.
+	    //
+	    result += '@';
+	  }
+
+	  //
+	  // Trailing colon is removed from `url.host` when it is parsed. If it still
+	  // ends with a colon, then add back the trailing colon that was removed. This
+	  // prevents an invalid URL from being transformed into a valid one.
+	  //
+	  if (host[host.length - 1] === ':' || (port.test(url.hostname) && !url.port)) {
+	    host += ':';
+	  }
+
+	  result += host + url.pathname;
+
+	  query = 'object' === typeof url.query ? stringify(url.query) : url.query;
+	  if (query) result += '?' !== query.charAt(0) ? '?'+ query : query;
+
+	  if (url.hash) result += url.hash;
+
+	  return result;
+	}
+
+	Url.prototype = { set: set, toString: toString };
+
+	//
+	// Expose the URL parser and some additional properties that might be useful for
+	// others or testing.
+	//
+	Url.extractProtocol = extractProtocol;
+	Url.location = lolcation;
+	Url.trimLeft = trimLeft;
+	Url.qs = qs;
+
+	urlParse = Url;
+	return urlParse;
+}
+
+var urlParseExports = requireUrlParse();
+var URL = /*@__PURE__*/getDefaultExportFromCjs(urlParseExports);
+
+function sleep(ms, isReject = false) {
+    return new Promise((resolve, reject) => {
+        setTimeout(isReject
+            ? () => reject({
+                code: 11001,
+                key: '@wutiange/log-listener-plugin%%timeout',
+                message: 'Timeout',
+            })
+            : resolve, ms);
+    });
+}
+function hasPort(url) {
+    if (!url || typeof url !== 'string') {
+        return false;
+    }
+    const parsedUrl = new URL(url);
+    return parsedUrl.port !== '';
+}
+function formDataToString(formData) {
+    const boundary = '----WebKitFormBoundary' + Math.random().toString(36).substr(2);
+    let result = '';
+    const parts = formData.getParts();
+    for (const part of parts) {
+        result += `--${boundary}\r\n`;
+        result += `Content-Disposition: ${part.headers['content-disposition']}\r\n`;
+        if (part.headers['content-type']) {
+            result += `Content-Type: ${part.headers['content-type']}\r\n`;
+        }
+        const value = 'string' in part ? part.string : part.uri;
+        result += `Content-Length: ${value.length}\r\n\r\n`;
+        result += `${value}\r\n`;
+    }
+    result += `--${boundary}--\r\n`;
+    return result;
+}
+function typeReplacer(key, val) {
+    if (val instanceof Error) {
+        return val.toString();
+    }
+    else if (val instanceof Function) {
+        return Function.prototype.toString.call(val);
+    }
+    else if (typeof val === 'symbol') {
+        return val.toString();
+    }
+    else if (typeof val === 'bigint') {
+        return val.toString();
+    }
+    else if (val instanceof RegExp) {
+        return val.toString();
+    }
+    else if (val instanceof Set) {
+        return Array.from(val);
+    }
+    else if (val instanceof Map) {
+        return Object.fromEntries(val);
+    }
+    return val;
+}
+
+const [log, warn, error] = [console.log, console.warn, console.error];
+const logger = {
+    log: (...data) => {
+        log(...data);
+    },
+    warn: (...data) => {
+        warn(...data);
+    },
+    error: (...data) => {
+        error(...data);
+    },
+};
+
+const URLS_KEY = 'log-listener-plugin-urls$$SetKey';
+const DEFAULT_TIMEOUT = 3000;
+const LOG_KEY = '[@wutiange/log-listener-plugin 日志]';
+var Level;
+(function (Level) {
+    Level["LOG"] = "log";
+    Level["WARN"] = "warn";
+    Level["ERROR"] = "error";
+})(Level || (Level = {}));
+var Tag;
+(function (Tag) {
+    Tag["LOG_PLUGIN_INTERNAL_ERROR"] = "log-plugin-internal-error";
+    Tag["DEFAULT"] = "default";
+})(Tag || (Tag = {}));
+const getDefaultDeviceINfo = () => {
+    try {
+        const { Platform } = require('react-native');
+        return {
+            SystemName: Platform.OS,
+            Version: Platform.Version,
+            ...Platform.constants
+        };
+    }
+    catch (error) {
+        logger.warn(LOG_KEY, '这个插件只能在 react-native 中使用');
+        return {};
+    }
+};
+const getBaseData = () => {
+    var _a;
+    try {
+        const DeviceInfo = (_a = require("react-native-device-info")) === null || _a === void 0 ? void 0 : _a.default;
+        return {
+            Brand: DeviceInfo.getBrand(),
+            Model: DeviceInfo.getModel(),
+            AppVersion: DeviceInfo.getVersion(),
+            Carrier: DeviceInfo.getCarrierSync(),
+            Manufacturer: DeviceInfo.getManufacturerSync(),
+            SystemName: DeviceInfo.getSystemName(),
+            ...getDefaultDeviceINfo()
+        };
+    }
+    catch (error) {
+        return getDefaultDeviceINfo();
+    }
+};
+const getDefaultStorage = () => {
+    var _a;
+    try {
+        const AsyncStorage = (_a = require("@react-native-async-storage/async-storage")) === null || _a === void 0 ? void 0 : _a.default;
+        return AsyncStorage;
+    }
+    catch (error) {
+        return null;
+    }
+};
+
+const DEFAULT_PORT = 27751;
+class Server {
+    constructor(url, timeout = 30000) {
+        this.baseUrlArr = new Set();
+        this.urlsObj = new Map();
+        this.baseData = {};
+        this.urlsListener = () => { };
+        this.innerBaseData = {};
+        this.addUrlsListener = (onNewUrlCallback) => {
+            this.urlsListener = onNewUrlCallback;
+        };
+        this.requestJoin = async (url, token) => {
+            var _a;
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json;charset=utf-8',
+                },
+                body: JSON.stringify({
+                    token,
+                    model: (_a = this.innerBaseData.Model) !== null && _a !== void 0 ? _a : `${this.innerBaseData.systemName}v${this.innerBaseData.osVersion}`,
+                }),
+            });
+            if (response.status !== 200) {
+                return false;
+            }
+            const json = await response.json();
+            if (json.code !== 0) {
+                return false;
+            }
+            return true;
+        };
+        this.send = async (path, data) => {
+            const request = async (url, _data) => {
+                await Promise.race([
+                    fetch(`${url}/${path}`, {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json;charset=utf-8',
+                        },
+                        body: JSON.stringify({ ...this.innerBaseData, ...this.baseData, ..._data }, typeReplacer),
+                    }),
+                    sleep(this.timeout, true),
+                ]);
+            };
+            if (this.baseUrlArr.size === 0) {
+                return;
+            }
+            this.baseUrlArr.forEach(async (e) => {
+                var _a, _b;
+                try {
+                    await request(e, data);
+                }
+                catch (error) {
+                    if (((_a = error === null || error === void 0 ? void 0 : error.message) === null || _a === void 0 ? void 0 : _a.includes('Network request failed')) ||
+                        ((_b = error === null || error === void 0 ? void 0 : error.message) === null || _b === void 0 ? void 0 : _b.includes('Timeout'))) {
+                        return;
+                    }
+                    logger.warn(LOG_KEY, '上报日志失败', error);
+                }
+            });
+        };
+        this.log = async (data) => {
+            return this.send('log', data);
+        };
+        this.network = async (data) => {
+            return this.send('network', data);
+        };
+        if (typeof url === 'string') {
+            this.updateUrl(url);
+        }
+        else {
+            this.setBaseUrlArr(url !== null && url !== void 0 ? url : new Set());
+        }
+        this.timeout = timeout;
+        this.innerBaseData = getBaseData();
+        this.handleZeroConf();
+    }
+    async handleZeroConf() {
+        var _a;
+        try {
+            const ZeroConf = (_a = require('react-native-zeroconf')) === null || _a === void 0 ? void 0 : _a.default;
+            if (!ZeroConf) {
+                return;
+            }
+            const zeroConf = new ZeroConf();
+            zeroConf.on('resolved', async (service) => {
+                var _a;
+                try {
+                    const { path, token } = (_a = service.txt) !== null && _a !== void 0 ? _a : {};
+                    const url = `http://${service.host}:${service.port}`;
+                    if (!(path && token)) {
+                        return;
+                    }
+                    if (!(await this.requestJoin(`${url}${path}`, token))) {
+                        return;
+                    }
+                    this.baseUrlArr.add(url);
+                    this.urlsObj.set(service.name, url);
+                    if (this.urlsListener) {
+                        this.urlsListener(this.baseUrlArr);
+                    }
+                }
+                catch (error) {
+                    logger.warn(LOG_KEY, '加入日志系统失败---', error);
+                }
+            });
+            zeroConf.on('remove', (name) => {
+                const currentUrl = this.urlsObj.get(name);
+                if (currentUrl === undefined) {
+                    return;
+                }
+                const isExistSomeUrl = Array.from(this.urlsObj.values()).some((url) => url === currentUrl);
+                this.urlsObj.delete(name);
+                if (isExistSomeUrl) {
+                    return;
+                }
+                this.baseUrlArr.delete(currentUrl);
+                if (this.urlsListener) {
+                    this.urlsListener(this.baseUrlArr);
+                }
+            });
+            zeroConf.on('error', (err) => {
+                logger.warn(LOG_KEY, 'zeroconf出现错误', err);
+            });
+            zeroConf.scan('http', 'tcp');
+        }
+        catch (error) {
+            logger.warn(LOG_KEY, 'zeroconf扫描或处理相关逻辑失败或者您根本就没有安装 react-native-zeroconf ，如果您没有安装，那么您将无法使用发现功能', error);
+        }
+    }
+    updateTimeout(timeout = 3000) {
+        this.timeout = timeout;
+    }
+    updateUrl(url = '') {
+        const tempUrl = url.includes('http') ? url : `http://${url}`;
+        if (!url) {
+            const currentUrl = this.urlsObj.get('Default');
+            if (!currentUrl) {
+                return;
+            }
+            const isExistSomeUrl = Array.from(this.urlsObj.values()).some((url) => url === currentUrl);
+            this.urlsObj.delete('Default');
+            if (isExistSomeUrl) {
+                return;
+            }
+            this.baseUrlArr.delete(currentUrl);
+        }
+        else if (!hasPort(tempUrl)) {
+            this.updateUrl(`${tempUrl}:${DEFAULT_PORT}`);
+        }
+        else {
+            const defaultUrl = this.urlsObj.get('Default');
+            if (defaultUrl) {
+                this.baseUrlArr.delete(defaultUrl);
+            }
+            this.baseUrlArr.add(tempUrl);
+            this.urlsObj.set('Default', tempUrl);
+        }
+    }
+    setBaseUrlArr(urlArr = new Set()) {
+        this.baseUrlArr = urlArr;
+    }
+    getBaseUrlArr() {
+        return this.baseUrlArr;
+    }
+    updateBaseData(data = {}) {
+        this.baseData = data;
+    }
+}
+
+const extractHost = (url) => {
+    var _a, _b;
+    const host = ((_b = (_a = url.split('//')[1]) === null || _a === void 0 ? void 0 : _a.split(':')[0]) === null || _b === void 0 ? void 0 : _b.split('/')[0]) || undefined;
+    return host;
+};
+const generateUniqueId = () => {
+    return Date.now().toString(36) + Math.random().toString(36).substr(2);
+};
+const parseResponseBlob = async (response) => {
+    const blobReader = new BlobFileReader();
+    blobReader.readAsText(response);
+    return await new Promise((resolve, reject) => {
+        const handleError = () => reject(blobReader.error);
+        blobReader.addEventListener('load', () => {
+            var _a;
+            resolve((_a = blobReader.result) !== null && _a !== void 0 ? _a : '');
+        });
+        blobReader.addEventListener('error', handleError);
+        blobReader.addEventListener('abort', handleError);
+    });
+};
+const getResponseBody = async (responseType, response) => {
+    try {
+        if (responseType === 'blob' && response) {
+            return await parseResponseBlob(response);
+        }
+        return response !== null && response !== void 0 ? response : null;
+    }
+    catch (error) {
+        logger.warn('getResponseBody---error---', error);
+        return null;
+    }
+};
+class HTTPInterceptor {
+    constructor() {
+        this.allRequests = new Map();
+        this.userListeners = [];
+        this.enabled = false;
+        this.addListener = (eventName, listener) => {
+            if (this.userListeners.find(([name, tempListener]) => name === eventName && tempListener === listener)) {
+                return;
+            }
+            this.userListeners.push([eventName, listener]);
+            return () => {
+                this.userListeners = this.userListeners.filter(([name, tempListener]) => name !== eventName || tempListener !== listener);
+            };
+        };
+        this.removeListener = (eventName, listener) => {
+            this.userListeners = this.userListeners.filter(([name, tempListener]) => name !== eventName || tempListener !== listener);
+        };
+        this.listenerHandle = (eventName, data) => {
+            this.userListeners.forEach(async ([name, listener]) => {
+                try {
+                    if (name === eventName) {
+                        await listener(data);
+                    }
+                }
+                catch (error) {
+                    console.warn(`eventName=${eventName}, error=${error === null || error === void 0 ? void 0 : error.message}`);
+                }
+            });
+        };
+        this.openHandle = (method, url, xhr) => {
+            if (this.ignoredHosts) {
+                const host = extractHost(url);
+                if (host && this.ignoredHosts.has(host)) {
+                    return;
+                }
+            }
+            if (this.ignoredUrls && this.ignoredUrls.has(url)) {
+                return;
+            }
+            if (this.ignoredPatterns) {
+                if (this.ignoredPatterns.some((pattern) => pattern.test(`${method} ${url}`))) {
+                    return;
+                }
+            }
+            xhr.uniqueId = HTTPInterceptor._index + generateUniqueId();
+            const newRequest = {
+                id: xhr.uniqueId,
+                method,
+                url,
+            };
+            this.allRequests.set(xhr.uniqueId, newRequest);
+            this.listenerHandle('open', newRequest);
+        };
+        this.requestHeaderHandle = (header, value, xhr) => {
+            const currentRequest = this.allRequests.get(xhr.uniqueId);
+            if (!currentRequest) {
+                return;
+            }
+            if (!currentRequest.requestHeaders) {
+                currentRequest.requestHeaders = {};
+            }
+            currentRequest.requestHeaders[header] = value;
+            this.listenerHandle('requestHeader', currentRequest);
+        };
+        this.headerReceivedHandle = (responseContentType, responseSize, responseHeaders, xhr) => {
+            const currentRequest = this.allRequests.get(xhr.uniqueId);
+            if (!currentRequest) {
+                return;
+            }
+            currentRequest.responseContentType = responseContentType;
+            currentRequest.responseSize = responseSize;
+            currentRequest.responseHeaders = xhr.responseHeaders;
+            this.listenerHandle('headerReceived', currentRequest);
+        };
+        this.responseHandle = async (status, timeout, response, responseURL, responseType, xhr) => {
+            var _a;
+            const currentRequest = this.allRequests.get(xhr.uniqueId);
+            if (!currentRequest) {
+                return;
+            }
+            currentRequest.endTime = Date.now();
+            currentRequest.status = status;
+            currentRequest.timeout = timeout;
+            currentRequest.responseData = await getResponseBody(responseType, response);
+            currentRequest.responseURL = responseURL;
+            currentRequest.responseType = responseType;
+            currentRequest.duration =
+                currentRequest.endTime - ((_a = currentRequest.startTime) !== null && _a !== void 0 ? _a : 0);
+            this.listenerHandle('response', currentRequest);
+            this.allRequests.delete(xhr.uniqueId);
+        };
+        this.sendHandle = (data, xhr) => {
+            const currentRequest = this.allRequests.get(xhr.uniqueId);
+            if (!currentRequest) {
+                return;
+            }
+            try {
+                if (data && typeof data === 'object' && data instanceof FormData) {
+                    currentRequest.requestData = formDataToString(data);
+                }
+                else {
+                    currentRequest.requestData = JSON.parse(data);
+                }
+            }
+            catch (error) {
+                currentRequest.requestData = null;
+            }
+            currentRequest.startTime = Date.now();
+            this.listenerHandle('send', currentRequest);
+        };
+        this.setIgnoredUrls = (ignoredUrls) => {
+            if (!Array.isArray(ignoredUrls) ||
+                (ignoredUrls[0] && typeof ignoredUrls[0] !== 'string')) {
+                console.warn('ignoredUrls must be an array of strings. The logger has not been started.');
+                return;
+            }
+            this.ignoredUrls = new Set(ignoredUrls);
+        };
+        this.enable = (options) => {
+            var _a;
+            try {
+                if (this.enabled ||
+                    (XHRInterceptor.isInterceptorEnabled() && !(options === null || options === void 0 ? void 0 : options.forceEnable))) {
+                    if (!this.enabled) {
+                        console.warn('network interceptor has not been enabled as another interceptor is already running (e.g. another debugging program). Use option `forceEnable: true` to override this behaviour.');
+                    }
+                    return;
+                }
+                if (options === null || options === void 0 ? void 0 : options.ignoredHosts) {
+                    if (!Array.isArray(options.ignoredHosts) ||
+                        typeof options.ignoredHosts[0] !== 'string') {
+                        console.warn('ignoredHosts must be an array of strings. The logger has not been started.');
+                        return;
+                    }
+                    this.ignoredHosts = new Set(options.ignoredHosts);
+                }
+                if (options === null || options === void 0 ? void 0 : options.ignoredPatterns) {
+                    this.ignoredPatterns = options.ignoredPatterns;
+                }
+                this.setIgnoredUrls((_a = options === null || options === void 0 ? void 0 : options.ignoredUrls) !== null && _a !== void 0 ? _a : []);
+                XHRInterceptor.setOpenCallback(this.openHandle);
+                XHRInterceptor.setRequestHeaderCallback(this.requestHeaderHandle);
+                XHRInterceptor.setHeaderReceivedCallback(this.headerReceivedHandle);
+                XHRInterceptor.setSendCallback(this.sendHandle);
+                XHRInterceptor.setResponseCallback(this.responseHandle);
+                XHRInterceptor.enableInterception();
+                this.enabled = true;
+            }
+            catch (error) { }
+        };
+        this.disable = () => {
+            if (!this.enabled) {
+                return;
+            }
+            XHRInterceptor.disableInterception();
+            this.enabled = false;
+        };
+        this.reset = () => {
+            this.disable();
+            this.removeAllListener();
+            this.ignoredHosts = undefined;
+            this.ignoredUrls = undefined;
+            this.ignoredPatterns = undefined;
+            this.allRequests.clear();
+        };
+    }
+    removeAllListener() {
+        this.userListeners = [];
+    }
+}
+HTTPInterceptor._index = 0;
+const httpInterceptor = new HTTPInterceptor();
+
+class LogPlugin {
+    constructor() {
+        this.server = null;
+        this.timeout = null;
+        this.isAuto = false;
+        this.storage = getDefaultStorage();
+        this.init = async () => {
+            this.server = new Server();
+            if (this.storage) {
+                const urlsStr = await this.storage.getItem(URLS_KEY);
+                if (urlsStr) {
+                    const urls = JSON.parse(urlsStr);
+                    if (Array.isArray(urls)) {
+                        this.server.setBaseUrlArr(new Set(urls));
+                        httpInterceptor.setIgnoredUrls(this.handleIgnoredUrls());
+                    }
+                }
+            }
+            this.server.addUrlsListener((urlArr) => {
+                if (this.storage) {
+                    this.storage.setItem(URLS_KEY, JSON.stringify(urlArr));
+                }
+                httpInterceptor.setIgnoredUrls(this.handleIgnoredUrls());
+            });
+        };
+        this.config = ({ storage, timeout, testUrl, isAuto, baseData = {} }) => {
+            if (isAuto) {
+                this.auto();
+            }
+            else {
+                this.unAuto();
+            }
+            this.storage = storage !== null && storage !== void 0 ? storage : getDefaultStorage();
+            this.setTimeout(timeout !== null && timeout !== void 0 ? timeout : DEFAULT_TIMEOUT);
+            this.setBaseUrl(testUrl);
+            this.setBaseData(baseData);
+        };
+        this.auto = () => {
+            this.startRecordNetwork();
+            this.startRecordLog();
+            this.isAuto = true;
+        };
+        this.unAuto = () => {
+            this.stopRecordLog();
+            httpInterceptor.disable();
+            httpInterceptor.removeAllListener();
+            this.isAuto = false;
+        };
+        this.startRecordLog = () => {
+            console.log = (...data) => {
+                this.log(...data);
+                if (!__DEV__) {
+                    return;
+                }
+                logger.log(...data);
+            };
+            console.warn = (...data) => {
+                this.warn(...data);
+                if (!__DEV__) {
+                    return;
+                }
+                logger.warn(...data);
+            };
+            console.error = (...data) => {
+                this.error(...data);
+                if (!__DEV__) {
+                    return;
+                }
+                logger.error(...data);
+            };
+        };
+        this.stopRecordLog = () => {
+            console.log = logger.log;
+            console.warn = logger.warn;
+            console.error = logger.error;
+        };
+        this.handleIgnoredUrls = () => {
+            var _a, _b;
+            const urls = (_b = (_a = this.server) === null || _a === void 0 ? void 0 : _a.getBaseUrlArr) === null || _b === void 0 ? void 0 : _b.call(_a);
+            const ignoredUrls = [];
+            if (urls === null || urls === void 0 ? void 0 : urls.size) {
+                urls.forEach((url) => {
+                    ignoredUrls.push(`${url}/log`, `${url}/network`, `${url}/join`);
+                });
+            }
+            return ignoredUrls;
+        };
+        this.startRecordNetwork = () => {
+            httpInterceptor.addListener('send', (data) => {
+                var _a;
+                (_a = this.server) === null || _a === void 0 ? void 0 : _a.network({
+                    url: data.url,
+                    id: data.id,
+                    method: data.method,
+                    headers: data.requestHeaders,
+                    body: data.requestData,
+                    createTime: data.startTime,
+                });
+            });
+            httpInterceptor.addListener('response', (data) => {
+                var _a;
+                (_a = this.server) === null || _a === void 0 ? void 0 : _a.network({
+                    headers: data.responseHeaders,
+                    body: data.responseData,
+                    requestId: data.id,
+                    statusCode: data.status,
+                    endTime: data.endTime,
+                });
+            });
+            httpInterceptor.enable({ ignoredUrls: this.handleIgnoredUrls() });
+        };
+        this.setBaseUrl = (url) => {
+            const tempUrl = url === null || url === void 0 ? void 0 : url.trim();
+            if (this.server) {
+                this.server.updateUrl(tempUrl);
+            }
+            else {
+                this.server = new Server(tempUrl);
+            }
+            httpInterceptor.setIgnoredUrls(this.handleIgnoredUrls());
+            if (this.isAuto) {
+                this.startRecordNetwork();
+                this.startRecordLog();
+            }
+        };
+        this.setTimeout = (timeout) => {
+            var _a;
+            if (typeof timeout === 'number') {
+                this.timeout = timeout;
+                (_a = this.server) === null || _a === void 0 ? void 0 : _a.updateTimeout(this.timeout);
+            }
+        };
+        this.getTimeout = () => {
+            if (typeof this.timeout === 'number') {
+                return this.timeout;
+            }
+            return null;
+        };
+        this.setBaseData = (data = {}) => {
+            var _a;
+            (_a = this.server) === null || _a === void 0 ? void 0 : _a.updateBaseData(data);
+        };
+        this._log = (level, tag, ...data) => {
+            var _a;
+            const sendData = {
+                message: data,
+                tag,
+                level: level !== null && level !== void 0 ? level : 'log',
+                createTime: Date.now(),
+            };
+            (_a = this.server) === null || _a === void 0 ? void 0 : _a.log(sendData);
+        };
+        this.tag = (tag, ...data) => {
+            this._log(Level.LOG, tag, ...data);
+        };
+        this.log = (...data) => {
+            this._log(Level.LOG, Tag.DEFAULT, ...data);
+        };
+        this.warn = (...data) => {
+            this._log(Level.WARN, Tag.DEFAULT, ...data);
+        };
+        this.error = (...data) => {
+            this._log(Level.ERROR, Tag.DEFAULT, ...data);
+        };
+        this.init();
+    }
+}
+const logPlugin = new LogPlugin();
+
+module.exports = logPlugin;
 //# sourceMappingURL=index.cjs.js.map