@wopee-io/wopee.wdio 4.7.0 → 5.0.2

package/node_modules/axios/lib/helpers/toFormData.js

@@ -1,19 +1,79 @@
 'use strict';
 
 var utils = require('../utils');
+var AxiosError = require('../core/AxiosError');
+var envFormData = require('../env/classes/FormData');
+
+function isVisitable(thing) {
+  return utils.isPlainObject(thing) || utils.isArray(thing);
+}
+
+function removeBrackets(key) {
+  return utils.endsWith(key, '[]') ? key.slice(0, -2) : key;
+}
+
+function renderKey(path, key, dots) {
+  if (!path) return key;
+  return path.concat(key).map(function each(token, i) {
+    // eslint-disable-next-line no-param-reassign
+    token = removeBrackets(token);
+    return !dots && i ? '[' + token + ']' : token;
+  }).join(dots ? '.' : '');
+}
+
+function isFlatArray(arr) {
+  return utils.isArray(arr) && !arr.some(isVisitable);
+}
+
+var predicates = utils.toFlatObject(utils, {}, null, function filter(prop) {
+  return /^is[A-Z]/.test(prop);
+});
+
+function isSpecCompliant(thing) {
+  return thing && utils.isFunction(thing.append) && thing[Symbol.toStringTag] === 'FormData' && thing[Symbol.iterator];
+}
 
 /**
  * Convert a data object to FormData
  * @param {Object} obj
  * @param {?Object} [formData]
+ * @param {?Object} [options]
+ * @param {Function} [options.visitor]
+ * @param {Boolean} [options.metaTokens = true]
+ * @param {Boolean} [options.dots = false]
+ * @param {?Boolean} [options.indexes = false]
  * @returns {Object}
  **/
 
-function toFormData(obj, formData) {
+function toFormData(obj, formData, options) {
+  if (!utils.isObject(obj)) {
+    throw new TypeError('target must be an object');
+  }
+
   // eslint-disable-next-line no-param-reassign
-  formData = formData || new FormData();
+  formData = formData || new (envFormData || FormData)();
 
-  var stack = [];
+  // eslint-disable-next-line no-param-reassign
+  options = utils.toFlatObject(options, {
+    metaTokens: true,
+    dots: false,
+    indexes: false
+  }, false, function defined(option, source) {
+    // eslint-disable-next-line no-eq-null,eqeqeq
+    return !utils.isUndefined(source[option]);
+  });
+
+  var metaTokens = options.metaTokens;
+  // eslint-disable-next-line no-use-before-define
+  var visitor = options.visitor || defaultVisitor;
+  var dots = options.dots;
+  var indexes = options.indexes;
+  var _Blob = options.Blob || typeof Blob !== 'undefined' && Blob;
+  var useBlob = _Blob && isSpecCompliant(formData);
+
+  if (!utils.isFunction(visitor)) {
+    throw new TypeError('visitor must be a function');
+  }
 
   function convertValue(value) {
     if (value === null) return '';
@@ -22,46 +82,93 @@ function toFormData(obj, formData) {
       return value.toISOString();
     }
 
+    if (!useBlob && utils.isBlob(value)) {
+      throw new AxiosError('Blob is not supported. Use a Buffer instead.');
+    }
+
     if (utils.isArrayBuffer(value) || utils.isTypedArray(value)) {
-      return typeof Blob === 'function' ? new Blob([value]) : Buffer.from(value);
+      return useBlob && typeof Blob === 'function' ? new Blob([value]) : Buffer.from(value);
     }
 
     return value;
   }
 
-  function build(data, parentKey) {
-    if (utils.isPlainObject(data) || utils.isArray(data)) {
-      if (stack.indexOf(data) !== -1) {
-        throw Error('Circular reference detected in ' + parentKey);
+  /**
+   *
+   * @param {*} value
+   * @param {String|Number} key
+   * @param {Array<String|Number>} path
+   * @this {FormData}
+   * @returns {boolean} return true to visit the each prop of the value recursively
+   */
+  function defaultVisitor(value, key, path) {
+    var arr = value;
+
+    if (value && !path && typeof value === 'object') {
+      if (utils.endsWith(key, '{}')) {
+        // eslint-disable-next-line no-param-reassign
+        key = metaTokens ? key : key.slice(0, -2);
+        // eslint-disable-next-line no-param-reassign
+        value = JSON.stringify(value);
+      } else if (
+        (utils.isArray(value) && isFlatArray(value)) ||
+        (utils.isFileList(value) || utils.endsWith(key, '[]') && (arr = utils.toArray(value))
+        )) {
+        // eslint-disable-next-line no-param-reassign
+        key = removeBrackets(key);
+
+        arr.forEach(function each(el, index) {
+          !(utils.isUndefined(el) || el === null) && formData.append(
+            // eslint-disable-next-line no-nested-ternary
+            indexes === true ? renderKey([key], index, dots) : (indexes === null ? key : key + '[]'),
+            convertValue(el)
+          );
+        });
+        return false;
       }
+    }
 
-      stack.push(data);
-
-      utils.forEach(data, function each(value, key) {
-        if (utils.isUndefined(value)) return;
-        var fullKey = parentKey ? parentKey + '.' + key : key;
-        var arr;
-
-        if (value && !parentKey && typeof value === 'object') {
-          if (utils.endsWith(key, '{}')) {
-            // eslint-disable-next-line no-param-reassign
-            value = JSON.stringify(value);
-          } else if (utils.endsWith(key, '[]') && (arr = utils.toArray(value))) {
-            // eslint-disable-next-line func-names
-            arr.forEach(function(el) {
-              !utils.isUndefined(el) && formData.append(fullKey, convertValue(el));
-            });
-            return;
-          }
-        }
-
-        build(value, fullKey);
-      });
-
-      stack.pop();
-    } else {
-      formData.append(parentKey, convertValue(data));
+    if (isVisitable(value)) {
+      return true;
     }
+
+    formData.append(renderKey(path, key, dots), convertValue(value));
+
+    return false;
+  }
+
+  var stack = [];
+
+  var exposedHelpers = Object.assign(predicates, {
+    defaultVisitor: defaultVisitor,
+    convertValue: convertValue,
+    isVisitable: isVisitable
+  });
+
+  function build(value, path) {
+    if (utils.isUndefined(value)) return;
+
+    if (stack.indexOf(value) !== -1) {
+      throw Error('Circular reference detected in ' + path.join('.'));
+    }
+
+    stack.push(value);
+
+    utils.forEach(value, function each(el, key) {
+      var result = !(utils.isUndefined(el) || el === null) && visitor.call(
+        formData, el, utils.isString(key) ? key.trim() : key, path, exposedHelpers
+      );
+
+      if (result === true) {
+        build(el, path ? path.concat(key) : [key]);
+      }
+    });
+
+    stack.pop();
+  }
+
+  if (!utils.isObject(obj)) {
+    throw new TypeError('data must be an object');
   }
 
   build(obj);

package/node_modules/axios/lib/helpers/toURLEncodedForm.js

@@ -0,0 +1,18 @@
+'use strict';
+
+var utils = require('../utils');
+var toFormData = require('./toFormData');
+var platform = require('../platform/');
+
+module.exports = function toURLEncodedForm(data, options) {
+  return toFormData(data, new platform.classes.URLSearchParams(), Object.assign({
+    visitor: function(value, key, path, helpers) {
+      if (platform.isNode && utils.isBuffer(value)) {
+        this.append(key, value.toString('base64'));
+        return false;
+      }
+
+      return helpers.defaultVisitor.apply(this, arguments);
+    }
+  }, options));
+};

package/node_modules/axios/lib/platform/browser/classes/FormData.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = FormData;

package/node_modules/axios/lib/platform/browser/classes/URLSearchParams.js

@@ -0,0 +1,5 @@
+'use strict';
+
+var AxiosURLSearchParams = require('../../../helpers/AxiosURLSearchParams');
+
+module.exports = typeof URLSearchParams !== 'undefined' ? URLSearchParams : AxiosURLSearchParams;

package/node_modules/axios/lib/platform/browser/index.js

@@ -0,0 +1,11 @@
+'use strict';
+
+module.exports = {
+  isBrowser: true,
+  classes: {
+    URLSearchParams: require('./classes/URLSearchParams'),
+    FormData: require('./classes/FormData'),
+    Blob: Blob
+  },
+  protocols: ['http', 'https', 'file', 'blob', 'url', 'data']
+};

package/node_modules/axios/lib/platform/index.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('./node/');

package/node_modules/axios/lib/platform/node/classes/FormData.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('form-data');

package/node_modules/axios/lib/platform/node/classes/URLSearchParams.js

@@ -0,0 +1,5 @@
+'use strict';
+
+var url = require('url');
+
+module.exports = url.URLSearchParams;

package/node_modules/axios/lib/platform/node/index.js

@@ -0,0 +1,11 @@
+'use strict';
+
+module.exports = {
+  isNode: true,
+  classes: {
+    URLSearchParams: require('./classes/URLSearchParams'),
+    FormData: require('./classes/FormData'),
+    Blob: typeof Blob !== 'undefined' && Blob || null
+  },
+  protocols: [ 'http', 'https', 'file', 'data' ]
+};

package/node_modules/axios/lib/utils.js

@@ -124,6 +124,16 @@ function isPlainObject(val) {
   return prototype === null || prototype === Object.prototype;
 }
 
+/**
+ * Determine if a value is a empty Object
+ *
+ * @param {Object} val The value to test
+ * @return {boolean} True if value is a empty Object, otherwise false
+ */
+function isEmptyObject(val) {
+  return val && Object.keys(val).length === 0 && Object.getPrototypeOf(val) === Object.prototype;
+}
+
 /**
  * Determine if a value is a Date
  *
@@ -210,7 +220,7 @@ var isURLSearchParams = kindOfTest('URLSearchParams');
  * @returns {String} The String freed of excess whitespace
  */
 function trim(str) {
-  return str.trim ? str.trim() : str.replace(/^\s+|\s+$/g, '');
+  return str.trim ? str.trim() : str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '');
 }
 
 /**
@@ -229,15 +239,16 @@ function trim(str) {
  *  navigator.product -> 'NativeScript' or 'NS'
  */
 function isStandardBrowserEnv() {
-  if (typeof navigator !== 'undefined' && (navigator.product === 'ReactNative' ||
-                                           navigator.product === 'NativeScript' ||
-                                           navigator.product === 'NS')) {
+  var product;
+  if (typeof navigator !== 'undefined' && (
+    (product = navigator.product) === 'ReactNative' ||
+    product === 'NativeScript' ||
+    product === 'NS')
+  ) {
     return false;
   }
-  return (
-    typeof window !== 'undefined' &&
-    typeof document !== 'undefined'
-  );
+
+  return typeof window !== 'undefined' && typeof document !== 'undefined';
 }
 
 /**
@@ -366,29 +377,32 @@ function inherits(constructor, superConstructor, props, descriptors) {
  * Resolve object with deep prototype chain to a flat object
  * @param {Object} sourceObj source object
  * @param {Object} [destObj]
- * @param {Function} [filter]
+ * @param {Function|Boolean} [filter]
+ * @param {Function} [propFilter]
  * @returns {Object}
  */
 
-function toFlatObject(sourceObj, destObj, filter) {
+function toFlatObject(sourceObj, destObj, filter, propFilter) {
   var props;
   var i;
   var prop;
   var merged = {};
 
   destObj = destObj || {};
+  // eslint-disable-next-line no-eq-null,eqeqeq
+  if (sourceObj == null) return destObj;
 
   do {
     props = Object.getOwnPropertyNames(sourceObj);
     i = props.length;
     while (i-- > 0) {
       prop = props[i];
-      if (!merged[prop]) {
+      if ((!propFilter || propFilter(prop, sourceObj, destObj)) && !merged[prop]) {
         destObj[prop] = sourceObj[prop];
         merged[prop] = true;
       }
     }
-    sourceObj = Object.getPrototypeOf(sourceObj);
+    sourceObj = filter !== false && Object.getPrototypeOf(sourceObj);
   } while (sourceObj && (!filter || filter(sourceObj, destObj)) && sourceObj !== Object.prototype);
 
   return destObj;
@@ -413,14 +427,15 @@ function endsWith(str, searchString, position) {
 
 
 /**
- * Returns new array from array like object
+ * Returns new array from array like object or null if failed
  * @param {*} [thing]
- * @returns {Array}
+ * @returns {?Array}
  */
 function toArray(thing) {
   if (!thing) return null;
+  if (isArray(thing)) return thing;
   var i = thing.length;
-  if (isUndefined(i)) return null;
+  if (!isNumber(i)) return null;
   var arr = new Array(i);
   while (i-- > 0) {
     arr[i] = thing[i];
@@ -436,6 +451,38 @@ var isTypedArray = (function(TypedArray) {
   };
 })(typeof Uint8Array !== 'undefined' && Object.getPrototypeOf(Uint8Array));
 
+function forEachEntry(obj, fn) {
+  var generator = obj && obj[Symbol.iterator];
+
+  var iterator = generator.call(obj);
+
+  var result;
+
+  while ((result = iterator.next()) && !result.done) {
+    var pair = result.value;
+    fn.call(obj, pair[0], pair[1]);
+  }
+}
+
+function matchAll(regExp, str) {
+  var matches;
+  var arr = [];
+
+  while ((matches = regExp.exec(str)) !== null) {
+    arr.push(matches);
+  }
+
+  return arr;
+}
+
+var isHTMLForm = kindOfTest('HTMLFormElement');
+
+var hasOwnProperty = (function resolver(_hasOwnProperty) {
+  return function(obj, prop) {
+    return _hasOwnProperty.call(obj, prop);
+  };
+})(Object.prototype.hasOwnProperty);
+
 module.exports = {
   isArray: isArray,
   isArrayBuffer: isArrayBuffer,
@@ -446,6 +493,7 @@ module.exports = {
   isNumber: isNumber,
   isObject: isObject,
   isPlainObject: isPlainObject,
+  isEmptyObject: isEmptyObject,
   isUndefined: isUndefined,
   isDate: isDate,
   isFile: isFile,
@@ -466,5 +514,9 @@ module.exports = {
   endsWith: endsWith,
   toArray: toArray,
   isTypedArray: isTypedArray,
-  isFileList: isFileList
+  isFileList: isFileList,
+  forEachEntry: forEachEntry,
+  matchAll: matchAll,
+  isHTMLForm: isHTMLForm,
+  hasOwnProperty: hasOwnProperty
 };

package/node_modules/axios/package.json

@@ -1,14 +1,14 @@
 {
   "name": "axios",
-  "version": "0.27.2",
+  "version": "0.30.0",
   "description": "Promise based HTTP client for the browser and node.js",
   "main": "index.js",
   "types": "index.d.ts",
   "scripts": {
-    "test": "grunt test && dtslint",
+    "test": "node bin/ssl_hotfix.js grunt test && node bin/ssl_hotfix.js dtslint --localTs node_modules/typescript/lib",
     "start": "node ./sandbox/server.js",
     "preversion": "grunt version && npm test",
-    "build": "NODE_ENV=production grunt build",
+    "build": "cross-env NODE_ENV=production grunt build",
     "examples": "node ./examples/server.js",
     "coveralls": "cat coverage/lcov.info | ./node_modules/coveralls/bin/coveralls.js",
     "fix": "eslint --fix lib/**/*.js"
@@ -31,10 +31,18 @@
   },
   "homepage": "https://axios-http.com",
   "devDependencies": {
+    "@rollup/plugin-babel": "^5.3.0",
+    "@rollup/plugin-commonjs": "^15.1.0",
+    "@rollup/plugin-json": "^4.1.0",
+    "@rollup/plugin-multi-entry": "^4.0.0",
+    "@rollup/plugin-node-resolve": "^9.0.0",
     "abortcontroller-polyfill": "^1.7.3",
+    "body-parser": "^1.20.0",
     "coveralls": "^3.1.1",
+    "cross-env": "^7.0.3",
     "dtslint": "^4.2.1",
     "es6-promise": "^4.2.8",
+    "express": "^4.18.1",
     "formidable": "^2.0.1",
     "grunt": "^1.4.1",
     "grunt-banner": "^0.6.0",
@@ -44,6 +52,7 @@
     "grunt-eslint": "^24.0.0",
     "grunt-karma": "^4.0.2",
     "grunt-mocha-test": "^0.13.3",
+    "grunt-shell": "^3.0.1",
     "grunt-webpack": "^5.0.0",
     "istanbul-instrumenter-loader": "^3.0.1",
     "jasmine-core": "^2.4.1",
@@ -60,6 +69,9 @@
     "load-grunt-tasks": "^5.1.0",
     "minimist": "^1.2.6",
     "mocha": "^8.2.1",
+    "multer": "^1.4.4",
+    "rollup": "^2.67.0",
+    "rollup-plugin-terser": "^7.0.2",
     "sinon": "^4.5.0",
     "terser-webpack-plugin": "^4.2.3",
     "typescript": "^4.6.3",
@@ -69,14 +81,15 @@
   },
   "browser": {
     "./lib/adapters/http.js": "./lib/adapters/xhr.js",
-    "./lib/defaults/env/FormData.js": "./lib/helpers/null.js"
+    "./lib/platform/node/index.js": "./lib/platform/browser/index.js"
   },
   "jsdelivr": "dist/axios.min.js",
   "unpkg": "dist/axios.min.js",
   "typings": "./index.d.ts",
   "dependencies": {
-    "follow-redirects": "^1.14.9",
-    "form-data": "^4.0.0"
+    "follow-redirects": "^1.15.4",
+    "form-data": "^4.0.0",
+    "proxy-from-env": "^1.1.0"
   },
   "bundlesize": [
     {
@@ -84,4 +97,4 @@
       "threshold": "5kB"
     }
   ]
-}
+}

package/node_modules/axios/rollup.config.js

@@ -0,0 +1,60 @@
+import resolve from '@rollup/plugin-node-resolve';
+import commonjs from '@rollup/plugin-commonjs';
+import {terser} from "rollup-plugin-terser";
+import json from '@rollup/plugin-json';
+
+const lib = require("./package.json");
+const outputFileName = 'axios';
+const name = "axios";
+const input = './lib/axios.js';
+
+const buildConfig = (config) => {
+
+  const build = ({minified}) => ({
+    input,
+    ...config,
+    output: {
+      ...config.output,
+      file: `${config.output.file}.${minified ? "min.js" : "js"}`
+    },
+    plugins: [
+      json(),
+      resolve({browser: true}),
+      commonjs(),
+      minified && terser(),
+      ...(config.plugins || []),
+    ]
+  });
+
+  return [
+    build({minified: false}),
+    build({minified: true}),
+  ];
+};
+
+export default async () => {
+  const year = new Date().getFullYear();
+  const banner = `// ${lib.name} v${lib.version} Copyright (c) ${year} ${lib.author}`;
+
+  return [
+    ...buildConfig({
+      output: {
+        file: `dist/${outputFileName}`,
+        name,
+        format: "umd",
+        exports: "default",
+        banner
+      }
+    }),
+
+    ...buildConfig({
+      output: {
+        file: `dist/esm/${outputFileName}`,
+        format: "esm",
+        preferConst: true,
+        exports: "named",
+        banner
+      }
+    })
+  ]
+};

package/node_modules/proxy-from-env/.eslintrc

@@ -0,0 +1,29 @@
+{
+  "env": {
+    "node": true
+  },
+  "rules": {
+    "array-bracket-spacing": [2, "never"],
+    "block-scoped-var": 2,
+    "brace-style": [2, "1tbs"],
+    "camelcase": 1,
+    "computed-property-spacing": [2, "never"],
+    "curly": 2,
+    "eol-last": 2,
+    "eqeqeq": [2, "smart"],
+    "max-depth": [1, 3],
+    "max-len": [1, 80],
+    "max-statements": [1, 15],
+    "new-cap": 1,
+    "no-extend-native": 2,
+    "no-mixed-spaces-and-tabs": 2,
+    "no-trailing-spaces": 2,
+    "no-unused-vars": 1,
+    "no-use-before-define": [2, "nofunc"],
+    "object-curly-spacing": [2, "never"],
+    "quotes": [2, "single", "avoid-escape"],
+    "semi": [2, "always"],
+    "keyword-spacing": [2, {"before": true, "after": true}],
+    "space-unary-ops": 2
+  }
+}

package/node_modules/proxy-from-env/.travis.yml

@@ -0,0 +1,10 @@
+language: node_js
+node_js:
+  - node
+  - lts/*
+script:
+  - npm run lint
+  # test-coverage will also run the tests, but does not print helpful output upon test failure.
+  # So we also run the tests separately.
+  - npm run test
+  - npm run test-coverage && cat coverage/lcov.info | ./node_modules/.bin/coveralls && rm -rf coverage

package/node_modules/proxy-from-env/LICENSE

@@ -0,0 +1,20 @@
+The MIT License
+
+Copyright (C) 2016-2018 Rob Wu <rob@robwu.nl>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.