appium-ios-simulator 3.26.1 → 3.27.2

package/build/lib/defaults-utils.js

@@ -0,0 +1,139 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.toXmlArg = toXmlArg;
+exports.generateUpdateCommandArgs = generateUpdateCommandArgs;
+exports.NSUserDefaults = void 0;
+
+require("source-map-support/register");
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _xmldom = require("xmldom");
+
+var _teen_process = require("teen_process");
+
+var _bluebird = _interopRequireDefault(require("bluebird"));
+
+var _logger = _interopRequireDefault(require("./logger"));
+
+function toXmlArg(value, serialize = true) {
+  let xmlDoc = null;
+
+  if (_lodash.default.isPlainObject(value)) {
+    xmlDoc = new _xmldom.DOMParser().parseFromString('<dict></dict>', 'text/xml');
+
+    for (const [subKey, subValue] of _lodash.default.toPairs(value)) {
+      const keyEl = xmlDoc.createElement('key');
+      const keyTextEl = xmlDoc.createTextNode(subKey);
+      keyEl.appendChild(keyTextEl);
+      xmlDoc.documentElement.appendChild(keyEl);
+      const subValueEl = xmlDoc.importNode(toXmlArg(subValue, false), true);
+      xmlDoc.documentElement.appendChild(subValueEl);
+    }
+  } else if (_lodash.default.isArray(value)) {
+    xmlDoc = new _xmldom.DOMParser().parseFromString('<array></array>', 'text/xml');
+
+    for (const subValue of value) {
+      const subValueEl = xmlDoc.importNode(toXmlArg(subValue, false), true);
+      xmlDoc.documentElement.appendChild(subValueEl);
+    }
+  } else if (_lodash.default.isBoolean(value)) {
+    xmlDoc = new _xmldom.DOMParser().parseFromString(value ? '<true/>' : '<false/>', 'text/xml');
+  } else if (_lodash.default.isInteger(value)) {
+    xmlDoc = new _xmldom.DOMParser().parseFromString(`<integer>${value}</integer>`, 'text/xml');
+  } else if (_lodash.default.isNumber(value)) {
+    xmlDoc = new _xmldom.DOMParser().parseFromString(`<real>${value}</real>`, 'text/xml');
+  } else if (_lodash.default.isString(value)) {
+    xmlDoc = new _xmldom.DOMParser().parseFromString(`<string></string>`, 'text/xml');
+    const valueTextEl = xmlDoc.createTextNode(value);
+    xmlDoc.documentElement.appendChild(valueTextEl);
+  }
+
+  if (!xmlDoc) {
+    throw new TypeError(`The defaults value ${JSON.stringify(value)} cannot be written, ` + `because it is not known how to handle its type`);
+  }
+
+  return serialize ? new _xmldom.XMLSerializer().serializeToString(xmlDoc.documentElement) : xmlDoc.documentElement;
+}
+
+function generateUpdateCommandArgs(valuesMap) {
+  const resultArgs = [];
+
+  for (const [key, value] of _lodash.default.toPairs(valuesMap)) {
+    try {
+      if (_lodash.default.isPlainObject(value)) {
+        const dictArgs = [key, '-dict-add'];
+
+        for (const [subKey, subValue] of _lodash.default.toPairs(value)) {
+          dictArgs.push(subKey, toXmlArg(subValue));
+        }
+
+        resultArgs.push(dictArgs);
+      } else if (_lodash.default.isArray(value)) {
+        const arrayArgs = [key, '-array-add'];
+
+        for (const subValue of arrayArgs) {
+          arrayArgs.push(toXmlArg(subValue));
+        }
+
+        resultArgs.push(arrayArgs);
+      } else {
+        resultArgs.push([key, toXmlArg(value)]);
+      }
+    } catch (e) {
+      if (e instanceof TypeError) {
+        _logger.default.warn(e.message);
+      } else {
+        throw e;
+      }
+    }
+  }
+
+  return resultArgs;
+}
+
+class NSUserDefaults {
+  constructor(plist) {
+    this.plist = plist;
+  }
+
+  async asJson() {
+    try {
+      const {
+        stdout
+      } = await (0, _teen_process.exec)('plutil', ['-convert', 'json', '-o', '-', this.plist]);
+      return JSON.parse(stdout);
+    } catch (e) {
+      throw new Error(`'${this.plist}' cannot be converted to JSON. Original error: ${e.stderr || e.message}`);
+    }
+  }
+
+  async update(valuesMap) {
+    if (!_lodash.default.isPlainObject(valuesMap)) {
+      throw new TypeError(`plist values must be a map. '${valuesMap}' is given instead`);
+    }
+
+    if (_lodash.default.isEmpty(valuesMap)) {
+      return;
+    }
+
+    const commandArgs = generateUpdateCommandArgs(valuesMap);
+
+    try {
+      await _bluebird.default.all(commandArgs.map(args => (0, _teen_process.exec)('defaults', ['write', this.plist, ...args])));
+    } catch (e) {
+      throw new Error(`Could not write defaults into '${this.plist}'. Original error: ${e.stderr || e.message}`);
+    }
+  }
+
+}
+
+exports.NSUserDefaults = NSUserDefaults;require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lib/defaults-utils.js"],"names":["toXmlArg","value","serialize","xmlDoc","_","isPlainObject","DOMParser","parseFromString","subKey","subValue","toPairs","keyEl","createElement","keyTextEl","createTextNode","appendChild","documentElement","subValueEl","importNode","isArray","isBoolean","isInteger","isNumber","isString","valueTextEl","TypeError","JSON","stringify","XMLSerializer","serializeToString","generateUpdateCommandArgs","valuesMap","resultArgs","key","dictArgs","push","arrayArgs","e","log","warn","message","NSUserDefaults","constructor","plist","asJson","stdout","parse","Error","stderr","update","isEmpty","commandArgs","B","all","map","args"],"mappings":"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","sourcesContent":["import _ from 'lodash';\nimport { DOMParser, XMLSerializer } from 'xmldom';\nimport { exec } from 'teen_process';\nimport B from 'bluebird';\nimport log from './logger';\n\n/**\n * Serializes the given value to plist-compatible\n * XML representation, which is ready for further usage\n * with `defaults` command line tool arguments\n *\n * @param {*} value The value to be serialized\n * @param {boolean} serialize [true] Whether to serialize the resulting\n * XML to string or to return raw HTMLElement instance\n * @returns {HTMLElement|string} Either string or raw node representation of\n * the given value\n * @throws {TypeError} If it is not known how to serialize the given value\n */\nfunction toXmlArg (value, serialize = true) {\n  let xmlDoc = null;\n\n  if (_.isPlainObject(value)) {\n    xmlDoc = new DOMParser().parseFromString('<dict></dict>', 'text/xml');\n    for (const [subKey, subValue] of _.toPairs(value)) {\n      const keyEl = xmlDoc.createElement('key');\n      const keyTextEl = xmlDoc.createTextNode(subKey);\n      keyEl.appendChild(keyTextEl);\n      xmlDoc.documentElement.appendChild(keyEl);\n      const subValueEl = xmlDoc.importNode(toXmlArg(subValue, false), true);\n      xmlDoc.documentElement.appendChild(subValueEl);\n    }\n  } else if (_.isArray(value)) {\n    xmlDoc = new DOMParser().parseFromString('<array></array>', 'text/xml');\n    for (const subValue of value) {\n      const subValueEl = xmlDoc.importNode(toXmlArg(subValue, false), true);\n      xmlDoc.documentElement.appendChild(subValueEl);\n    }\n  } else if (_.isBoolean(value)) {\n    xmlDoc = new DOMParser().parseFromString(value ? '<true/>' : '<false/>', 'text/xml');\n  } else if (_.isInteger(value)) {\n    xmlDoc = new DOMParser().parseFromString(`<integer>${value}</integer>`, 'text/xml');\n  } else if (_.isNumber(value)) {\n    xmlDoc = new DOMParser().parseFromString(`<real>${value}</real>`, 'text/xml');\n  } else if (_.isString(value)) {\n    xmlDoc = new DOMParser().parseFromString(`<string></string>`, 'text/xml');\n    const valueTextEl = xmlDoc.createTextNode(value);\n    xmlDoc.documentElement.appendChild(valueTextEl);\n  }\n\n  if (!xmlDoc) {\n    throw new TypeError(`The defaults value ${JSON.stringify(value)} cannot be written, ` +\n      `because it is not known how to handle its type`);\n  }\n\n  return serialize\n    ? new XMLSerializer().serializeToString(xmlDoc.documentElement)\n    : xmlDoc.documentElement;\n}\n\n/**\n * Generates command line args for the `defaults`\n * command line utility based on the given preference values mapping.\n * See https://shadowfile.inode.link/blog/2018/06/advanced-defaults1-usage/\n * for more details.\n *\n * @param {Object} valuesMap Preferences mapping\n * @returns {Array<Array<string>>} Each item in the array\n * is the `defaults write <plist>` command suffix\n */\nfunction generateUpdateCommandArgs (valuesMap) {\n  const resultArgs = [];\n  for (const [key, value] of _.toPairs(valuesMap)) {\n    try {\n      if (_.isPlainObject(value)) {\n        const dictArgs = [key, '-dict-add'];\n        for (const [subKey, subValue] of _.toPairs(value)) {\n          dictArgs.push(subKey, toXmlArg(subValue));\n        }\n        resultArgs.push(dictArgs);\n      } else if (_.isArray(value)) {\n        const arrayArgs = [key, '-array-add'];\n        for (const subValue of arrayArgs) {\n          arrayArgs.push(toXmlArg(subValue));\n        }\n        resultArgs.push(arrayArgs);\n      } else {\n        resultArgs.push([key, toXmlArg(value)]);\n      }\n    } catch (e) {\n      if (e instanceof TypeError) {\n        log.warn(e.message);\n      } else {\n        throw e;\n      }\n    }\n  }\n  return resultArgs;\n}\n\n\nclass NSUserDefaults {\n  constructor (plist) {\n    this.plist = plist;\n  }\n\n  /**\n   * Reads the content of the given plist file using plutil command line tool\n   * and serializes it to a JSON representation\n   *\n   * @returns {Object} The serialized plist content\n   * @throws {Error} If there was an error during serialization\n   */\n  async asJson () {\n    try {\n      const {stdout} = await exec('plutil', ['-convert', 'json', '-o', '-', this.plist]);\n      return JSON.parse(stdout);\n    } catch (e) {\n      throw new Error(`'${this.plist}' cannot be converted to JSON. Original error: ${e.stderr || e.message}`);\n    }\n  }\n\n  /**\n   * Updates the content of the given plist file.\n   * If the plist does not exist yet then it is going to be created.\n   *\n   * @param {Object} valuesMap Mapping of preference values to update.\n   * If any of item values are of dictionary type then only the first level dictionary gets\n   * updated. Everything below this level will be replaced. This is the known limitation\n   * of the `defaults` command line tool. A workaround for it would be to read the current\n   * preferences mapping first and merge it with this value.\n   * @throws {Error} If there was an error while updating the plist\n   */\n  async update (valuesMap) {\n    if (!_.isPlainObject(valuesMap)) {\n      throw new TypeError(`plist values must be a map. '${valuesMap}' is given instead`);\n    }\n    if (_.isEmpty(valuesMap)) {\n      return;\n    }\n\n    const commandArgs = generateUpdateCommandArgs(valuesMap);\n    try {\n      await B.all(commandArgs.map((args) => exec('defaults', ['write', this.plist, ...args])));\n    } catch (e) {\n      throw new Error(`Could not write defaults into '${this.plist}'. Original error: ${e.stderr || e.message}`);\n    }\n  }\n}\n\n\nexport {\n  NSUserDefaults,\n  toXmlArg, generateUpdateCommandArgs,\n};\n"],"file":"lib/defaults-utils.js","sourceRoot":"../.."}

package/build/lib/geolocation.js

@@ -36,21 +36,20 @@ async function setLocationWithLyft(udid, latitude, longitude) {
 }
 
 async function setLocationWithIdb(idb, latitude, longitude) {
-  if (idb) {
-    try {
-      await idb.setLocation(latitude, longitude);
-    } catch (e) {
-      throw new Error(`Failed to set geolocation with idb. Original error: ${e.stderr || e.message}`);
-    }
+  if (!idb) {
+    throw new Error('Failed to set geolocation with idb because it is not installed or the "launchWithIDB" capability was not set');
   }
 
-  throw new Error('Failed to set geolocation with idb because it is not installed');
+  try {
+    await idb.setLocation(latitude, longitude);
+  } catch (e) {
+    throw new Error(`Failed to set geolocation with idb. Original error: ${e.stderr || e.message}`);
+  }
 }
 
 async function setLocationWithAppleScript(sim, latitude, longitude, menu = 'Debug') {
-  const decimalSeparator = 0.1.toLocaleString().replace(/\d/g, '');
-  const latitudeStr = `${latitude}`.replace(/\D/g, decimalSeparator);
-  const longitudeStr = `${longitude}`.replace(/\D/g, decimalSeparator);
+  const decimalSeparator = (await (0, _teen_process.exec)('/usr/bin/python', ['-c', 'from AppKit import NSNumberFormatter;' + 'import sys;' + 'sys.stdout.write(NSNumberFormatter.alloc().init().decimalSeparator())'])).stdout;
+  const [latitudeStr, longitudeStr] = [latitude, longitude].map(coord => `${coord}`.replace(/\D/g, decimalSeparator));
   const output = await sim.executeUIClientScript(`
     tell application "System Events"
       tell process "Simulator"
@@ -77,4 +76,4 @@ async function setLocationWithAppleScript(sim, latitude, longitude, menu = 'Debu
 }require('source-map-support').install();
 
 
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lib/geolocation.js"],"names":["LYFT_SET_LOCATION","setLocationWithLyft","udid","latitude","longitude","fs","which","e","Error","stderr","message","setLocationWithIdb","idb","setLocation","setLocationWithAppleScript","sim","menu","decimalSeparator","toLocaleString","replace","latitudeStr","longitudeStr","output","executeUIClientScript","log","debug","_","trim"],"mappings":";;;;;;;;;;;;;AAAA;;AACA;;AACA;;AACA;;AAEA,MAAMA,iBAAiB,GAAG,wBAA1B;;AAYA,eAAeC,mBAAf,CAAoCC,IAApC,EAA0CC,QAA1C,EAAoDC,SAApD,EAA+D;AAC7D,MAAI;AACF,UAAMC,kBAAGC,KAAH,CAASN,iBAAT,CAAN;AACD,GAFD,CAEE,OAAOO,CAAP,EAAU;AACV,UAAM,IAAIC,KAAJ,CAAW,IAAGR,iBAAkB,4CAAtB,GACd,sFADc,GAEd,qFAFc,GAGd,4CAHI,CAAN;AAID;;AAED,MAAI;AACF,UAAM,wBAAKA,iBAAL,EAAwB,CAC5B,IAD4B,EACtBG,QADsB,EACZC,SADY,EAE5B,IAF4B,EAEtBF,IAFsB,CAAxB,CAAN;AAID,GALD,CAKE,OAAOK,CAAP,EAAU;AACV,UAAM,IAAIC,KAAJ,CAAW,mCAAkCR,iBAAkB,KAArD,GACb,mBAAkBO,CAAC,CAACE,MAAF,IAAYF,CAAC,CAACG,OAAQ,EADrC,CAAN;AAED;AACF;;AAYD,eAAeC,kBAAf,CAAmCC,GAAnC,EAAwCT,QAAxC,EAAkDC,SAAlD,EAA6D;AAC3D,MAAIQ,GAAJ,EAAS;AACP,QAAI;AACF,YAAMA,GAAG,CAACC,WAAJ,CAAgBV,QAAhB,EAA0BC,SAA1B,CAAN;AACD,KAFD,CAEE,OAAOG,CAAP,EAAU;AACV,YAAM,IAAIC,KAAJ,CAAW,uDAAsDD,CAAC,CAACE,MAAF,IAAYF,CAAC,CAACG,OAAQ,EAAvF,CAAN;AACD;AACF;;AACD,QAAM,IAAIF,KAAJ,CAAU,gEAAV,CAAN;AACD;;AAcD,eAAeM,0BAAf,CAA2CC,GAA3C,EAAgDZ,QAAhD,EAA0DC,SAA1D,EAAqEY,IAAI,GAAG,OAA5E,EAAqF;AACnF,QAAMC,gBAAgB,GAAI,GAAD,CAAMC,cAAN,GAAuBC,OAAvB,CAA+B,KAA/B,EAAsC,EAAtC,CAAzB;AAEA,QAAMC,WAAW,GAAI,GAAEjB,QAAS,EAAZ,CAAcgB,OAAd,CAAsB,KAAtB,EAA6BF,gBAA7B,CAApB;AACA,QAAMI,YAAY,GAAI,GAAEjB,SAAU,EAAb,CAAee,OAAf,CAAuB,KAAvB,EAA8BF,gBAA9B,CAArB;AACA,QAAMK,MAAM,GAAG,MAAMP,GAAG,CAACQ,qBAAJ,CAA2B;;;;yHAIuEP,IAAK;;;8DAGhEI,WAAY;;8DAEZC,YAAa;;;;;;;GATpD,CAArB;;AAiBAG,kBAAIC,KAAJ,CAAW,2CAA0CH,MAAO,EAA5D;;AACA,MAAII,gBAAEC,IAAF,CAAOL,MAAP,MAAmB,MAAvB,EAA+B;AAC7B,UAAM,IAAId,KAAJ,CAAW,+DAA8Dc,MAAO,EAAhF,CAAN;AACD;AACF","sourcesContent":["import _ from 'lodash';\nimport log from './logger';\nimport { exec } from 'teen_process';\nimport { fs } from 'appium-support';\n\nconst LYFT_SET_LOCATION = 'set-simulator-location';\n\n/**\n * Set custom geolocation parameters for the given Simulator using LYFT_SET_LOCATION.\n *\n * @param {string} udid - The udid to set the given geolocation\n * @param {string|number} latitude - The latitude value, which is going to be entered\n *   into the corresponding edit field, for example '39,0006'.\n * @param {string|number} longitude - The longitude value, which is going to be entered\n *   into the corresponding edit field, for example '19,0068'.\n * @throws {Error} If it failed to set the location\n */\nasync function setLocationWithLyft (udid, latitude, longitude) {\n  try {\n    await fs.which(LYFT_SET_LOCATION);\n  } catch (e) {\n    throw new Error(`'${LYFT_SET_LOCATION}' binary has not been found in your PATH. ` +\n      'Please install it as \"brew install lyft/formulae/set-simulator-location\" by brew or ' +\n      'read https://github.com/lyft/set-simulator-location to set the binary by manual to ' +\n      'be able to set geolocation by the library.');\n  }\n\n  try {\n    await exec(LYFT_SET_LOCATION, [\n      '-c', latitude, longitude,\n      '-u', udid\n    ]);\n  } catch (e) {\n    throw new Error(`Failed to set geolocation with '${LYFT_SET_LOCATION}'. ` +\n      `Original error: ${e.stderr || e.message}`);\n  }\n}\n\n/**\n * Set custom geolocation parameters for the given Simulator using idb.\n *\n * @param {Object} idb - The IDB instance\n * @param {string|number} latitude - The latitude value, which is going to be entered\n *   into the corresponding edit field, for example '39,0006'.\n * @param {string|number} longitude - The longitude value, which is going to be entered\n *   into the corresponding edit field, for example '19,0068'.\n * @throws {Error} If it failed to set the location\n */\nasync function setLocationWithIdb (idb, latitude, longitude) {\n  if (idb) {\n    try {\n      await idb.setLocation(latitude, longitude);\n    } catch (e) {\n      throw new Error(`Failed to set geolocation with idb. Original error: ${e.stderr || e.message}`);\n    }\n  }\n  throw new Error('Failed to set geolocation with idb because it is not installed');\n}\n\n\n/**\n * Set custom geolocation parameters for the given Simulator using AppleScript\n *\n * @param {Object} sim - The SimulatorXcode object\n * @param {string|number} latitude - The latitude value, which is going to be entered\n *   into the corresponding edit field, for example '39,0006'.\n * @param {string|number} longitude - The longitude value, which is going to be entered\n *   into the corresponding edit field, for example '19,0068'.\n * @param {string} [menu=Debug] - The menu field in which the 'Location' feature is found\n * @throws {Error} If it failed to set the location\n */\nasync function setLocationWithAppleScript (sim, latitude, longitude, menu = 'Debug') {\n  const decimalSeparator = (0.1).toLocaleString().replace(/\\d/g, '');\n  // Make sure system-wide decimal separator is used\n  const latitudeStr = `${latitude}`.replace(/\\D/g, decimalSeparator);\n  const longitudeStr = `${longitude}`.replace(/\\D/g, decimalSeparator);\n  const output = await sim.executeUIClientScript(`\n    tell application \"System Events\"\n      tell process \"Simulator\"\n        set featureName to \"Custom Location\"\n        set dstMenuItem to menu item (featureName & \"…\") of menu 1 of menu item \"Location\" of menu 1 of menu bar item \"${menu}\" of menu bar 1\n        click dstMenuItem\n        delay 1\n        set value of text field 1 of window featureName to \"${latitudeStr}\"\n        delay 0.5\n        set value of text field 2 of window featureName to \"${longitudeStr}\"\n        delay 0.5\n        click button \"OK\" of window featureName\n        delay 0.5\n        set isInvisible to (not (exists (window featureName)))\n      end tell\n    end tell\n  `);\n  log.debug(`Geolocation parameters dialog accepted: ${output}`);\n  if (_.trim(output) !== 'true') {\n    throw new Error(`Failed to set geolocation with AppleScript. Original error: ${output}`);\n  }\n}\n\nexport {\n  setLocationWithLyft, setLocationWithIdb, setLocationWithAppleScript\n};\n"],"file":"lib/geolocation.js","sourceRoot":"../.."}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lib/geolocation.js"],"names":["LYFT_SET_LOCATION","setLocationWithLyft","udid","latitude","longitude","fs","which","e","Error","stderr","message","setLocationWithIdb","idb","setLocation","setLocationWithAppleScript","sim","menu","decimalSeparator","stdout","latitudeStr","longitudeStr","map","coord","replace","output","executeUIClientScript","log","debug","_","trim"],"mappings":";;;;;;;;;;;;;AAAA;;AACA;;AACA;;AACA;;AAEA,MAAMA,iBAAiB,GAAG,wBAA1B;;AAYA,eAAeC,mBAAf,CAAoCC,IAApC,EAA0CC,QAA1C,EAAoDC,SAApD,EAA+D;AAC7D,MAAI;AACF,UAAMC,kBAAGC,KAAH,CAASN,iBAAT,CAAN;AACD,GAFD,CAEE,OAAOO,CAAP,EAAU;AACV,UAAM,IAAIC,KAAJ,CAAW,IAAGR,iBAAkB,4CAAtB,GACd,sFADc,GAEd,qFAFc,GAGd,4CAHI,CAAN;AAID;;AAED,MAAI;AACF,UAAM,wBAAKA,iBAAL,EAAwB,CAC5B,IAD4B,EACtBG,QADsB,EACZC,SADY,EAE5B,IAF4B,EAEtBF,IAFsB,CAAxB,CAAN;AAID,GALD,CAKE,OAAOK,CAAP,EAAU;AACV,UAAM,IAAIC,KAAJ,CAAW,mCAAkCR,iBAAkB,KAArD,GACb,mBAAkBO,CAAC,CAACE,MAAF,IAAYF,CAAC,CAACG,OAAQ,EADrC,CAAN;AAED;AACF;;AAYD,eAAeC,kBAAf,CAAmCC,GAAnC,EAAwCT,QAAxC,EAAkDC,SAAlD,EAA6D;AAC3D,MAAI,CAACQ,GAAL,EAAU;AACR,UAAM,IAAIJ,KAAJ,CAAU,8GAAV,CAAN;AACD;;AAED,MAAI;AACF,UAAMI,GAAG,CAACC,WAAJ,CAAgBV,QAAhB,EAA0BC,SAA1B,CAAN;AACD,GAFD,CAEE,OAAOG,CAAP,EAAU;AACV,UAAM,IAAIC,KAAJ,CAAW,uDAAsDD,CAAC,CAACE,MAAF,IAAYF,CAAC,CAACG,OAAQ,EAAvF,CAAN;AACD;AACF;;AAcD,eAAeI,0BAAf,CAA2CC,GAA3C,EAAgDZ,QAAhD,EAA0DC,SAA1D,EAAqEY,IAAI,GAAG,OAA5E,EAAqF;AAEnF,QAAMC,gBAAgB,GAAG,CAAC,MAAM,wBAAK,iBAAL,EAAwB,CACtD,IADsD,EAEtD,0CACA,aADA,GAEA,uEAJsD,CAAxB,CAAP,EAKrBC,MALJ;AAOA,QAAM,CAACC,WAAD,EAAcC,YAAd,IAA8B,CAACjB,QAAD,EAAWC,SAAX,EAAsBiB,GAAtB,CAA2BC,KAAD,IAAY,GAAEA,KAAM,EAAT,CAAWC,OAAX,CAAmB,KAAnB,EAA0BN,gBAA1B,CAArC,CAApC;AAEA,QAAMO,MAAM,GAAG,MAAMT,GAAG,CAACU,qBAAJ,CAA2B;;;;yHAIuET,IAAK;;;8DAGhEG,WAAY;;8DAEZC,YAAa;;;;;;;GATpD,CAArB;;AAiBAM,kBAAIC,KAAJ,CAAW,2CAA0CH,MAAO,EAA5D;;AACA,MAAII,gBAAEC,IAAF,CAAOL,MAAP,MAAmB,MAAvB,EAA+B;AAC7B,UAAM,IAAIhB,KAAJ,CAAW,+DAA8DgB,MAAO,EAAhF,CAAN;AACD;AACF","sourcesContent":["import _ from 'lodash';\nimport log from './logger';\nimport { exec } from 'teen_process';\nimport { fs } from 'appium-support';\n\nconst LYFT_SET_LOCATION = 'set-simulator-location';\n\n/**\n * Set custom geolocation parameters for the given Simulator using LYFT_SET_LOCATION.\n *\n * @param {string} udid - The udid to set the given geolocation\n * @param {string|number} latitude - The latitude value, which is going to be entered\n *   into the corresponding edit field, for example '39,0006'.\n * @param {string|number} longitude - The longitude value, which is going to be entered\n *   into the corresponding edit field, for example '19,0068'.\n * @throws {Error} If it failed to set the location\n */\nasync function setLocationWithLyft (udid, latitude, longitude) {\n  try {\n    await fs.which(LYFT_SET_LOCATION);\n  } catch (e) {\n    throw new Error(`'${LYFT_SET_LOCATION}' binary has not been found in your PATH. ` +\n      'Please install it as \"brew install lyft/formulae/set-simulator-location\" by brew or ' +\n      'read https://github.com/lyft/set-simulator-location to set the binary by manual to ' +\n      'be able to set geolocation by the library.');\n  }\n\n  try {\n    await exec(LYFT_SET_LOCATION, [\n      '-c', latitude, longitude,\n      '-u', udid\n    ]);\n  } catch (e) {\n    throw new Error(`Failed to set geolocation with '${LYFT_SET_LOCATION}'. ` +\n      `Original error: ${e.stderr || e.message}`);\n  }\n}\n\n/**\n * Set custom geolocation parameters for the given Simulator using idb.\n *\n * @param {Object} idb - The IDB instance\n * @param {string|number} latitude - The latitude value, which is going to be entered\n *   into the corresponding edit field, for example '39,0006'.\n * @param {string|number} longitude - The longitude value, which is going to be entered\n *   into the corresponding edit field, for example '19,0068'.\n * @throws {Error} If it failed to set the location\n */\nasync function setLocationWithIdb (idb, latitude, longitude) {\n  if (!idb) {\n    throw new Error('Failed to set geolocation with idb because it is not installed or the \"launchWithIDB\" capability was not set');\n  }\n\n  try {\n    await idb.setLocation(latitude, longitude);\n  } catch (e) {\n    throw new Error(`Failed to set geolocation with idb. Original error: ${e.stderr || e.message}`);\n  }\n}\n\n\n/**\n * Set custom geolocation parameters for the given Simulator using AppleScript\n *\n * @param {Object} sim - The SimulatorXcode object\n * @param {string|number} latitude - The latitude value, which is going to be entered\n *   into the corresponding edit field, for example '39,0006'.\n * @param {string|number} longitude - The longitude value, which is going to be entered\n *   into the corresponding edit field, for example '19,0068'.\n * @param {string} [menu=Debug] - The menu field in which the 'Location' feature is found\n * @throws {Error} If it failed to set the location\n */\nasync function setLocationWithAppleScript (sim, latitude, longitude, menu = 'Debug') {\n  // Make sure system-wide decimal separator is used\n  const decimalSeparator = (await exec('/usr/bin/python', [\n    '-c',\n    'from AppKit import NSNumberFormatter;' +\n    'import sys;' +\n    'sys.stdout.write(NSNumberFormatter.alloc().init().decimalSeparator())'\n  ])).stdout;\n\n  const [latitudeStr, longitudeStr] = [latitude, longitude].map((coord) => `${coord}`.replace(/\\D/g, decimalSeparator));\n\n  const output = await sim.executeUIClientScript(`\n    tell application \"System Events\"\n      tell process \"Simulator\"\n        set featureName to \"Custom Location\"\n        set dstMenuItem to menu item (featureName & \"…\") of menu 1 of menu item \"Location\" of menu 1 of menu bar item \"${menu}\" of menu bar 1\n        click dstMenuItem\n        delay 1\n        set value of text field 1 of window featureName to \"${latitudeStr}\"\n        delay 0.5\n        set value of text field 2 of window featureName to \"${longitudeStr}\"\n        delay 0.5\n        click button \"OK\" of window featureName\n        delay 0.5\n        set isInvisible to (not (exists (window featureName)))\n      end tell\n    end tell\n  `);\n  log.debug(`Geolocation parameters dialog accepted: ${output}`);\n  if (_.trim(output) !== 'true') {\n    throw new Error(`Failed to set geolocation with AppleScript. Original error: ${output}`);\n  }\n}\n\nexport {\n  setLocationWithLyft, setLocationWithIdb, setLocationWithAppleScript\n};\n"],"file":"lib/geolocation.js","sourceRoot":"../.."}

package/build/lib/simulator-xcode-10.js

@@ -50,16 +50,38 @@ class SimulatorXcode10 extends _simulatorXcode.default {
 
     const timer = new _appiumSupport.timing.Timer().start();
     await this.simctl.openUrl(url);
+    let psError;
 
     try {
-      await (0, _asyncbox.waitForCondition)(async () => (await this.ps()).some(({
-        name
-      }) => name === _utils.MOBILE_SAFARI_BUNDLE_ID), {
+      await (0, _asyncbox.waitForCondition)(async () => {
+        let procList = [];
+
+        try {
+          procList = await this.ps();
+          psError = null;
+        } catch (e) {
+          _logger.default.debug(e.message);
+
+          psError = e;
+        }
+
+        return procList.some(({
+          name
+        }) => name === _utils.MOBILE_SAFARI_BUNDLE_ID);
+      }, {
         waitMs: _utils.SAFARI_STARTUP_TIMEOUT,
         intervalMs: 500
       });
     } catch (err) {
-      throw new Error(`Safari cannot open '${url}' after ${timer.getDuration().asSeconds.toFixed(3)}s ` + `because of: ${err.message}`);
+      const secondsElapsed = timer.getDuration().asSeconds;
+
+      if (psError) {
+        _logger.default.warn(`Mobile Safari process existence cannot be verified after ${secondsElapsed.toFixed(3)}s. ` + `Original error: ${psError.message}`);
+
+        _logger.default.warn('Continuing anyway');
+      } else {
+        throw new Error(`Mobile Safari cannot open '${url}' after ${secondsElapsed.toFixed(3)}s. ` + `Its process ${_utils.MOBILE_SAFARI_BUNDLE_ID} does not exist in the list of Simulator processes`);
+      }
     }
 
     _logger.default.debug(`Safari successfully opened '${url}' in ${timer.getDuration().asSeconds.toFixed(3)}s`);
@@ -71,4 +93,4 @@ var _default = SimulatorXcode10;
 exports.default = _default;require('source-map-support').install();
 
 
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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