/ - Diff - Haketilo - Hydrilla issue tracker

      * IMPORT listen_for_connection
      * IMPORT sha256
      * IMPORT get_query_best
      * IMPORT make_ajax_request
      * IMPORTS_END
      */
-...
     function send_actions(url, port)
+    {
         let [pattern, settings] = query_best(url);
         const [pattern, settings] = query_best(url);
         const repos = storage.get_all(TYPE_PREFIX.REPO);
         port.postMessage(["settings", [pattern, settings]]);
         port.postMessage(["settings", [pattern, settings, repos]]);
         if (settings === undefined)
     	return;
-...
+        }
+    }
     function ajax_callback()
+    {
         if (this.readyState == 4)
     	this.resolve_callback(this);
+    }
     function initiate_ajax_request(resolve, method, url)
+    {
         var xhttp = new XMLHttpRequest();
         xhttp.resolve_callback = resolve;
         xhttp.onreadystatechange = ajax_callback;
         xhttp.open(method, url, true);
         xhttp.send();
+    }
     function make_ajax_request(method, url)
+    {
         return new Promise((resolve, reject) =>
     		       initiate_ajax_request(resolve, method, url));
+    }
     async function fetch_remote_script(script_data)
+    {
         try {

     /**
      * part of Hachette
      * Wrapping XMLHttpRequest into a Promise.
+     *
      * Copyright (C) 2021 Wojtek Kosior
      * Redistribution terms are gathered in the `copyright' file.
      */
     function ajax_callback()
+    {
         if (this.readyState == 4)
     	this.resolve_callback(this);
+    }
     function initiate_ajax_request(resolve, reject, method, url)
+    {
         const xhttp = new XMLHttpRequest();
         xhttp.resolve_callback = resolve;
         xhttp.onreadystatechange = ajax_callback;
         xhttp.open(method, url, true);
         try {
     	xhttp.send();
         } catch(e) {
     	console.log(e);
     	setTimeout(reject, 0);
+        }
+    }
     function make_ajax_request(method, url)
+    {
         return new Promise((resolve, reject) =>
     		       initiate_ajax_request(resolve, reject, method, url));
+    }
     /*
      * EXPORTS_START
      * EXPORT make_ajax_request
      * EXPORTS_END
      */

      * IMPORTS_START
      * IMPORT listen_for_connection
      * IMPORT CONNECTION_TYPE
      * IMPORT set_repo_query_repos
      * IMPORT set_repo_query_callback
      * IMPORTS_END
      */
-...
     function report_settings(settings)
+    {
         const [pattern, settings_data, repos] = settings;
         set_repo_query_repos(repos);
         report_activity("settings", settings);
+    }
     function report_repo_query_result(result)
+    {
         report_activity("repo_query_result", result);
+    }
     function trigger_repo_query()
+    {
         set_repo_query_callback(report_repo_query_result);
+    }
     function new_connection(port)
+    {
         console.log("new activity info connection!");
-...
         for (const activity of activities)
     	port.postMessage(activity);
         /*
          * So far the only thing we expect to receive is repo query order. Once more
          * possibilities arrive, we will need to complicate this listener.
          */
         port.onMessage.addListener(trigger_repo_query);
         port.onDisconnect.addListener(() => ports.delete(port));
+    }
     function start_activity_info_server()

      * IMPORT is_chrome
      * IMPORT is_mozilla
      * IMPORT start_activity_info_server
      * IMPORT set_repo_query_url
      * IMPORTS_END
      */
-...
+        }
         start_activity_info_server();
         set_repo_query_url(document.URL);
+    }

     /**
      * part of Hachette
      * Getting available content for site from remote repositories.
+     *
      * Copyright (C) 2021 Wojtek Kosior
      * Redistribution terms are gathered in the `copyright' file.
      */
     /*
      * IMPORTS_START
      * IMPORT make_ajax_request
      * IMPORTS_END
      */
     var query_started = false;
     var url = undefined;
     var repos = undefined;
     var callback = undefined;
     async function query(repo)
+    {
         const [repo_url, data] = repo;
         let response = "Query failed";
         const query_url = `${repo_url}/query?n=${encodeURIComponent(url)}`;
         try {
     	let xhttp = await make_ajax_request("GET", query_url);
     	if (xhttp.status === 200)
     	    response = xhttp.responseText;
     	console.log(xhttp);
         } catch (e) {
     	console.log(e);
+        }
         callback([repo_url, response]);
+    }
     function start_query()
+    {
         if (query_started || !url || !repos || !callback)
     	return;
         query_started = true;
         console.log(`about to query ${url} from ${repos}`);
         for (const repo of repos)
     	query(repo);
+    }
     function set_repo_query_url(_url)
+    {
         url = _url;
         start_query();
+    }
     function set_repo_query_repos(_repos)
+    {
         repos = _repos;
         start_query();
+    }
     function set_repo_query_callback(_callback)
+    {
         callback = _callback;
         start_query();
+    }
     /*
      * EXPORTS_START
      * EXPORT set_repo_query_url
      * EXPORT set_repo_query_repos
      * EXPORT set_repo_query_callback
      * EXPORTS_END
      */

     	  display: none;
+          }
           .show_hide_next2:not(:checked)+* {
     	  display: none;
+          }
           .show_hide_next2:checked+*+* {
     	  display: none;
+          }
           .hide {
     	  display: none;
+          }
-...
           #container_for_injected>#none_injected:not(:last-child) {
     	  display: none;
+          }
           input#connected_chbx:checked+div+h3 {
     	  display: none;
+          }
         </style>
       </head>
       <body>
-...
           </label>
           <ul id="possible_patterns"></ul>
           <input id="connected_chbx" type="checkbox" class="show_next"></input>
           <input id="connected_chbx" type="checkbox" class="show_hide_next2"></input>
           <div>
     	<h3>
     	  Matched pattern: <span id="pattern">...</span>
     	  <button id="view_pattern" class="hide">
     	  View in settings
     	    View in settings
     	  </button>
     	  <input id="query_started_chbx" type="checkbox" class="show_hide_next2"></input>
     	  <div id="container_for_repo_responses">
     	    <h3>Queried from repositories</h3>
     	  </div>
     	  <button id="query_pattern">
     	    Search for matching patterns
     	  </button>
     	</h3>
     	<h3>

+    }
     const connected_chbx = by_id("connected_chbx");
     const query_pattern_but = by_id("query_pattern");
     function try_to_connect(tab_id)
+    {
-...
         const connect_info = {name: CONNECTION_TYPE.ACTIVITY_INFO, frameId: 0};
         const port = browser.tabs.connect(tab_id, connect_info);
         port.onDisconnect.addListener(port => handle_disconnect(tab_id));
         const button_cb = (e) => start_querying_repos(port);
         port.onDisconnect.addListener(port => handle_disconnect(tab_id, button_cb));
         port.onMessage.addListener(handle_activity_report);
         query_pattern_but.addEventListener("click", button_cb);
         if (is_mozilla)
     	setTimeout(() => monitor_connecting(port, tab_id), 1000);
+    }
     const query_started_chbx = by_id("query_started_chbx");
     function start_querying_repos(port)
+    {
         port.postMessage("dummy (trigger repo querying)");
         query_started_chbx.checked = true;
+    }
     const loading_chbx = by_id("loading_chbx");
     function handle_disconnect(tab_id)
     function handle_disconnect(tab_id, button_cb)
+    {
         query_pattern_but.removeEventListener("click", button_cb);
         if (is_chrome && !browser.runtime.lastError)
     	return;
         /* return if there was no connection initialization failure */
         /* return if error was not during connection initialization */
         if (connected_chbx.checked)
     	return;
-...
     const payload_span = by_id("payload");
     const view_payload_but = by_id("view_payload");
     const container_for_injected = by_id("container_for_injected");
     const container_for_repo_responses = by_id("container_for_repo_responses");
     function handle_activity_report(message)
+    {
-...
         const [type, data] = message;
         if (type === "settings") {
     	let [pattern, settings] = data;
     	let [pattern, settings, repos] = data;
     	settings = settings || {};
     	blocked_span.textContent = settings.allow ? "no" : "yes";
-...
     	container_for_injected.appendChild(h4);
     	container_for_injected.appendChild(pre);
+        }
         if (type === "repo_query_result") {
     	const [repo_url, response_text] = data;
     	const h4 = document.createElement("h4");
     	const pre = document.createElement("pre");
     	h4.textContent = repo_url;
     	pre.textContent = response_text;
     	container_for_repo_responses.appendChild(h4);
     	container_for_repo_responses.appendChild(pre);
+        }
+    }
     by_id("settings_but")

Project

General

Profile

Haketilo

Revision c483ae19

Added by koszko about 2 years ago