+
+ Version: 0.1
+ Author: Alex Nguyen
+ Source Code: https://github.com/alexnguyennz
+
+
+
+
+
+
+
+
+
+
+
+ | Title | +URL | +Refresh Interval | +Block Reloads | +Bypass Cache | +Actions | + + + + +
|---|
+ +
Options
+ +
+
+ Set custom intervals
+Set commonly used interval/reload times. These will appear in the extension icon menu and the context menu.
+
+
+
+
+ Interval One
+ + + + +
+
+ + + + + +
+ Interval Two
+ + + + +
+ + + + + +
+ Interval Three
+ + + + +
+ + + + + +
+ Interval Four
+ + + + +
+ + + + + +
+ Interval Five
+ + + + +
+ + + + + +
+
+ Enable Page Refresher in context menu
+Enable or disable this extension in the context menu (right click).
++ + + + +
+ + + ++ +
+
+
+ Block auto reloading (per tab)
+Stop pages from auto refreshing. This can cause some pages to not function correctly. This option is disabled on pages that block this feature. Turning this option off will reload the tab. +
-
+
- chrome:// +
- chrome-extension:// +
- https://chrome.google.com/webstore/ +
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/public/popup.html b/public/popup.html
new file mode 100644
index 0000000..d59bb31
--- /dev/null
+++ b/public/popup.html
@@ -0,0 +1,51 @@
+
+
+
+
+ Bypass local cache (per tab)
+Bypasses the local cache upon each reload. This ensures you're always browsing the latest version of the page. This option only works with this extension's reloading process.
+
+
+
+
+
+
+
+
+
+
+
+
+ OFF
+
+
+
+
+
+
+
+
+
+ + +
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/public/robots.txt b/public/robots.txt
new file mode 100644
index 0000000..e9e57dc
--- /dev/null
+++ b/public/robots.txt
@@ -0,0 +1,3 @@
+# https://www.robotstxt.org/robotstxt.html
+User-agent: *
+Disallow:
diff --git a/public/src/css/options.css b/public/src/css/options.css
new file mode 100644
index 0000000..2972526
--- /dev/null
+++ b/public/src/css/options.css
@@ -0,0 +1,156 @@
+body {
+ margin: 0 15% 0 15%;
+ font-size: 14px;
+ color: rgb(36, 36, 36);
+}
+
+h2 { text-align: center; }
+
+img {
+ display: block;
+ margin: 0 auto;
+ margin-top: 10px;
+}
+
+p { margin-top: 0; }
+
+button:hover { cursor: pointer; }
+
+hr { border: 2px solid rgb(36, 36, 36); }
+
+#extension-info {
+ text-align: center;
+ margin-bottom: 0;
+}
+
+
+/* *** TABLE *** */
+table {
+ text-align: center;
+ border-collapse: collapse;
+ width: 100%;
+ margin: 0 auto;
+ table-layout: fixed;
+ margin-bottom: 25px;
+}
+
+td {
+ overflow: hidden;
+ text-overflow: ellipsis;
+ white-space: nowrap;
+}
+
+th {
+ overflow: hidden;
+ font-size: 11px;
+}
+
+tr { font-size: 12px; }
+
+tr:hover {
+ background-color: #f2f2f2;
+ transition: 0.1s all;
+}
+
+thead tr:hover {
+ background-color: white;
+ transition: none;
+}
+
+td, th {
+ border: 1px solid #dddddd;
+ padding: 5px;
+}
+
+/* set each individual column width and equal to 100 */
+th:nth-child(1) { width: 35%; }
+th:nth-child(2) { width: 35%; }
+th:nth-child(3) { width: 5%; }
+th:nth-child(4) { width: 5%; }
+th:nth-child(5) { width: 5%; }
+th:nth-child(6) { width: 15%; }
+
+.go-button, .quit-button {
+ width: 35px;
+ height: 25px;
+}
+
+.quit-button { font-size: 11px; } /* correct alignment in cell */
+
+.go-button { margin-right: 5px; }
+
+.go-button:after { content: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAYAAACNMs+9AAAAQElEQVR42qXKwQkAIAxDUUdxtO6/RBQkQZvSi8I/pL4BoGw/XPkh4XigPmsUgh0626AjRsgxHTkUThsG2T/sIlzdTsp52kSS1wAAAABJRU5ErkJggg==); }
+
+
+/* *** OPTIONS *** */
+input[type=number] {
+ width: 90%;
+ padding: 10px;
+ box-sizing: border-box;
+}
+
+.grid-container {
+ display: grid;
+ grid-template-columns: minmax(auto, 20%) minmax(auto, 20%) minmax(auto, 20%) minmax(auto, 20%) minmax(auto, 20%);
+ gap: 10px;
+}
+
+.grid-item {
+ display: grid;
+ grid-template-columns: 50% 50%;
+ padding: 10px;
+ border: 1px solid rgb(104, 104, 104);
+ box-sizing: border-box;
+}
+
+details { margin-top: 20px; }
+
+details > summary {
+ font-size: 16px;
+ font-weight: bold;
+}
+
+details > p { margin-left: 18px; }
+
+summary {
+ display: inline-block;
+ letter-spacing: -0.5px;
+}
+
+summary:hover {
+ cursor: pointer;
+ text-decoration: underline;
+}
+
+summary:focus { outline: none; }
+
+.submit-buttons { margin-bottom: 25px; }
+
+.submit-buttons button { padding: 7px; }
+
+.blocked-urls:after {
+ color: red;
+ content: "*";
+ font-weight: bold;
+}
+
+.right-align { text-align: right; }
+
+#message {
+ font-weight: bold;
+ color: rgb(45, 167, 66);
+}
+
+#context-enabled { margin-left: 0; }
+
+
+/* VIEWPORTS */
+@media only screen and (max-width: 900px) {
+ input::-webkit-outer-spin-button,
+ input::-webkit-inner-spin-button {
+ -webkit-appearance: none;
+ margin: 0;
+ }
+
+ input[type=number] { padding: 0; }
+}
diff --git a/public/src/css/popup.css b/public/src/css/popup.css
new file mode 100644
index 0000000..afc90c6
--- /dev/null
+++ b/public/src/css/popup.css
@@ -0,0 +1,97 @@
+.interval-block { column-count: 2; }
+
+.custom-intervals { column-count: 5; }
+
+.custom-intervals input { margin-left: 10px; }
+
+.custom-intervals label { margin-left: 5px; }
+
+input[type=number] {
+ width: 75px;
+ padding: 10px;
+}
+
+
+/* *** TOGGLE *** */
+.knobs, .layer {
+ position: absolute;
+ top: 0;
+ right: 0;
+ bottom: 0;
+ left: 0;
+}
+
+.knobs { z-index: 2; }
+
+#reload-toggle {
+ position: relative;
+ top: 10px;
+ width: 210px;
+ height: 30px;
+ overflow: hidden;
+ border-radius: 2px;
+ background-color: #fcebeb;
+ z-index: 1;
+ border: 1px solid #5e5e5e;
+ box-sizing: border-box;
+ margin-bottom: 15px;
+}
+
+#reload-toggle #option {
+ cursor: pointer;
+ z-index: 3;
+ opacity: 0;
+ position: relative;
+ width: 100%;
+ height: 100%;
+}
+
+#reload-toggle .knobs:before, #reload-toggle .knobs:after, #reload-toggle .knobs span {
+ position: absolute;
+ width: 97px;
+ height: 10px;
+ font-size: 10px;
+ font-weight: 800;
+ text-align: center;
+ line-height: 1;
+ padding: 9px 4px;
+}
+
+#reload-toggle .knobs:before {
+ content: '';
+ background-color: #F44336;
+ left: 0px;
+}
+
+#reload-toggle .knobs:after {
+ content: 'ON';
+ color: #4e4e4e;
+ right: 4px;
+}
+
+#reload-toggle .knobs span {
+ color: #fff;
+ left: 4px;
+ z-index: 1;
+}
+
+#reload-toggle #option:checked + .knobs span { color: #4e4e4e; }
+
+#reload-toggle #option:checked + .knobs:before {
+ left: 105px;
+ background-color: #03A9F4;
+}
+
+#reload-toggle #option:checked + .knobs:after { color: #fff; }
+
+#reload-toggle #option:checked ~ .layer { background-color: #ebf7fc; }
+/* *** END TOGGLE *** */
+
+hr { margin-bottom: 4px; }
+
+#option-link {
+ float: right;
+ background-image: url('data:image/svg+xml;utf8,');
+ width: 16px;
+ height: 16px;
+}
\ No newline at end of file
diff --git a/public/src/img/banner-src.png b/public/src/img/banner-src.png
new file mode 100644
index 0000000..213e485
Binary files /dev/null and b/public/src/img/banner-src.png differ
diff --git a/public/src/img/banner.png b/public/src/img/banner.png
new file mode 100644
index 0000000..2921529
Binary files /dev/null and b/public/src/img/banner.png differ
diff --git a/public/src/img/cog.svg b/public/src/img/cog.svg
new file mode 100644
index 0000000..fb5bd35
--- /dev/null
+++ b/public/src/img/cog.svg
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/public/src/img/logo-128.png b/public/src/img/logo-128.png
new file mode 100644
index 0000000..be8ffbc
Binary files /dev/null and b/public/src/img/logo-128.png differ
diff --git a/public/src/img/logo-16.png b/public/src/img/logo-16.png
new file mode 100644
index 0000000..3e801d6
Binary files /dev/null and b/public/src/img/logo-16.png differ
diff --git a/public/src/img/logo-48.png b/public/src/img/logo-48.png
new file mode 100644
index 0000000..4b4b479
Binary files /dev/null and b/public/src/img/logo-48.png differ
diff --git a/public/src/js/background.js b/public/src/js/background.js
new file mode 100644
index 0000000..937ecce
--- /dev/null
+++ b/public/src/js/background.js
@@ -0,0 +1,319 @@
+// *************** //
+// *** IMPORTS *** //
+// *************** //
+import { getTimeFormat } from "./global.js";
+
+
+// ********************** //
+// *** INITIALIZATION *** //
+// ********************** //
+
+// *** Set default storage options if none are saved already. *** //
+chrome.storage.sync.get({enableContext: false, intervalOne: 5, intervalTwo: 15, intervalThree: 30, intervalFour: 60, intervalFive: 120}, items => {
+
+ chrome.storage.sync.set(items);
+ if (items.enableContext === true) addContextMenu(); // set context menu to open initially on extension reload
+});
+
+
+let tabIDList = {}; // *** Store all running reloads in an object using each tab's ID along with their properties. *** //
+
+getInitialTabState();
+
+
+// ************************* //
+// *** CHROME TAB EVENTS *** //
+// ************************* //
+
+// *** For newly created tabs, create a new tab object for it in the tabIDList. *** //
+chrome.tabs.onCreated.addListener(tab => createTabObject(tab));
+
+
+// *** When the active tab is changed, change the context enable checkbox to true or false depending on whether a reload exists for that tab. *** //
+chrome.tabs.onActivated.addListener(tab => {
+ updateContextState(tab.tabId);
+});
+
+
+// *** Listen for any tabs that are reloaded and set badge text and colour after a tab reload/change since badge changes reset after a tab change. *** //
+chrome.tabs.onUpdated.addListener((tabID, changeInfo) => {
+
+ setBadge(tabID);
+
+ if (tabIDList[tabID]["blockReload"] === true) blockReload(tabID, true); // continue to inject the window.stop code upon a reload if the state remains true
+
+ if (changeInfo.title) tabIDList[tabID]["tabTitle"] = changeInfo.title; // if title and/or URL has changed, update the tabIDList entry
+ if (changeInfo.url) tabIDList[tabID]["tabURL"] = changeInfo.url;
+
+ chrome.runtime.sendMessage({greeting: "loadRows"});
+});
+
+
+// *** Listen for any tabs that are closed and if a reload exists for it, delete it. *** //
+chrome.tabs.onRemoved.addListener(tabID => {
+
+ if (tabIDList[tabID].hasOwnProperty("reloadInfo")) {
+ clearInterval(tabIDList[tabID]["reloadInfo"]["intervalID"]);
+ clearInterval(tabIDList[tabID]["reloadInfo"]["timeLeftID"]);
+ }
+
+ delete tabIDList[tabID];
+
+ chrome.runtime.sendMessage({greeting: "loadRows"});
+});
+
+
+// *** Set up context menu's onClicked event listeners. *** //
+chrome.runtime.onInstalled.addListener(() => {
+
+ chrome.storage.sync.get(["intervalOne", "intervalTwo", "intervalThree", "intervalFour", "intervalFive"], items => {
+
+ contextInterval = items.intervalOne; // initially set interval to intervalOne by default - one radio must be checked
+
+ chrome.contextMenus.onClicked.addListener((info, tab) => {
+
+ // set default state whenever any context item is clicked; delete the current tab's reload and set enableReload checkbox to false
+ chrome.contextMenus.update("enableReload", {checked: false});
+ deleteReload(tab.id);
+
+ switch (info.menuItemId) {
+ case "intervalOne":
+ contextInterval = items.intervalOne;
+ break;
+ case "intervalTwo":
+ contextInterval = items.intervalTwo;
+ break;
+ case "intervalThree":
+ contextInterval = items.intervalThree;
+ break;
+ case "intervalFour":
+ contextInterval = items.intervalFour;
+ break;
+ case "intervalFive":
+ contextInterval = items.intervalFive;
+ break;
+ case "enableReload":
+ (info.checked ? createReload(contextInterval) : deleteReload(tab.id));
+ break;
+
+ }
+ });
+ });
+});
+
+
+// *********************** //
+// *** CHROME MESSAGES *** //
+// *********************** //
+
+// *** Listen for any messages from other pages. *** //
+chrome.runtime.onMessage.addListener(function(request, sender, sendResponse) {
+
+ switch(request.greeting) {
+ case "createReload":
+ createReload(request.interval);
+ break;
+ case "deleteReload":
+ deleteReload(request.tabID);
+ break;
+ case "getTabIDList":
+ chrome.tabs.query({active: true, currentWindow: true, windowType: "normal"}, tab => sendResponse({tabIDList: tabIDList, tabID: tab[0].id, tabURL: tab[0].url}));
+ break;
+ case "blockReload":
+ chrome.tabs.query({active: true, currentWindow: true, windowType: "normal"}, tab => blockReload(tab[0].id, request.state));
+ break;
+ case "bypassCache":
+ bypassCache(request.state);
+ break;
+ case "blockReloadFromOptions":
+ blockReloadFromOptions(request.tabID, request.state);
+ break;
+ case "bypassCacheFromOptions":
+ bypassCacheFromOptions(request.tabID, request.state);
+ break;
+ case "enableContext":
+ addContextMenu();
+ break;
+ case "disableContext":
+ chrome.contextMenus.removeAll();
+ contextMenuLoaded = false;
+ break;
+ }
+
+ return true;
+});
+
+
+// ***************** //
+// *** FUNCTIONS *** //
+// ***************** //
+
+// *** Create Reload. *** //
+function createReload(interval) {
+
+ chrome.tabs.query({active: true, currentWindow: true, windowType: "normal"}, tab => {
+ const tabID = tab[0].id; // store tabID
+
+ if (tabIDList[tabID].hasOwnProperty("reloadInfo") === true) { // reset any reloads; only allow one reload on a tab at one time in case a bug/error runs multiple reloads
+ clearInterval(tabIDList[tabID]["reloadInfo"]["intervalID"]);
+ clearInterval(tabIDList[tabID]["reloadInfo"]["timeLeftID"]);
+ delete tabIDList[tabID]["reloadInfo"];
+ }
+
+ tabIDList[tabID]["reloadInfo"] = {};
+
+ tabIDList[tabID]["reloadInfo"]["interval"] = interval;
+ tabIDList[tabID]["reloadInfo"]["timeLeft"] = interval;
+
+ setBadge(tabID); // set badge to display time left
+
+ const intervalID = setInterval(() => reloadTab(tabID), interval * 1000); // run a reload using the current active tab ID, store intervalID
+
+ const timeLeftID = setInterval(() => {
+ tabIDList[tabID]["reloadInfo"]["timeLeft"]--;
+
+ if (tabIDList[tabID]["reloadInfo"]["timeLeft"] === 0) tabIDList[tabID]["reloadInfo"]["timeLeft"] = interval;
+
+ setBadge(tabID); // update badge text with currenttime left
+ }, 1000);
+
+ tabIDList[tabID]["reloadInfo"]["intervalID"] = intervalID;
+ tabIDList[tabID]["reloadInfo"]["timeLeftID"] = timeLeftID;
+
+ updateContextState(tabID);
+
+ chrome.runtime.sendMessage({greeting: "loadRows"});
+ });
+}
+
+
+// *** Reload tab functionality. *** //
+function reloadTab(tabID) {
+
+ (tabIDList[tabID]["bypassCache"] ? chrome.tabs.reload(tabID, { bypassCache: true }) : chrome.tabs.reload(tabID));
+}
+
+
+// *** Delete both reloads using clearInterval. *** //
+function deleteReload(tabID) {
+
+ if (tabIDList[tabID].hasOwnProperty("reloadInfo") === true) {
+ clearInterval(tabIDList[tabID]["reloadInfo"]["intervalID"]);
+ clearInterval(tabIDList[tabID]["reloadInfo"]["timeLeftID"]);
+
+ chrome.browserAction.setBadgeText({tabId: tabID, text: ""}); // reset badge text if reload is turned off
+
+ delete tabIDList[tabID]["reloadInfo"];
+
+ updateContextState(tabID);
+
+ chrome.runtime.sendMessage({greeting: "loadRows"});
+ }
+}
+
+
+// *** Set time left in reload to badge text, badge colour, and extension title. *** //
+function setBadge(tabID) {
+
+ if (tabIDList[tabID].hasOwnProperty("reloadInfo") === true) {
+ const formattedTimeLeft = getTimeFormat(tabIDList[tabID]["reloadInfo"]["timeLeft"]); // store formatted times (1:00) from tabIDList object
+
+ chrome.browserAction.setBadgeBackgroundColor({tabId: tabID, color: "#ff6c52"});
+ chrome.browserAction.setBadgeText({tabId: tabID, text: formattedTimeLeft});
+ }
+
+}
+
+
+// *** Get initial tab state of all current tabs. *** //
+function getInitialTabState() {
+
+ chrome.tabs.query({}, tabs => tabs.forEach(tab => createTabObject(tab)));
+}
+
+
+// *** Create a new tab object inside the tabIDList. *** //
+function createTabObject(tab) {
+
+ const tabID = tab.id;
+
+ tabIDList[tabID] = {};
+ tabIDList[tabID]["tabTitle"] = tab.title;
+ tabIDList[tabID]["tabURL"] = tab.url;
+ tabIDList[tabID]["blockReload"] = false;
+ tabIDList[tabID]["bypassCache"] = false;
+}
+
+
+// *** Block meta refreshes and automatic reloads. *** //
+function blockReload(tabID, state) {
+
+ tabIDList[tabID]["blockReload"] = state;
+
+ (tabIDList[tabID]["blockReload"] === true ? chrome.tabs.executeScript(tabID, { code: "window.stop();" }) : chrome.tabs.reload(tabID));
+
+ chrome.runtime.sendMessage({greeting: "loadRows"});
+}
+
+
+// *** Bypass local cache. *** //
+function bypassCache(state) {
+ chrome.tabs.query({active: true, currentWindow: true, windowType: "normal"}, tab => {
+ const tabID = tab[0].id;
+
+ tabIDList[tabID]["bypassCache"] = state;
+
+ chrome.runtime.sendMessage({greeting: "loadRows"});
+ });
+}
+
+
+// *** Block meta refreshes and automatic reloads. *** //
+function blockReloadFromOptions(tabID, state) {
+
+ tabIDList[tabID]["blockReload"] = state;
+ (tabIDList[tabID]["blockReload"] ? chrome.tabs.executeScript(tabID, { code: "window.stop();" }) : chrome.tabs.reload(tabID));
+}
+
+
+// *** Bypass local cache. *** //
+function bypassCacheFromOptions(tabID, state) {
+ tabIDList[tabID]["bypassCache"] = state;
+}
+
+
+let contextMenuLoaded = false; // track context menu state (on or off); set to false by default
+let contextInterval; // track state of context interval value
+
+// *** Remove any existing context menu and create context menu. *** //
+function addContextMenu() {
+
+ chrome.contextMenus.removeAll(() => {
+ chrome.storage.sync.get(["intervalOne", "intervalTwo", "intervalThree", "intervalFour", "intervalFive"], items => {
+
+ contextInterval = items.intervalOne;
+
+ const definedIntervals = { intervalOne: items.intervalOne, intervalTwo: items.intervalTwo, intervalThree: items.intervalThree, intervalFour: items.intervalFour, intervalFive: items.intervalFive };
+
+ chrome.contextMenus.create({ "contexts": ["page"], "id": "contextParent", "title": "Page Refresher" });
+ chrome.contextMenus.create({ "type": "checkbox", "parentId": "contextParent", "id": "enableReload", "title": "Enable" });
+
+ contextMenuLoaded = true;
+
+ for (const [key, value] of Object.entries(definedIntervals)) {
+ chrome.contextMenus.create({ "type": "radio", "parentId": "contextParent", "id": key, "title": getTimeFormat(value) });
+ }
+
+ chrome.tabs.query({active: true, currentWindow: true, windowType: "normal"}, tab => updateContextState(tab[0].id));
+ });
+ });
+}
+
+
+// *** Updates the checked status of the enableReload context menu based on the reload state for that tab. *** //
+function updateContextState(tabID) {
+
+ if (contextMenuLoaded === true) {
+ (tabIDList[tabID].hasOwnProperty("reloadInfo") ? chrome.contextMenus.update("enableReload", { "checked": true }) : chrome.contextMenus.update("enableReload", { "checked": false }));
+ }
+}
diff --git a/public/src/js/global.js b/public/src/js/global.js
new file mode 100644
index 0000000..ee0982a
--- /dev/null
+++ b/public/src/js/global.js
@@ -0,0 +1,28 @@
+// *** getElementById shorthand. *** //
+export function $(id) {
+ return document.getElementById(id);
+}
+
+
+// *** Convert total seconds into a 00:00 time format. *** //
+export function getTimeFormat(totalSeconds) {
+
+ const minutes = Math.trunc(totalSeconds / 60); // divide by 60 and remove all decimals
+ let seconds = totalSeconds % 60; // use remainder as seconds
+
+ if (seconds < 10) seconds = "0" + seconds; // if seconds is lower than 10, add 0 e.g. 05; otherwise leave as normal
+
+ const formattedTime = minutes + ":" + seconds;
+
+ return formattedTime;
+}
+
+
+// *** Check if the URL matches a forbidden one, and disable the relevant checkbox. *** //
+export function urlCheck(tabURL, elementID) {
+
+ const urlArray = ["chrome://", "chrome-extension://", "https://chrome.google.com/webstore"];
+ const check = urlArray.some(el => tabURL.includes(el));
+
+ (check ? $(elementID).disabled = true: $(elementID).disabled = false);
+}
\ No newline at end of file
diff --git a/public/src/js/options.js b/public/src/js/options.js
new file mode 100644
index 0000000..e38dfbb
--- /dev/null
+++ b/public/src/js/options.js
@@ -0,0 +1,254 @@
+// *************** //
+// *** IMPORTS *** //
+// *************** //
+import { $, getTimeFormat, urlCheck } from "./global.js";
+
+
+// ********************** //
+// *** INITIALIZATION *** //
+// ********************** //
+document.addEventListener('DOMContentLoaded', () => {
+
+ loadRows();
+ updateOptionStates();
+
+ $("display-all-tabs").addEventListener("click", () => loadRows());
+
+ // EVENT LISTENERS
+ $("save-options").addEventListener("click", saveOptions);
+ $("reset-options").addEventListener("click", resetOptions);
+
+ document.getElementsByName("interval").forEach(item => item.addEventListener("click", event => event.target.select()) ); // auto select values in interval fields
+});
+
+
+// *** Reset or reload table rows upon reload creation/removal, tab deletion. *** //
+chrome.runtime.onMessage.addListener(function(request, sender, sendResponse) {
+ if (request.greeting === "loadRows") loadRows();
+
+ return true;
+});
+
+
+// *** Load tab information into individual rows with options (as buttons). *** //
+function loadRows() {
+
+ const table = $("reload-table").getElementsByTagName("tbody")[0];
+ const displayAllTabs = $("display-all-tabs");
+
+ chrome.runtime.sendMessage({greeting: "getTabIDList"}, response => {
+ table.innerHTML = ""; // reset all table information that has been loaded in previously
+
+ const tabIDList = response.tabIDList;
+
+ if (displayAllTabs.checked === false) {
+
+ if (reloadsExist(tabIDList) === true) {
+
+ for (const tabID in tabIDList) {
+ if (tabIDList[tabID].hasOwnProperty("reloadInfo") === true) { // only display tab info if it has a reload
+ const row = table.insertRow();
+
+ let formattedTitle = tabIDList[tabID]["tabTitle"];
+ let formattedURL = tabIDList[tabID]["tabURL"];
+
+ if (tabIDList[tabID]["tabTitle"].length >= 75) formattedTitle = tabIDList[tabID]["tabTitle"].substr(0, 75) + "..."; // add ... to the end of a long URL
+ if (tabIDList[tabID]["tabURL"].length >= 75) formattedURL = tabIDList[tabID]["tabURL"].substr(0, 75) + "..."; // add ... to the end of a long URL
+
+ // insert each desired property into an individual cell; use createTextNode to escape HTML characters e.g. for elements so that they don't display
+ row.insertCell(-1).appendChild(document.createTextNode(formattedTitle));
+ row.insertCell(-1).appendChild(document.createTextNode(formattedURL));
+ row.insertCell(-1).appendChild(document.createTextNode(getTimeFormat(tabIDList[tabID]["reloadInfo"]["interval"])));
+ row.insertCell(-1).innerHTML = '';
+ row.insertCell(-1).innerHTML = '';
+ row.insertCell(-1).innerHTML = '' +
+ '';
+
+ // check checkboxes based on option states
+ (tabIDList[tabID]["blockReload"] ? $(tabID + "-block").checked = true : $(tabID + "-block").checked = false);
+ (tabIDList[tabID]["bypassCache"] ? $(tabID + "-bypass").checked = true : $(tabID + "-bypass").checked = false);
+
+ urlCheck(tabIDList[tabID]["tabURL"], tabID + "-block");
+
+ createTabOptions();
+ }
+ }
+ } else {
+ table.innerHTML = `