Source: index.js

  1. /**
  2. * @file Main file responsible for starting up the web (client) portion of
  3. * CypherPoker.JS. Also provides functionality for dynamic loading of additional
  4. * scripts and JSON data.
  5. *
  6. * @version 0.5.0
  7. */
  9. /**
  10. * @property {String} appVersion The version of the application. This information
  11. * is appended to the {@link appTitle}.
  12. */
  13. var appVersion = "0.5.0";
  14. /**
  15. * @property {String} appName The name of the application. This information
  16. * is prepended to the {@link appTitle}.
  17. */
  18. var appName = "CypherPoker.JS";
  19. /**
  20. * @property {String} appTitle The title of the application as it should appear in
  21. * the main browser window / tab and any new windows / tabs. If running as a desktop
  22. * (Electron) application, this is the name that appears on all child windows of
  23. * the main process.
  24. */
  25. var appTitle = appName+" v"+appVersion;
  26. /**
  27. * @property {String} _settingsURL="./scripts/settings.json" The URL of the main
  28. * settings JSON file.
  29. * @private
  30. */
  31. const _settingsURL = "./scripts/settings.json";
  32. /**
  33. * @property {Boolean} _useCache=false Will force script-based loads to bypass
  34. * local browser caches if false.
  35. * @private
  36. */
  37. const _useCache = false;
  38. /**
  39. * @property {CypherPoker} cypherpoker=null A reference to the main CypherPoker.JS instance.
  40. * @private
  41. */
  42. var cypherpoker = null;
  43. /**
  44. * @property {CypherPokerUI} ui=null A reference to the CypherPokerUI instance
  45. * @private
  46. */
  47. var ui = null;
  48. /**
  49. * @property {Object} hostEnv=null Contains settings and references supplied by
  50. * a non-browser host environment such as Electron. When running as a standard web
  51. * page in a browser this value should remain null.
  52. */
  53. var hostEnv = null;
  54. /**
  55. * @property {Object} ipcRenderer=null A reference to the <code>ipcRenderer</code>
  56. * object of the host desktop (Electron) environment. If this script is running
  57. * within a standard web browser this reference will remain <code>null</code>.
  58. */
  59. var ipcRenderer = null;
  60. /**
  61. * @property {String} ipcID=null an interprocess communication ID used to
  62. * identify this window (child process) to the main process. If not running
  63. * in a desktop (Electron) environment, this value will remain <code>null</code>.
  64. */
  65. var ipcID = null;
  66. /**
  67. * @property {Array} _require Indexed array of required external scripts,
  68. * in the order that they must be loaded in.
  69. * @property {String} _require.url The URL of the external script to load.
  70. * @property {Function} [_require.onload] A function reference to invoke
  71. * when the script is finished loading.
  72. * @private
  73. */
  74. const _require = [
  75.    {"url":"./scripts/libs/Polyfills.js"},
  76.    {"url":"./scripts/libs/EventDispatcher.js"},
  77.    {"url":"./scripts/libs/EventPromise.js"},
  78.    {"url":"./scripts/libs/SDB.js"},
  79.    {"url":"./scripts/libs/RPC.js"},
  80.    {"url":"./scripts/libs/transports/WSSClient.js"},
  81.    {"url":"./scripts/libs/transports/WSSTunnel.js"},
  82.    {"url":"./scripts/libs/transports/WebRTCClient.js"},
  83.    {"url":"./scripts/libs/APIRouter.js"},
  84.    {"url":"./scripts/libs/P2PRouter.js"},
  85.    {"url":"./scripts/libs/ConnectivityManager.js"},
  86.    {"url":"./scripts/libs/WorkerHost.js"},
  87.    {"url":"./scripts/libs/SRACrypto.js"},
  88.    {"url":"./scripts/libs/BigInteger.min.js"},
  89.    {"url":"./scripts/CypherPokerGame.js"},
  90.    {"url":"./scripts/CypherPokerPlayer.js"},
  91.    {"url":"./scripts/CypherPokerAccount.js"},
  92.    {"url":"./scripts/CypherPokerCard.js"},
  93.    {"url":"./scripts/CypherPokerContract.js"},
  94.    {"url":"./scripts/CypherPokerAnalyzer.js"},
  95.    {"url":"./scripts/CypherPokerUI.js",
  96.       "onload": () => {
  97.          var promise = new Promise((resolve, reject) => {
  98.             //game UI to be contained in the #game element
  99.             var gameElement = document.querySelector("#game");
  100.             ui = new CypherPokerUI(gameElement);
  101.             ui.initialize();
  102.             resolve(true);
  103.          })
  104.          return (promise);
  105.       }
  106.    },
  107.    {"url":"./scripts/CypherPoker.js",
  108.       "onload": () => {
  109.          var promise = new Promise((resolve, reject) => {
  110.             ui.showDialog ("Loading game settings...");
  111.             //EventDispatcher and EventPromise must already exist here!
  112.             loadJSON(_settingsURL).onEventPromise("load").then(promise => {
  113.                if (promise.target.response != null) {
  114.                   cypherpoker = new CypherPoker(promise.target.response);
  115.                   ui.cypherpoker = cypherpoker; //attach the cypherpoker instance to the UI
  116.                   var urlParams = parseURLParameters(document.location);
  117.                   var startOptions = new Object();
  118.                   startOptions.urlParams = urlParams;
  119.                   cypherpoker.start(startOptions).then(result => {
  120.                      console.log ("CypherPoker.JS instance fully started and connected.");
  121.                      resolve(true);
  122.                   }).catch(err => {
  123.                      ui.showDialog(err.message);
  124.                      console.error(err.stack);
  125.                      reject(false);
  126.                   });
  127.                } else {
  128.                   alert (`Settings data (${_settingsURL}) not loaded or parsed.`);
  129.                   throw (new Error(`Settings data (${_settingsURL}) not loaded or parsed.`));
  130.                   reject(false);
  131.                }
  132.             });
  133.          });
  134.       }
  135.    }
  136. ]
  138. /**
  139. * Parses a supplied URL string that may contain parameters (e.g. document.location),
  140. * and returns an object with the parameters parsed to name-value pairs. Any URL-encoded
  141. * properties are decoded to native representations prior to being parsed.
  142. *
  143. * @param {String} urlString The URL string, either absolute or relative, to parse.
  144. *
  145. * @return {URLSearchParams} A [URLSearchParams]{@link https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams}
  146. * instance containing the parsed name-value pairs found in the <code>urlString</code>.
  147. *
  148. * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams}
  149. */
  150. function parseURLParameters(urlString) {
  151.    var decodedURL = decodeURI(urlString);
  152.    var urlObj = new URL(decodedURL);
  153.    return (urlObj.searchParams);
  154. }
  156. /**
  157. * Loads an external JavaScript file by adding a <script> tag to the
  158. * DOM's <head> tag.
  159. *
  160. * @param {String} scriptURL The URL of the script to load and parse.
  161. * @private
  162. */
  163. function loadJavaScript(scriptURL) {
  164.    var script = document.createElement("script");
  165.    script.setAttribute("type", "text/javascript");
  166.    script.setAttribute("language", "text/JavaScript");
  167.    if (_useCache == false) {
  168.       //force script load (ignore cache)
  169.       scriptURL = scriptURL + "?" + String(Math.random()).split("0.")[1];
  170.    }
  171.    script.setAttribute("src", scriptURL);
  172.    script.addEventListener ("load", onLoadJavaScript);
  173.    document.getElementsByTagName("head")[0].appendChild(script);
  174. }
  176. /**
  177. * Event handler invoked when an external JavaScript file has completed loading.
  178. * The next file in the {@link _requires} array is automatically loaded.
  179. *
  180. * @param {Event} event A standard DOM event object.
  181. * @private
  182. * @async
  183. */
  184. async function onLoadJavaScript(event) {
  185.    var loadedObj = _require.shift(); //important! -- remove current element from array
  186.    var loadedURL = loadedObj.url;
  187.    var loadedTimeStamp = new Date(event.timeStamp);
  188.    console.log (`"${loadedURL}" loaded at ${loadedTimeStamp.getSeconds()}s ${loadedTimeStamp.getMilliseconds()}ms`);
  189.    if (_require.length > 0) {
  190.       loadJavaScript (_require[0].url);
  191.    } else {
  192.       console.log (`All scripts loaded in ${loadedTimeStamp.getSeconds()}s ${loadedTimeStamp.getMilliseconds()}ms`);
  193.    }
  194.    if (typeof loadedObj["onload"] == "function") {
  195.       await loadedObj.onload();
  196.    }
  197. }
  199. /**
  200. * Loads an external JSON data file using XMLHTTPRequest.
  201. *
  202. * @param {String} jsonURL The URL of the JSON data file to load and parse.
  203. *
  204. * @return {XMLHTTPRequest} The XHR instance used to load the data.
  205. * @private
  206. */
  207. function loadJSON(jsonURL) {
  208.    var xhr = new XMLHttpRequest();
  209.    if (_useCache == false) {
  210.       //force new data load
  211.       jsonURL = jsonURL + "?" + String(Math.random()).split("0.")[1];
  212.    }
  213.    xhr.open("GET", jsonURL);
  214.    xhr.overrideMimeType("application/json");
  215.    xhr.responseType = "json";
  216.    xhr.send();
  217.    return (xhr);
  218. }
  220. /**
  221. * Sends an IPC command to the main Electron process if this script is
  222. * running within a desktop (Electron) environment.
  223. *
  224. * @param {String} command The command to send to the main process via IPC.
  225. * @param {*} [data=null] Any accompanying data to include with the <code>command</code>.
  226. * If omitted or <code>null</code>, an empty object is created.
  227. * @param {Boolean} [async=false] Sends the request asynchronously, immediately
  228. * returning a promise instead of the synchronous response object. Synchronous requests
  229. * <code>async=false</code> will block the main thread.
  230. *
  231. * @return {Object|Promise} A reply object is immediately returned if the desktop IPC
  232. * interface is available otherwise <code>null</code> is returned. If <code>async=true</code>,
  233. * a promise is returned instead that resolves with the reply object or rejects with an error.
  234. * The behaiour of the promise matches the behaviour of the synchronous reply.
  235. */
  236. function IPCSend (command, data=null, async=false) {
  237.    if (async == true) {
  238.       var promise = new Promise((resolve, reject) => {
  239.          if (isDesktop()) {
  240.             var request = new Object();
  241.             request.command = command;
  242.             if (data == null) {
  243.                data = new Object();
  244.             }
  245.             request.async = true;
  246.             request.data = data;
  247.             request.data.ipcID = ipcID;
  248.             var responseID = command + ipcID;
  249.             try {
  250.                ipcRenderer.once(responseID, (senderObj, replyObj) => {
  251.                   resolve(replyObj);
  252.                });
  253.                ipcRenderer.send("ipc-main", request);
  254.             } catch (err) {
  255.                reject (err);
  256.             }
  257.          } else {
  258.             resolve (null);
  259.          }
  260.       });
  261.       return (promise);
  262.    } else {
  263.       if (isDesktop()) {
  264.          var request = new Object();
  265.          request.command = command;
  266.          if (data == null) {
  267.             data = new Object();
  268.          }
  269.          request.async = false;
  270.          request.data = data;
  271.          request.data.ipcID = ipcID;
  272.          try {
  273.             return (ipcRenderer.sendSync("ipc-main", request));
  274.          } catch (err) {
  275.             console.error (err.stack);
  276.          }
  277.       } else {
  278.          return (null);
  279.       }
  280.    }
  281. }
  284. /**
  285. * Invoked when an interprocess message is asynchronously received
  286. * from the main process on the "ipc-main" channel. The synchronous IPC response
  287. * will be an object with at least a response <code>type</code> string and some
  288. * <code>data</code>. If this script is not running in a desktop (Electron)
  289. * host environemnt this handler will never be invoked.
  290. *
  291. * @param {Event} event The event being dispatched.
  292. * @param {Object} request The request object. It must contain at least
  293. * a <code>command</string> to process by the handler.
  294. *
  295. * @private
  296. */
  297. function onIPCMessage(event, request) {
  298.    var response = new Object();
  299.    if (request.ipcID != ipcID) {
  300.       //not for this window / child process
  301.       return;
  302.    }
  303.    //be sure not to include any circular references in the response
  304.    //since it will be stringified before being returned...
  305.    switch (request.command) {
  306.       default:
  307.          response.type = "error";
  308.          response.data = new Object();
  309.          response.data.code = -1;
  310.          response.data.message = "Unrecognized IPC request command \""+request.command+"\"";
  311.          break;
  312.    }
  313.    event.returnValue = response; //respond immediately
  314.    //...or respond asynchronously:
  315.    //event.sender.send(request.ipcID, response);
  316. }
  318. /**
  319. * Invoked when a key, or key combination, is pressed on the keyboard.
  320. *
  321. * @param {Event} event The event being dispatched.
  322. * @param {Object} request The request object. It must contain at least
  323. * a <code>command</string> to process by the handler.
  324. *
  325. * @private
  326. */
  327. function onKeyPress(event) {
  328.    const key = event.key;
  329.    var alt = event.altKey;
  330.    var ctrl = event.ctrlKey;
  331.    var shift = event.shiftKey;
  332.    if (isDesktop()) {
  333.       //matches Dev Tools toogle keyboard shortcut in standard browser
  334.       if ((ctrl == true) && (alt == false) && (shift == true) && ((key == "i") || (key == "I"))) {
  335.          //toggle Dev Tools on all open windows:
  336.          // IPCSend("toggle-devtools", {all:true});
  337.          IPCSend("toggle-devtools");
  338.       }
  339.    }
  340. }
  342. /**
  343. * Tests whether or not the host environment is a desktop (Electron) one.
  344. *
  345. * @return {Boolean} True if the host environment is a desktop (Electron) one
  346. * otherwise it's a standard web (browser) host environment.
  347. */
  348. function isDesktop() {
  349.    if ((ipcRenderer != null) && (ipcID != null)) {
  350.       return (true);
  351.    }
  352.    return (false);
  353. }
  355. /**
  356. * Main page load handler; invokes {@link loadJavaScript} with the first
  357. * JavaScript file found in the {@link _requires} array.
  358. * @private
  359. */
  360. onload = function () {
  361.    try {
  362.       //try initializing through Electron IPC
  363.       ipcRenderer = require("electron").ipcRenderer;
  364.       ipcRenderer.on("ipc-main", onIPCMessage); //set IPC message handler
  365.       ipcID = String(Math.random()).split("0.")[1];
  366.       var initData = new Object();
  367.       initData.ipcID = ipcID;
  368.       hostEnv = IPCSend("init", initData).data;
  369.       appVersion = hostEnv.version;
  370.       appName = hostEnv.name;
  371.       appTitle = hostEnv.title;
  372.       console.log ("Desktop (Electron) host environment detected.");
  373.    } catch (err) {
  374.       //probably running in standard browser
  375.       console.log ("Browser (web) host environment detected.");
  376.       ipcRenderer = null;
  377.       hostEnv = null;
  378.       ipcID = null;
  379.    } finally {
  380.       window.addEventListener('keydown', onKeyPress);
  381.    }
  382.    document.title = appTitle;
  383.    loadJavaScript (_require[0].url);
  384. }