visualizer-on-tabs 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 cheminfo
+
+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.

package/README.md

@@ -0,0 +1,113 @@
+# visualizer-on-tabs
+
+Builds a static website that has multiple instances of the visualizer that can communicate with each other.
+
+## CLI usage
+
+```bash
+npx visualizer-on-tabs --config=./config.json --outDir=./out
+```
+
+## Configuration
+
+Example: https://github.com/cheminfo/cheminfo-server-setup/blob/master/doc/on-tabs/config.json
+
+```js
+const config = {
+  // Title of the single page app
+  title: 'My app',
+  // List of default views to load
+  possibleViews: {
+    Home: {
+      url: 'https://couch.cheminfo.org/cheminfo-public/158ef2f0cc85bfc5b4f2d88cff473e83/view.json',
+    },
+  },
+  // Rules on how visualizer view URLs should be rewritten when a tab is opened
+  rewriteRules: [
+    {
+      reg: '^([a-z0-9]+)\\?(.*)$',
+      replace: 'https://couch.cheminfo.org/cheminfo-public/$1/view.json?$2',
+    },
+    {
+      reg: '^[a-z0-9]+$',
+      replace: 'https://couch.cheminfo.org/cheminfo-public/$&/view.json',
+    },
+    {
+      reg: '^[a-z0-9]+/view.json\\?.*',
+      replace: 'https://couch.cheminfo.org/cheminfo-public/$&',
+    },
+  ],
+  // Setting this to true loads all the tabs (in possibleViews) on page load
+  // It is discouraged to do this because loading hidden iframes
+  // lead to layout issues. Especially in Firefox.
+  // When false, only the selected tab is loaded.
+  loadHidden: false,
+  // The visualizer configuration object that will be passed to each visualizer instance
+  visualizerConfig: undefined,
+  // The version of the visualizer to load. By default it 'auto', which uses
+  // the version stored in the loaded view.
+  visualizerVersion: 'auto',
+  // Options passed to `makeVisualizerPage`, see https://github.com/cheminfo/react-visualizer
+  // Respectively `fallbackVersion` and `cdn`.
+  visualizerFallbackVersion: undefined,
+  visualizerCDN: undefined,
+};
+```
+
+## Dev setup
+
+Here is how you can test your changes in the visualizer-on-tabs react app.
+
+### Build the page with a custom configuration
+
+There is a dev configuration in `./dev.json`, which is used by local scripts to build a working visualizer-on-tabs app.
+
+To build in dev mode with automatic rebuild, run:
+
+```bash
+npm run build:dev
+```
+
+To test the production build, run:
+
+```bash
+npm run build
+```
+
+To serve the files produced by the build, run:
+
+```bash
+npm run serve
+```
+
+## Install and configure visualizer-on-tabs
+
+### Configure a flavor to deploy on-tabs
+
+Edit the `flavorLayouts`(/usr/local/flavor-builder/config.json) to specify a deployment method for your flavor. For this, you need to add a new entry which key is your flavor name and value is `visualizer-on-tabs`. Example:
+
+```
+...
+"flavorLayouts": {
+    "720p": "minimal-simple-menu",
+    "myflavor":"visualizer-on-tabs"
+  }
+  ...
+```
+
+Add a new rewriteRule
+
+```
+"visualizerOnTabs": {
+    "_default": {
+      "rocLogin": {
+        "url": "https://myloginserver"
+      },
+      "rewriteRules": [
+        {"reg": "^[^/]+$", "replace": "http://myserver.org/rest-on-couch/db/visualizer/$&/view.json"}
+      ]
+    }
+    ...
+```
+
+You would need to edit a view in this flavor, or launch the build manually with the `--forceUpdate` option.

package/bin/build.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+
+/* eslint-disable no-console */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+
+import minimist from 'minimist';
+
+import build from '../main/index.js';
+
+const argv = minimist(process.argv.slice(2));
+
+if (!argv.outDir) {
+  console.log(`CLI args:
+    --outDir - output directory (required)
+    --dev - development mode with file watching
+    --config - path to JSON config file
+  `);
+  throw new Error('The --outDir option is required.');
+}
+
+const mode = argv.dev ? 'development' : 'production';
+const watch = !!argv.dev;
+const outDir = argv.outDir;
+let config = {};
+if (argv.config) {
+  const configFile = path.resolve(argv.config);
+  config = JSON.parse(fs.readFileSync(configFile, 'utf8'));
+}
+
+const cleanup = await build({ mode, watch, outDir, config });
+
+process.on('SIGINT', async () => {
+  console.log('Build cancelled on SIGINT');
+  cleanup().catch(console.error);
+  process.exit(1);
+});

package/main/iframe-bridge.js

@@ -0,0 +1,8 @@
+// v1.0.0 taken from http://www.lactame.com/lib/iframe-bridge/HEAD/iframe-bridge.js on 2016-12-19
+// Conversion to base64 with http://decodebase64.com/
+// Added //# sourceURL=iframe-bridge-browser.js at the end of the file to help developer tools
+const iframeBridge =
+  'data:application/javascript;base64,' +
+  '/**
 * iframe-bridge - Communicate between iframes and a control page
 * @version v1.0.0
 * @link https://github.com/cheminfo-js/iframe-bridge
 * @license MIT
 */
(function webpackUniversalModuleDefinition(root, factory) {
	if(typeof exports === 'object' && typeof module === 'object')
		module.exports = factory();
	else if(typeof define === 'function' && define.amd)
		define([], factory);
	else if(typeof exports === 'object')
		exports["IframeBridge"] = factory();
	else
		root["IframeBridge"] = factory();
})(this, function() {
return /******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};
/******/
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/
/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId]) {
/******/ 			return installedModules[moduleId].exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			i: moduleId,
/******/ 			l: false,
/******/ 			exports: {}
/******/ 		};
/******/
/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ 		// Flag the module as loaded
/******/ 		module.l = true;
/******/
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/
/******/
/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;
/******/
/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;
/******/
/******/ 	// define getter function for harmony exports
/******/ 	__webpack_require__.d = function(exports, name, getter) {
/******/ 		if(!__webpack_require__.o(exports, name)) {
/******/ 			Object.defineProperty(exports, name, {
/******/ 				configurable: false,
/******/ 				enumerable: true,
/******/ 				get: getter
/******/ 			});
/******/ 		}
/******/ 	};
/******/
/******/ 	// getDefaultExport function for compatibility with non-harmony modules
/******/ 	__webpack_require__.n = function(module) {
/******/ 		var getter = module && module.__esModule ?
/******/ 			function getDefault() { return module['default']; } :
/******/ 			function getModuleExports() { return module; };
/******/ 		__webpack_require__.d(getter, 'a', getter);
/******/ 		return getter;
/******/ 	};
/******/
/******/ 	// Object.prototype.hasOwnProperty.call
/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";
/******/
/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(__webpack_require__.s = 1);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


// Copyright Joyent, Inc. and other Node contributors.
//
// 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.

function EventEmitter() {
  this._events = this._events || {};
  this._maxListeners = this._maxListeners || undefined;
}
module.exports = EventEmitter;

// Backwards-compat with node 0.10.x
EventEmitter.EventEmitter = EventEmitter;

EventEmitter.prototype._events = undefined;
EventEmitter.prototype._maxListeners = undefined;

// By default EventEmitters will print a warning if more than 10 listeners are
// added to it. This is a useful default which helps finding memory leaks.
EventEmitter.defaultMaxListeners = 10;

// Obviously not all Emitters should be limited to 10. This function allows
// that to be increased. Set to zero for unlimited.
EventEmitter.prototype.setMaxListeners = function (n) {
  if (!isNumber(n) || n < 0 || isNaN(n)) throw TypeError('n must be a positive number');
  this._maxListeners = n;
  return this;
};

EventEmitter.prototype.emit = function (type) {
  var er, handler, len, args, i, listeners;

  if (!this._events) this._events = {};

  // If there is no 'error' event listener then throw.
  if (type === 'error') {
    if (!this._events.error || isObject(this._events.error) && !this._events.error.length) {
      er = arguments[1];
      if (er instanceof Error) {
        throw er; // Unhandled 'error' event
      } else {
        // At least give some kind of context to the user
        var err = new Error('Uncaught, unspecified "error" event. (' + er + ')');
        err.context = er;
        throw err;
      }
    }
  }

  handler = this._events[type];

  if (isUndefined(handler)) return false;

  if (isFunction(handler)) {
    switch (arguments.length) {
      // fast cases
      case 1:
        handler.call(this);
        break;
      case 2:
        handler.call(this, arguments[1]);
        break;
      case 3:
        handler.call(this, arguments[1], arguments[2]);
        break;
      // slower
      default:
        args = Array.prototype.slice.call(arguments, 1);
        handler.apply(this, args);
    }
  } else if (isObject(handler)) {
    args = Array.prototype.slice.call(arguments, 1);
    listeners = handler.slice();
    len = listeners.length;
    for (i = 0; i < len; i++) {
      listeners[i].apply(this, args);
    }
  }

  return true;
};

EventEmitter.prototype.addListener = function (type, listener) {
  var m;

  if (!isFunction(listener)) throw TypeError('listener must be a function');

  if (!this._events) this._events = {};

  // To avoid recursion in the case that type === "newListener"! Before
  // adding it to the listeners, first emit "newListener".
  if (this._events.newListener) this.emit('newListener', type, isFunction(listener.listener) ? listener.listener : listener);

  if (!this._events[type])
    // Optimize the case of one listener. Don't need the extra array object.
    this._events[type] = listener;else if (isObject(this._events[type]))
    // If we've already got an array, just append.
    this._events[type].push(listener);else
    // Adding the second element, need to change to array.
    this._events[type] = [this._events[type], listener];

  // Check for listener leak
  if (isObject(this._events[type]) && !this._events[type].warned) {
    if (!isUndefined(this._maxListeners)) {
      m = this._maxListeners;
    } else {
      m = EventEmitter.defaultMaxListeners;
    }

    if (m && m > 0 && this._events[type].length > m) {
      this._events[type].warned = true;
      console.error('(node) warning: possible EventEmitter memory ' + 'leak detected. %d listeners added. ' + 'Use emitter.setMaxListeners() to increase limit.', this._events[type].length);
      if (typeof console.trace === 'function') {
        // not supported in IE 10
        console.trace();
      }
    }
  }

  return this;
};

EventEmitter.prototype.on = EventEmitter.prototype.addListener;

EventEmitter.prototype.once = function (type, listener) {
  if (!isFunction(listener)) throw TypeError('listener must be a function');

  var fired = false;

  function g() {
    this.removeListener(type, g);

    if (!fired) {
      fired = true;
      listener.apply(this, arguments);
    }
  }

  g.listener = listener;
  this.on(type, g);

  return this;
};

// emits a 'removeListener' event iff the listener was removed
EventEmitter.prototype.removeListener = function (type, listener) {
  var list, position, length, i;

  if (!isFunction(listener)) throw TypeError('listener must be a function');

  if (!this._events || !this._events[type]) return this;

  list = this._events[type];
  length = list.length;
  position = -1;

  if (list === listener || isFunction(list.listener) && list.listener === listener) {
    delete this._events[type];
    if (this._events.removeListener) this.emit('removeListener', type, listener);
  } else if (isObject(list)) {
    for (i = length; i-- > 0;) {
      if (list[i] === listener || list[i].listener && list[i].listener === listener) {
        position = i;
        break;
      }
    }

    if (position < 0) return this;

    if (list.length === 1) {
      list.length = 0;
      delete this._events[type];
    } else {
      list.splice(position, 1);
    }

    if (this._events.removeListener) this.emit('removeListener', type, listener);
  }

  return this;
};

EventEmitter.prototype.removeAllListeners = function (type) {
  var key, listeners;

  if (!this._events) return this;

  // not listening for removeListener, no need to emit
  if (!this._events.removeListener) {
    if (arguments.length === 0) this._events = {};else if (this._events[type]) delete this._events[type];
    return this;
  }

  // emit removeListener for all listeners on all events
  if (arguments.length === 0) {
    for (key in this._events) {
      if (key === 'removeListener') continue;
      this.removeAllListeners(key);
    }
    this.removeAllListeners('removeListener');
    this._events = {};
    return this;
  }

  listeners = this._events[type];

  if (isFunction(listeners)) {
    this.removeListener(type, listeners);
  } else if (listeners) {
    // LIFO order
    while (listeners.length) {
      this.removeListener(type, listeners[listeners.length - 1]);
    }
  }
  delete this._events[type];

  return this;
};

EventEmitter.prototype.listeners = function (type) {
  var ret;
  if (!this._events || !this._events[type]) ret = [];else if (isFunction(this._events[type])) ret = [this._events[type]];else ret = this._events[type].slice();
  return ret;
};

EventEmitter.prototype.listenerCount = function (type) {
  if (this._events) {
    var evlistener = this._events[type];

    if (isFunction(evlistener)) return 1;else if (evlistener) return evlistener.length;
  }
  return 0;
};

EventEmitter.listenerCount = function (emitter, type) {
  return emitter.listenerCount(type);
};

function isFunction(arg) {
  return typeof arg === 'function';
}

function isNumber(arg) {
  return typeof arg === 'number';
}

function isObject(arg) {
  return typeof arg === 'object' && arg !== null;
}

function isUndefined(arg) {
  return arg === void 0;
}

/***/ }),
/* 1 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var debug = __webpack_require__(2)('iframe-bridge:iframe');
var MessageHandler = __webpack_require__(6);

var messageHandler = new MessageHandler();

messageHandler.init(window.parent);
window.addEventListener('message', function (event) {
    try {
        var data = JSON.parse(event.data);
        debug('message received', data);
        messageHandler.handleMessage(data);
    } catch (e) {}
});

exports.postMessage = function (type, message) {
    return messageHandler.postMessage(type, message);
};

exports.onMessage = function (cb) {
    messageHandler.on('message', cb);
};

exports.ready = function () {
    messageHandler.handlePendingMessages();
};

/***/ }),
/* 2 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

/**
 * This is the web browser implementation of `debug()`.
 *
 * Expose `debug()` as the module.
 */

exports = module.exports = __webpack_require__(4);
exports.log = log;
exports.formatArgs = formatArgs;
exports.save = save;
exports.load = load;
exports.useColors = useColors;
exports.storage = 'undefined' != typeof chrome && 'undefined' != typeof chrome.storage ? chrome.storage.local : localstorage();

/**
 * Colors.
 */

exports.colors = ['lightseagreen', 'forestgreen', 'goldenrod', 'dodgerblue', 'darkorchid', 'crimson'];

/**
 * Currently only WebKit-based Web Inspectors, Firefox >= v31,
 * and the Firebug extension (any Firefox version) are known
 * to support "%c" CSS customizations.
 *
 * TODO: add a `localStorage` variable to explicitly enable/disable colors
 */

function useColors() {
  // NB: In an Electron preload script, document will be defined but not fully
  // initialized. Since we know we're in Chrome, we'll just detect this case
  // explicitly
  if (typeof window !== 'undefined' && window.process && window.process.type === 'renderer') {
    return true;
  }

  // is webkit? http://stackoverflow.com/a/16459606/376773
  // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
  return typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance ||
  // is firebug? http://stackoverflow.com/a/398120/376773
  typeof window !== 'undefined' && window.console && (window.console.firebug || window.console.exception && window.console.table) ||
  // is firefox >= v31?
  // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
  typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31 ||
  // double check webkit in userAgent just in case we are in a worker
  typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
}

/**
 * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
 */

exports.formatters.j = function (v) {
  try {
    return JSON.stringify(v);
  } catch (err) {
    return '[UnexpectedJSONParseError]: ' + err.message;
  }
};

/**
 * Colorize log arguments if enabled.
 *
 * @api public
 */

function formatArgs(args) {
  var useColors = this.useColors;

  args[0] = (useColors ? '%c' : '') + this.namespace + (useColors ? ' %c' : ' ') + args[0] + (useColors ? '%c ' : ' ') + '+' + exports.humanize(this.diff);

  if (!useColors) return;

  var c = 'color: ' + this.color;
  args.splice(1, 0, c, 'color: inherit');

  // the final "%c" is somewhat tricky, because there could be other
  // arguments passed either before or after the %c, so we need to
  // figure out the correct index to insert the CSS into
  var index = 0;
  var lastC = 0;
  args[0].replace(/%[a-zA-Z%]/g, function (match) {
    if ('%%' === match) return;
    index++;
    if ('%c' === match) {
      // we only are interested in the *last* %c
      // (the user may have provided their own)
      lastC = index;
    }
  });

  args.splice(lastC, 0, c);
}

/**
 * Invokes `console.log()` when available.
 * No-op when `console.log` is not a "function".
 *
 * @api public
 */

function log() {
  // this hackery is required for IE8/9, where
  // the `console.log` function doesn't have 'apply'
  return 'object' === typeof console && console.log && Function.prototype.apply.call(console.log, console, arguments);
}

/**
 * Save `namespaces`.
 *
 * @param {String} namespaces
 * @api private
 */

function save(namespaces) {
  try {
    if (null == namespaces) {
      exports.storage.removeItem('debug');
    } else {
      exports.storage.debug = namespaces;
    }
  } catch (e) {}
}

/**
 * Load `namespaces`.
 *
 * @return {String} returns the previously persisted debug modes
 * @api private
 */

function load() {
  var r;
  try {
    r = exports.storage.debug;
  } catch (e) {}

  // If debug isn't set in LS, and we're in Electron, try to load $DEBUG
  if (!r && typeof process !== 'undefined' && 'env' in process) {
    r = process.env.DEBUG;
  }

  return r;
}

/**
 * Enable namespaces listed in `localStorage.debug` initially.
 */

exports.enable(load());

/**
 * Localstorage attempts to return the localstorage.
 *
 * This is necessary because safari throws
 * when a user disables cookies/localstorage
 * and you attempt to access it.
 *
 * @return {LocalStorage}
 * @api private
 */

function localstorage() {
  try {
    return window.localStorage;
  } catch (e) {}
}
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))

/***/ }),
/* 3 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


// shim for using process in browser
var process = module.exports = {};

// cached from whatever global is present so that test runners that stub it
// don't break things.  But we need to wrap it in a try catch in case it is
// wrapped in strict mode code which doesn't define any globals.  It's inside a
// function because try/catches deoptimize in certain engines.

var cachedSetTimeout;
var cachedClearTimeout;

function defaultSetTimout() {
    throw new Error('setTimeout has not been defined');
}
function defaultClearTimeout() {
    throw new Error('clearTimeout has not been defined');
}
(function () {
    try {
        if (typeof setTimeout === 'function') {
            cachedSetTimeout = setTimeout;
        } else {
            cachedSetTimeout = defaultSetTimout;
        }
    } catch (e) {
        cachedSetTimeout = defaultSetTimout;
    }
    try {
        if (typeof clearTimeout === 'function') {
            cachedClearTimeout = clearTimeout;
        } else {
            cachedClearTimeout = defaultClearTimeout;
        }
    } catch (e) {
        cachedClearTimeout = defaultClearTimeout;
    }
})();
function runTimeout(fun) {
    if (cachedSetTimeout === setTimeout) {
        //normal enviroments in sane situations
        return setTimeout(fun, 0);
    }
    // if setTimeout wasn't available but was latter defined
    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
        cachedSetTimeout = setTimeout;
        return setTimeout(fun, 0);
    }
    try {
        // when when somebody has screwed with setTimeout but no I.E. maddness
        return cachedSetTimeout(fun, 0);
    } catch (e) {
        try {
            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
            return cachedSetTimeout.call(null, fun, 0);
        } catch (e) {
            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
            return cachedSetTimeout.call(this, fun, 0);
        }
    }
}
function runClearTimeout(marker) {
    if (cachedClearTimeout === clearTimeout) {
        //normal enviroments in sane situations
        return clearTimeout(marker);
    }
    // if clearTimeout wasn't available but was latter defined
    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
        cachedClearTimeout = clearTimeout;
        return clearTimeout(marker);
    }
    try {
        // when when somebody has screwed with setTimeout but no I.E. maddness
        return cachedClearTimeout(marker);
    } catch (e) {
        try {
            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
            return cachedClearTimeout.call(null, marker);
        } catch (e) {
            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
            // Some versions of I.E. have different rules for clearTimeout vs setTimeout
            return cachedClearTimeout.call(this, marker);
        }
    }
}
var queue = [];
var draining = false;
var currentQueue;
var queueIndex = -1;

function cleanUpNextTick() {
    if (!draining || !currentQueue) {
        return;
    }
    draining = false;
    if (currentQueue.length) {
        queue = currentQueue.concat(queue);
    } else {
        queueIndex = -1;
    }
    if (queue.length) {
        drainQueue();
    }
}

function drainQueue() {
    if (draining) {
        return;
    }
    var timeout = runTimeout(cleanUpNextTick);
    draining = true;

    var len = queue.length;
    while (len) {
        currentQueue = queue;
        queue = [];
        while (++queueIndex < len) {
            if (currentQueue) {
                currentQueue[queueIndex].run();
            }
        }
        queueIndex = -1;
        len = queue.length;
    }
    currentQueue = null;
    draining = false;
    runClearTimeout(timeout);
}

process.nextTick = function (fun) {
    var args = new Array(arguments.length - 1);
    if (arguments.length > 1) {
        for (var i = 1; i < arguments.length; i++) {
            args[i - 1] = arguments[i];
        }
    }
    queue.push(new Item(fun, args));
    if (queue.length === 1 && !draining) {
        runTimeout(drainQueue);
    }
};

// v8 likes predictible objects
function Item(fun, array) {
    this.fun = fun;
    this.array = array;
}
Item.prototype.run = function () {
    this.fun.apply(null, this.array);
};
process.title = 'browser';
process.browser = true;
process.env = {};
process.argv = [];
process.version = ''; // empty string to avoid regexp issues
process.versions = {};

function noop() {}

process.on = noop;
process.addListener = noop;
process.once = noop;
process.off = noop;
process.removeListener = noop;
process.removeAllListeners = noop;
process.emit = noop;
process.prependListener = noop;
process.prependOnceListener = noop;

process.listeners = function (name) {
    return [];
};

process.binding = function (name) {
    throw new Error('process.binding is not supported');
};

process.cwd = function () {
    return '/';
};
process.chdir = function (dir) {
    throw new Error('process.chdir is not supported');
};
process.umask = function () {
    return 0;
};

/***/ }),
/* 4 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


/**
 * This is the common logic for both the Node.js and web browser
 * implementations of `debug()`.
 *
 * Expose `debug()` as the module.
 */

exports = module.exports = createDebug.debug = createDebug['default'] = createDebug;
exports.coerce = coerce;
exports.disable = disable;
exports.enable = enable;
exports.enabled = enabled;
exports.humanize = __webpack_require__(5);

/**
 * The currently active debug mode names, and names to skip.
 */

exports.names = [];
exports.skips = [];

/**
 * Map of special "%n" handling functions, for the debug "format" argument.
 *
 * Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
 */

exports.formatters = {};

/**
 * Previous log timestamp.
 */

var prevTime;

/**
 * Select a color.
 * @param {String} namespace
 * @return {Number}
 * @api private
 */

function selectColor(namespace) {
  var hash = 0,
      i;

  for (i in namespace) {
    hash = (hash << 5) - hash + namespace.charCodeAt(i);
    hash |= 0; // Convert to 32bit integer
  }

  return exports.colors[Math.abs(hash) % exports.colors.length];
}

/**
 * Create a debugger with the given `namespace`.
 *
 * @param {String} namespace
 * @return {Function}
 * @api public
 */

function createDebug(namespace) {

  function debug() {
    // disabled?
    if (!debug.enabled) return;

    var self = debug;

    // set `diff` timestamp
    var curr = +new Date();
    var ms = curr - (prevTime || curr);
    self.diff = ms;
    self.prev = prevTime;
    self.curr = curr;
    prevTime = curr;

    // turn the `arguments` into a proper Array
    var args = new Array(arguments.length);
    for (var i = 0; i < args.length; i++) {
      args[i] = arguments[i];
    }

    args[0] = exports.coerce(args[0]);

    if ('string' !== typeof args[0]) {
      // anything else let's inspect with %O
      args.unshift('%O');
    }

    // apply any `formatters` transformations
    var index = 0;
    args[0] = args[0].replace(/%([a-zA-Z%])/g, function (match, format) {
      // if we encounter an escaped % then don't increase the array index
      if (match === '%%') return match;
      index++;
      var formatter = exports.formatters[format];
      if ('function' === typeof formatter) {
        var val = args[index];
        match = formatter.call(self, val);

        // now we need to remove `args[index]` since it's inlined in the `format`
        args.splice(index, 1);
        index--;
      }
      return match;
    });

    // apply env-specific formatting (colors, etc.)
    exports.formatArgs.call(self, args);

    var logFn = debug.log || exports.log || console.log.bind(console);
    logFn.apply(self, args);
  }

  debug.namespace = namespace;
  debug.enabled = exports.enabled(namespace);
  debug.useColors = exports.useColors();
  debug.color = selectColor(namespace);

  // env-specific initialization logic for debug instances
  if ('function' === typeof exports.init) {
    exports.init(debug);
  }

  return debug;
}

/**
 * Enables a debug mode by namespaces. This can include modes
 * separated by a colon and wildcards.
 *
 * @param {String} namespaces
 * @api public
 */

function enable(namespaces) {
  exports.save(namespaces);

  exports.names = [];
  exports.skips = [];

  var split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
  var len = split.length;

  for (var i = 0; i < len; i++) {
    if (!split[i]) continue; // ignore empty strings
    namespaces = split[i].replace(/\*/g, '.*?');
    if (namespaces[0] === '-') {
      exports.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));
    } else {
      exports.names.push(new RegExp('^' + namespaces + '$'));
    }
  }
}

/**
 * Disable debug output.
 *
 * @api public
 */

function disable() {
  exports.enable('');
}

/**
 * Returns true if the given mode name is enabled, false otherwise.
 *
 * @param {String} name
 * @return {Boolean}
 * @api public
 */

function enabled(name) {
  var i, len;
  for (i = 0, len = exports.skips.length; i < len; i++) {
    if (exports.skips[i].test(name)) {
      return false;
    }
  }
  for (i = 0, len = exports.names.length; i < len; i++) {
    if (exports.names[i].test(name)) {
      return true;
    }
  }
  return false;
}

/**
 * Coerce `val`.
 *
 * @param {Mixed} val
 * @return {Mixed}
 * @api private
 */

function coerce(val) {
  if (val instanceof Error) return val.stack || val.message;
  return val;
}

/***/ }),
/* 5 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


/**
 * Helpers.
 */

var s = 1000;
var m = s * 60;
var h = m * 60;
var d = h * 24;
var y = d * 365.25;

/**
 * Parse or format the given `val`.
 *
 * Options:
 *
 *  - `long` verbose formatting [false]
 *
 * @param {String|Number} val
 * @param {Object} [options]
 * @throws {Error} throw an error if val is not a non-empty string or a number
 * @return {String|Number}
 * @api public
 */

module.exports = function (val, options) {
  options = options || {};
  var type = typeof val;
  if (type === 'string' && val.length > 0) {
    return parse(val);
  } else if (type === 'number' && isNaN(val) === false) {
    return options.long ? fmtLong(val) : fmtShort(val);
  }
  throw new Error('val is not a non-empty string or a valid number. val=' + JSON.stringify(val));
};

/**
 * Parse the given `str` and return milliseconds.
 *
 * @param {String} str
 * @return {Number}
 * @api private
 */

function parse(str) {
  str = String(str);
  if (str.length > 100) {
    return;
  }
  var match = /^((?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(str);
  if (!match) {
    return;
  }
  var n = parseFloat(match[1]);
  var type = (match[2] || 'ms').toLowerCase();
  switch (type) {
    case 'years':
    case 'year':
    case 'yrs':
    case 'yr':
    case 'y':
      return n * y;
    case 'days':
    case 'day':
    case 'd':
      return n * d;
    case 'hours':
    case 'hour':
    case 'hrs':
    case 'hr':
    case 'h':
      return n * h;
    case 'minutes':
    case 'minute':
    case 'mins':
    case 'min':
    case 'm':
      return n * m;
    case 'seconds':
    case 'second':
    case 'secs':
    case 'sec':
    case 's':
      return n * s;
    case 'milliseconds':
    case 'millisecond':
    case 'msecs':
    case 'msec':
    case 'ms':
      return n;
    default:
      return undefined;
  }
}

/**
 * Short format for `ms`.
 *
 * @param {Number} ms
 * @return {String}
 * @api private
 */

function fmtShort(ms) {
  if (ms >= d) {
    return Math.round(ms / d) + 'd';
  }
  if (ms >= h) {
    return Math.round(ms / h) + 'h';
  }
  if (ms >= m) {
    return Math.round(ms / m) + 'm';
  }
  if (ms >= s) {
    return Math.round(ms / s) + 's';
  }
  return ms + 'ms';
}

/**
 * Long format for `ms`.
 *
 * @param {Number} ms
 * @return {String}
 * @api private
 */

function fmtLong(ms) {
  return plural(ms, d, 'day') || plural(ms, h, 'hour') || plural(ms, m, 'minute') || plural(ms, s, 'second') || ms + ' ms';
}

/**
 * Pluralization helper.
 */

function plural(ms, n, name) {
  if (ms < n) {
    return;
  }
  if (ms < n * 1.5) {
    return Math.floor(ms / n) + ' ' + name;
  }
  return Math.ceil(ms / n) + ' ' + name + 's';
}

/***/ }),
/* 6 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var Message = __webpack_require__(7);

var EventEmitter = __webpack_require__(0);

var idCounter = 0;
var postedMessages = new Map();

class MessageHandler extends EventEmitter {
    constructor() {
        super();
        this.readyToPost = false;
        this.readyToHandle = false;
        this.windowID = null;
        this.messageSource = null;
        this.pendingMessages = [];
        this.unhandledMessages = [];
    }

    _postMessageToSource(message) {
        this.messageSource.postMessage(JSON.stringify(message), '*');
    }

    init(messageSource) {
        this.readyToPost = true;
        this.windowID = Date.now();
        this.messageSource = messageSource;
        this._postMessageToSource({
            type: 'admin.connect',
            windowID: this.windowID
        });

        window.addEventListener('unload', () => {
            this.messageSource.postMessage(JSON.stringify({
                type: 'admin.disconnect',
                windowID: this.windowID
            }), '*');
        });

        this.postPendingMessages();
    }

    postMessage(type, message) {
        var id = ++idCounter;
        var toPost = {
            type,
            message,
            messageID: id,
            windowID: this.windowID
        };
        var theMessage = new Message(id, toPost);
        if (this.readyToPost) {
            this._postMessageToSource(toPost);
            postedMessages.set(id, theMessage);
        } else {
            this.pendingMessages.push(theMessage);
        }
        return theMessage;
    }

    postPendingMessages() {
        for (var message of this.pendingMessages) {
            message.data.windowID = this.windowID;
            this._postMessageToSource(message.data);
            postedMessages.set(message.id, message);
        }
    }

    handlePendingMessages() {
        this.readyToHandle = true;
        for (var i = 0; i < this.unhandledMessages.length; i++) {
            this.handleMessage(this.unhandledMessages[i]);
        }
        this.unhandledMessages = [];
    }

    handleMessage(data) {
        if (!this.readyToHandle) {
            this.unhandledMessages.push(data);
            return;
        }
        if (!postedMessages.has(data.messageID)) {
            return this.emit('message', data);
        }
        var message = postedMessages.get(data.messageID);
        if (data.status) {
            if (data.status === 'error') {
                message._reject(data);
                postedMessages.delete(data.messageID);
            } else if (data.status === 'success') {
                message._resolve(data);
                postedMessages.delete(data.messageID);
            } else {
                message.emit(data.status, data);
            }
        } else {
            // no status is considered a success
            message._resolve(data);
            postedMessages.delete(data.messageID);
        }
    }
}

module.exports = MessageHandler;

/***/ }),
/* 7 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var EventEmitter = __webpack_require__(0).EventEmitter;
var promise = Symbol();

class Message extends EventEmitter {
    constructor(id, data) {
        super();
        this.id = id;
        this.data = data;
        this[promise] = new Promise((resolve, reject) => {
            this._resolve = resolve;
            this._reject = reject;
        });
    }

    then(onResolve, onReject) {
        return this[promise].then(onResolve, onReject);
    }

    catch(onReject) {
        return this[promise].catch(onReject);
    }
}

module.exports = Message;

/***/ })
/******/ ]);
});
//# sourceMappingURL=iframe-bridge.js.map';
+
+export default iframeBridge;

package/main/index.js

@@ -0,0 +1,174 @@
+/* eslint-disable no-console */
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import _ from 'lodash';
+import visualizer from 'react-visualizer';
+import webpack from 'webpack';
+
+import iframeBridge from './iframe-bridge.js';
+
+const __dirname = import.meta.dirname;
+
+const defaultConfig = {
+  title: 'visualizer-on-tabs',
+};
+
+async function buildApp(options, outDir, cleanup) {
+  const { promise, resolve, reject } = Promise.withResolvers();
+  const entries = [{ file: 'app.js' }];
+  for (const entry of entries) {
+    let config = {
+      mode: options.mode === 'development' ? 'development' : 'production',
+      context: path.resolve(__dirname, '../'),
+      entry: path.resolve(__dirname, '../src', entry.file),
+      output: {
+        path: outDir,
+        filename: entry.file,
+      },
+      devtool: 'source-map',
+      module: {
+        rules: [
+          {
+            test: /\.js$/,
+            include: [
+              path.resolve(__dirname, '../src'),
+              path.resolve(__dirname, '../node_modules/iframe-bridge'),
+            ],
+            loader: 'babel-loader',
+            options: {
+              cwd: path.join(__dirname, '..'),
+              presets: ['@babel/env', '@babel/react'],
+            },
+          },
+        ],
+      },
+    };
+
+    function handleError(err, stats) {
+      if (err) {
+        if (options.watch) {
+          console.error(err.stack, err.message);
+        } else {
+          reject(err);
+        }
+      } else {
+        // TODO: use node's util.debuglog here and in flavor-builder
+        const statsJson = stats.toJson();
+
+        if (statsJson.errors.length > 0) {
+          for (let error of statsJson.errors) {
+            console.error(error.message);
+          }
+          if (!options.watch) {
+            reject(
+              new Error(
+                `Build failed with ${statsJson.errors.length} error(s)`,
+              ),
+            );
+          }
+        }
+        if (statsJson.warnings.length > 0) {
+          for (let warning of statsJson.warnings) {
+            console.warn(warning.message);
+          }
+        }
+        console.log(`Build of ${entry.file} successful`);
+        if (!options.watch) {
+          cleanup()
+            .catch(console.error)
+            .then(() => resolve(cleanup));
+        }
+      }
+    }
+    const instance = webpack(config);
+    if (options.watch) {
+      instance.watch({ aggregateTimeout: 200 }, handleError);
+      // In watch mode we resolve before the first build is done.
+      resolve(cleanup);
+    } else {
+      // With a single run, the handler will resolve / reject the promise.
+      instance.run(handleError);
+    }
+  }
+  return promise;
+}
+
+export default async (options) => {
+  Object.assign(options.config, defaultConfig);
+
+  const outDir = path.resolve(options.outDir);
+  await fs.mkdir(outDir, { recursive: true });
+
+  const confPath = path.join(__dirname, '../src/config/custom.json');
+  console.log('Copying files');
+  await Promise.all([
+    fs.writeFile(confPath, JSON.stringify(options.config)),
+    copyBootstrap(options),
+    copyContent(options),
+    addIndex(options),
+    addVisualizer(options),
+  ]);
+
+  async function cleanup() {
+    console.log('Cleaning up');
+    // Normally, the file should exist when this is called.
+    await fs.unlink(confPath);
+  }
+
+  console.log('Building app');
+  await buildApp(options, outDir, cleanup);
+
+  return cleanup;
+};
+
+function copyContent(options) {
+  return fs.cp(
+    path.join(__dirname, '../src/static'),
+    path.join(options.outDir, 'static'),
+    {
+      recursive: true,
+    },
+  );
+}
+
+async function copyBootstrap(options) {
+  const bootstrapCss = fileURLToPath(
+    import.meta.resolve('bootstrap/dist/css/bootstrap.min.css'),
+  );
+  await fs.mkdir(path.join(options.outDir, 'static'), { recursive: true });
+  return fs.copyFile(
+    bootstrapCss,
+    path.join(options.outDir, 'static/bootstrap.min.css'),
+  );
+}
+
+async function addIndex(options) {
+  const content = await fs.readFile(
+    path.join(__dirname, '../src/template/index.html'),
+    'utf8',
+  );
+  const tpl = _.template(content);
+  return fs.writeFile(
+    path.join(options.outDir, 'index.html'),
+    tpl({
+      title: options.config.title,
+      uniqid: Date.now(),
+    }),
+  );
+}
+
+function addVisualizer(options) {
+  const page = visualizer.makeVisualizerPage({
+    cdn: options.config.visualizerCDN,
+    fallbackVersion: options.config.visualizerFallbackVersion,
+    scripts: [
+      {
+        url: iframeBridge,
+      },
+    ],
+  });
+  return fs.writeFile(path.join(options.outDir, 'visualizer.html'), page);
+}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "visualizer-on-tabs",
+  "version": "1.0.0",
+  "description": "visualizer-on-tabs webpack builder",
+  "type": "module",
+  "exports": {
+    ".": "./main/index.js"
+  },
+  "bin": "bin/build.js",
+  "files": [
+    "main",
+    "src",
+    "bin",
+    "!**/*.test.js"
+  ],
+  "browserslist": [
+    "defaults"
+  ],
+  "scripts": {
+    "build": "npx --no-install visualizer-on-tabs --config=./dev.json --outDir=./out",
+    "build:dev": "npx --no-install visualizer-on-tabs --dev=1 --config=./dev.json --outDir=./out",
+    "clean": "rimraf out",
+    "eslint": "eslint bin main src",
+    "prettier": "prettier --check ./",
+    "prettier-write": "prettier --write ./",
+    "serve": "npx serve out/",
+    "test": "npm run test-only && npm run eslint && npm run prettier",
+    "test-only": "node --test"
+  },
+  "dependencies": {
+    "@babel/core": "^7.28.3",
+    "@babel/preset-env": "^7.28.3",
+    "@babel/preset-react": "^7.27.1",
+    "babel-loader": "^10.0.0",
+    "bootstrap": "^5.3.3",
+    "iframe-bridge": "^3.0.2",
+    "lockr": "^0.8.5",
+    "lodash": "^4.17.21",
+    "minimist": "^1.2.6",
+    "react": "^18.3.1",
+    "react-bootstrap": "^3.0.0-beta.3",
+    "react-dom": "^18.3.1",
+    "react-visualizer": "^3.0.1",
+    "webpack": "^5.91.0"
+  },
+  "devDependencies": {
+    "eslint": "^9.34.0",
+    "eslint-config-zakodium": "^16.0.0",
+    "prettier": "^3.6.2",
+    "rimraf": "^6.0.1"
+  },
+  "volta": {
+    "node": "24.7.0"
+  }
+}

package/src/app.js

@@ -0,0 +1,20 @@
+import React from 'react';
+import ReactDOM from 'react-dom/client';
+
+import App from './components/App.js';
+
+const loc = window.location;
+let hash = loc.hash.slice(1);
+if (!hash) {
+  hash = 'main';
+}
+
+const props = {
+  origin: loc.origin,
+  path: hash,
+};
+
+const element = React.createElement(App, props);
+ReactDOM.createRoot(document.getElementById('visualizer-on-tabs')).render(
+  element,
+);

package/src/components/App.js

@@ -0,0 +1,373 @@
+/* eslint-disable no-await-in-loop */
+
+import { postMessage, registerHandler } from 'iframe-bridge/main';
+import React from 'react';
+import Tab from 'react-bootstrap/Tab';
+import BTabs from 'react-bootstrap/Tabs';
+import { Visualizer } from 'react-visualizer';
+
+import { getConfig } from '../config/config.js';
+import customConfig from '../config/custom.json' with { type: 'json' };
+import Tabs from '../main/Tabs.js';
+import iframeMessageHandler from '../main/iframeMessageHandler.js';
+import * as tabStorage from '../main/tabStorage.js';
+import { rewriteURL } from '../util.js';
+
+import Login from './Login.js';
+import TabTitle from './TabTitle.js';
+
+const config = getConfig(customConfig);
+let tabInit = Promise.resolve();
+let currentIframe;
+
+const pageURL = new URL(window.location);
+const pageQueryParameters = (() => {
+  let params = {};
+  for (let key of pageURL.searchParams.keys()) {
+    params[key] = pageURL.searchParams.get(key);
+  }
+  return params;
+})();
+
+const iframeStyle = { position: 'static', flex: 2, border: 'none' };
+
+class App extends React.Component {
+  constructor(props) {
+    super(props);
+    for (let key in config.possibleViews) {
+      config.possibleViews[key].id = key;
+    }
+    this.onActiveTab = this.onActiveTab.bind(this);
+
+    registerHandler('tab', iframeMessageHandler);
+    registerHandler('admin', (data, [level2]) => {
+      if (level2 === 'connect' && data.windowID !== undefined) {
+        if (!currentIframe) {
+          // The iframe was refreshed
+          config.possibleViews[this.state.activeTabKey].windowID =
+            data.windowID;
+          this.sendData(this.state.activeTabKey);
+        } else {
+          config.possibleViews[currentIframe.id].windowID = data.windowID;
+          currentIframe.resolve();
+          currentIframe = null;
+        }
+      }
+    });
+
+    Tabs.on('openTab', (obj) => {
+      const options = {};
+      ['noFocus', 'noFocusEvent', 'noData', 'load'].forEach((prop) => {
+        options[prop] = obj[prop];
+        delete obj[prop];
+      });
+      this.doTab(obj, options);
+    });
+    Tabs.on('status', this.setTabStatus.bind(this));
+    Tabs.on('message', this.sendTabMessage.bind(this));
+    Tabs.on('focus', this.focusTab.bind(this));
+
+    this.visualizerVersion = pageURL.searchParams.get('v');
+
+    this.state = {
+      viewsList: [],
+      activeTabKey: 0,
+      isConfigLoaded: false,
+    };
+
+    void this.loadTabs();
+  }
+
+  async loadTabs() {
+    let firstTab;
+    const loadTab = async (view) => {
+      if (!firstTab) firstTab = view.id;
+      await this.doTab(view, {
+        noFocus: true,
+        load: config.loadHidden,
+        noFocusEvent: true,
+      });
+    };
+    const data = tabStorage.load();
+    // Load possible views first
+    for (let key in config.possibleViews) {
+      let saved;
+      if ((saved = data.find((el) => el.id === key))) {
+        await loadTab(saved);
+      } else {
+        await loadTab(config.possibleViews[key]);
+      }
+    }
+
+    for (let i = 0; i < data.length; i++) {
+      if (!config.possibleViews[data[i].id]) {
+        await loadTab(data[i]);
+      }
+    }
+
+    // Nothing is focused at this point
+    const lastSelected = tabStorage.getSelected();
+    if (this.state.viewsList.find((el) => el.id === lastSelected)) {
+      await this.showTab(lastSelected);
+    } else {
+      await this.showTab(firstTab);
+    }
+  }
+
+  setTabStatus(data) {
+    // Find view with given window ID
+    const ids = Object.keys(config.possibleViews);
+    let id = ids.find(
+      (id) => config.possibleViews[id].windowID === data.windowID,
+    );
+    if (!id) return;
+    let view = config.possibleViews[id];
+
+    view = this.state.viewsList.find((el) => el.id === view.id);
+    if (!view) return;
+
+    view.status = { ...view.status, ...data.message };
+    this.setState((state) => ({
+      viewsList: state.viewsList,
+    }));
+  }
+
+  sendTabMessage(data) {
+    const viewInfo = config.possibleViews[data.id];
+    if (viewInfo) {
+      postMessage('tab.message', data.message, viewInfo.windowID);
+    }
+  }
+
+  async focusTab(tabId) {
+    if (this.state.viewsList.find((el) => el.id === tabId)) {
+      await this.showTab(tabId, {
+        noData: true,
+      });
+    }
+  }
+
+  async doTab(obj, options) {
+    if (!config.possibleViews[obj.id]) {
+      config.possibleViews[obj.id] = {
+        id: obj.id,
+        url: obj.url,
+        data: obj.data,
+        closable: obj.closable,
+        rawIframe: obj.rawIframe,
+      };
+    } else {
+      config.possibleViews[obj.id].data = obj.data;
+    }
+
+    if (config.rewriteRules) {
+      let newURL = rewriteURL(
+        config.rewriteRules,
+        config.possibleViews[obj.id].url,
+      );
+      if (newURL) {
+        config.possibleViews[obj.id].rewrittenUrl = newURL;
+      }
+    }
+
+    await this.showTab(obj.id, options);
+  }
+
+  async showTab(id, options) {
+    options = options || {};
+    const sameTab = this.state.activeTabKey === id;
+    if (sameTab && !options.force) return;
+
+    const focusedTabId = options.noFocus ? undefined : id;
+    let viewFromList = this.state.viewsList.find((el) => el.id === id);
+    const newTab = !viewFromList;
+    const viewInfo = config.possibleViews[id];
+
+    if (!viewInfo) throw new Error('unreachable');
+    if (!viewFromList) {
+      viewFromList = {
+        id,
+        url: viewInfo.url,
+        rewrittenUrl: viewInfo.rewrittenUrl,
+        closable: viewInfo.closable,
+        rawIframe: viewInfo.rawIframe,
+      };
+      this.state.viewsList.push(viewFromList);
+    }
+    const firstRender =
+      (options.load || !options.noFocus) && (newTab || !viewFromList.rendered);
+    await tabInit;
+    // First render means we expect the render function to initialize a new iframe
+    // We need to get the IframeBridge ID of that frame and prevent any other iframes
+    // to load during that time
+    if (firstRender) {
+      // TODO: there is probably a cleaner way than a global promise
+      // eslint-disable-next-line require-atomic-updates
+      tabInit = new Promise((resolve) => {
+        viewFromList.rendered = true;
+        this.setState((state) => ({
+          activeTabKey: focusedTabId,
+          viewsList: state.viewsList,
+        }));
+
+        setTimeout(() => {
+          // This will have an effect only if Promise is not yet resolved
+          // It prevents completely blocking the interface if there is a problem
+          // with that tab
+          return resolve();
+        }, 3000);
+        currentIframe = {
+          resolve,
+          id,
+        };
+      });
+      await tabInit;
+    } else {
+      this.setState((state) => ({
+        activeTabKey: focusedTabId,
+        viewsList: state.viewsList,
+      }));
+    }
+
+    // always send data on first render
+    if (!options.noData || firstRender) {
+      this.sendData(id);
+    }
+    tabStorage.save(id, viewInfo);
+    if (!options.noFocus) {
+      tabStorage.saveSelected(id);
+    }
+    if (!options.noFocusEvent && !sameTab) {
+      this.sendTabFocusEvent(focusedTabId);
+    }
+  }
+
+  sendData(id) {
+    const viewInfo = config.possibleViews[id];
+    postMessage(
+      'tab.data',
+      { ...viewInfo.data, queryParameters: pageQueryParameters },
+      viewInfo.windowID,
+    );
+  }
+
+  async removeTab(id) {
+    const forbiddenPossibleViews = Object.keys(config.possibleViews);
+    tabStorage.remove(id);
+    if (forbiddenPossibleViews.indexOf(id) === -1) {
+      delete config.possibleViews[id];
+    }
+    let idx = this.state.viewsList.findIndex((el) => el.id === id);
+    if (idx === -1) return;
+    this.state.viewsList.splice(idx, 1);
+
+    let newActiveTab;
+    if (id !== this.state.activeTabKey) {
+      newActiveTab = this.state.activeTabKey;
+    } else {
+      const viewsLength = this.state.viewsList.length;
+      // Set next active tab
+      if (viewsLength > 0) {
+        if (idx < viewsLength) {
+          newActiveTab = this.state.viewsList[idx].id;
+        } else {
+          newActiveTab = this.state.viewsList[viewsLength - 1].id;
+        }
+      }
+    }
+
+    await this.showTab(newActiveTab, {
+      noData: true,
+      force: true,
+    });
+  }
+
+  sendTabFocusEvent(key) {
+    if (config.possibleViews[key]) {
+      postMessage('tab.focus', {}, config.possibleViews[key].windowID);
+    }
+  }
+
+  async onActiveTab(key) {
+    await this.showTab(key, {
+      noData: true,
+    });
+  }
+
+  render() {
+    const arr = [];
+    for (let view of this.state.viewsList) {
+      const closable = view.closable === undefined ? true : view.closable;
+      const saved =
+        !view.status || view.status.saved === undefined
+          ? true
+          : view.status.saved;
+
+      const textStyle = {};
+      if (!saved) {
+        textStyle.color = 'red';
+      }
+      const shouldRender = view.rendered || view.id === this.state.activeTabKey;
+      let viewPage;
+      if (shouldRender) {
+        if (view.rawIframe) {
+          viewPage = (
+            <iframe
+              allow="fullscreen; clipboard-read; clipboard-write;"
+              src={view.rewrittenUrl || view.url}
+              style={iframeStyle}
+            />
+          );
+        } else {
+          viewPage = (
+            <Visualizer
+              url="visualizer.html"
+              viewURL={view.rewrittenUrl || view.url}
+              version={
+                this.visualizerVersion || config.visualizerVersion || 'auto'
+              }
+              config={config.visualizerConfig}
+              style={iframeStyle}
+            />
+          );
+        }
+      } else {
+        viewPage = <div>Not rendered</div>;
+      }
+      arr.push(
+        <Tab
+          title={
+            <TabTitle
+              textTitle={saved ? null : 'Not saved'}
+              textStyle={textStyle}
+              name={view.id}
+              onTabClosed={closable ? () => this.removeTab(view.id) : null}
+            />
+          }
+          key={view.id}
+          eventKey={view.id}
+        >
+          {viewPage}
+        </Tab>,
+      );
+    }
+
+    return (
+      <div className="visualizer-on-tabs-app">
+        <Login config={config} />
+        <div className="visualizer-on-tabs-content d-flex flex-column">
+          <BTabs
+            id="visualizer-on-tabs-tab"
+            transition={false}
+            activeKey={this.state.activeTabKey}
+            onSelect={this.onActiveTab}
+          >
+            {arr}
+          </BTabs>
+        </div>
+      </div>
+    );
+  }
+}
+
+export default App;

package/src/components/Login.js

@@ -0,0 +1,92 @@
+import React from 'react';
+
+const styles = {
+  position: 'fixed',
+  right: 20,
+  top: 10,
+};
+
+class Login extends React.Component {
+  constructor(props) {
+    super(props);
+    const { config } = props;
+    this.state = {};
+    this.logout = this.logout.bind(this);
+    if (!config.rocLogin) return;
+
+    if (config.rocLogin.urlAbsolute) {
+      this.loginUrl = config.rocLogin.urlAbsolute;
+    } else {
+      this.loginUrl = `${config.rocLogin.url}/auth/login?continue=${
+        config.rocLogin.redirect || window.location.href
+      }`;
+    }
+  }
+
+  componentDidMount() {
+    void this.session();
+  }
+
+  async session() {
+    if (!this.props.config.rocLogin) return;
+    const login = this.props.config.rocLogin;
+    const response = await fetch(`${login.url}/auth/session`, {
+      credentials: 'include',
+    });
+    if (response.ok) {
+      const body = await response.json();
+      if (
+        login.auto &&
+        (!body.authenticated || (login.user && body.username !== login.user))
+      ) {
+        window.location.href = this.loginUrl;
+      }
+      this.setState({
+        user: body.username,
+      });
+    } else {
+      this.setState({
+        user: null,
+      });
+    }
+  }
+
+  async logout() {
+    if (!this.props.config.rocLogin) return;
+    const response = await fetch(
+      `${this.props.config.rocLogin.url}/auth/logout`,
+      {
+        credentials: 'include',
+      },
+    );
+    if (!response.ok) {
+      throw new Error(`Unexpected logout response: ${response.statusText}`);
+    }
+    void this.session();
+  }
+
+  render() {
+    if (!this.props.config.rocLogin) {
+      return <div />;
+    }
+    if (!this.state.user || this.state.user === 'anonymous') {
+      return (
+        <div style={styles}>
+          <a href={this.loginUrl}>Login</a>
+        </div>
+      );
+    } else {
+      return (
+        <div style={styles}>
+          {this.state.user}
+          &nbsp;
+          <a href="#" onClick={this.logout}>
+            Logout
+          </a>
+        </div>
+      );
+    }
+  }
+}
+
+export default Login;

package/src/components/TabTitle.js

@@ -0,0 +1,41 @@
+import React from 'react';
+
+class TabTitle extends React.Component {
+  constructor(props) {
+    super(props);
+    this.onClosedClicked = this.onClosedClicked.bind(this);
+  }
+  onClosedClicked(event) {
+    event.stopPropagation();
+    event.preventDefault();
+    if (this.props.onTabClosed) {
+      this.props.onTabClosed.call();
+    }
+  }
+
+  render() {
+    let closeHandle;
+    if (this.props.onTabClosed) {
+      closeHandle = (
+        <span className="close-tab-glyph" onClick={this.onClosedClicked}>
+          ×
+        </span>
+      );
+    } else {
+      closeHandle = '';
+    }
+
+    return (
+      <div
+        title={this.props.textTitle}
+        style={this.props.textStyle}
+        className="d-flex flex-row gap-2 align-items-baseline"
+      >
+        {this.props.name}
+        {closeHandle}
+      </div>
+    );
+  }
+}
+
+export default TabTitle;

package/src/config/config.js

@@ -0,0 +1,10 @@
+import defaultConfig from './default.js';
+
+export function getConfig(customConfig) {
+  const config = { ...defaultConfig, ...customConfig };
+  if (config.rocLogin && config.rocLogin.url) {
+    // Remove trailing slash
+    config.rocLogin.url = config.rocLogin.url.replace(/\/$/, '');
+  }
+  return config;
+}

package/src/config/default.js

@@ -0,0 +1,15 @@
+export default {
+  visualizerConfig: {
+    debugLevel: 0,
+    filters: [],
+    modules: {
+      folders: ['modules/types'],
+    },
+    header: false,
+  },
+  possibleViews: {
+    Home: {
+      url: '',
+    },
+  },
+};

package/src/main/Tabs.js

@@ -0,0 +1,21 @@
+import { EventEmitter } from 'events';
+
+const Tabs = new EventEmitter();
+
+Tabs.openTab = function openTab(data) {
+  Tabs.emit('openTab', data);
+};
+
+Tabs.status = function status(data) {
+  Tabs.emit('status', data);
+};
+
+Tabs.sendMessage = function sendMessage(message) {
+  Tabs.emit('message', message);
+};
+
+Tabs.focus = function focus(message) {
+  Tabs.emit('focus', message);
+};
+
+export default Tabs;

package/src/main/constants.js

@@ -0,0 +1 @@
+export const version = 1;

package/src/main/iframeMessageHandler.js

@@ -0,0 +1,42 @@
+import Tabs from './Tabs.js';
+
+export default function iframeMessageHandler(data, [level2]) {
+  let prom;
+  switch (level2) {
+    case 'open':
+      Tabs.openTab(data.message);
+      prom = Promise.resolve('done');
+      break;
+    case 'status':
+      Tabs.status(data);
+      prom = Promise.resolve('done');
+      break;
+    case 'message':
+      Tabs.sendMessage(data.message);
+      prom = Promise.resolve('done');
+      break;
+    case 'focus':
+      Tabs.focus(data.message);
+      prom = Promise.resolve('done');
+      break;
+    default:
+      prom = Promise.reject(new Error(`Unknown action: ${level2}}`));
+      break;
+  }
+
+  prom.then(
+    (message) => {
+      data.message = message.data;
+      // the iframeMessageHandler callback's `this` is bound by the iframe-bridge library
+      // eslint-disable-next-line no-invalid-this
+      this.postMessage(data);
+    },
+    (error) => {
+      data.status = 'error';
+      data.message = error;
+      // the iframeMessageHandler callback's `this` is bound by the iframe-bridge library
+      // eslint-disable-next-line no-invalid-this
+      this.postMessage(data);
+    },
+  );
+}

package/src/main/tabStorage.js

@@ -0,0 +1,63 @@
+import lockr from 'lockr';
+
+import { version } from './constants.js';
+
+const LOCAL_STORAGE_TAB_DATA = 'vweb-';
+const LOCAL_STORAGE_TAB_IDS = 'vweb1-tab-ids';
+const LOCAL_STORAGE_LAST_TAB = 'vweb1-selected-tab';
+
+const storage = {};
+
+function isVersionOK(v) {
+  return v === undefined || v === version;
+}
+
+export function save(tabId, data) {
+  if (!tabId) return;
+  lockr.sadd(LOCAL_STORAGE_TAB_IDS, tabId);
+  let key = LOCAL_STORAGE_TAB_DATA + tabId;
+  data.version = version;
+  lockr.set(key, data);
+}
+
+export function saveSelected(tabId) {
+  if (!tabId) return;
+  lockr.set(LOCAL_STORAGE_LAST_TAB, tabId);
+}
+
+export function getSelected() {
+  return lockr.get(LOCAL_STORAGE_LAST_TAB);
+}
+
+export function load() {
+  let ids = lockr.smembers(LOCAL_STORAGE_TAB_IDS);
+  if (!ids) return [];
+
+  let data = ids.map((id) => {
+    return lockr.get(LOCAL_STORAGE_TAB_DATA + id);
+  });
+
+  data.forEach((entry) => {
+    if (!isVersionOK(entry.version)) {
+      storage.remove(entry.id);
+    }
+  });
+
+  data = data.filter((entry) => isVersionOK(entry.version));
+
+  data.sort(function sortData(a, b) {
+    let idxA = ids.indexOf(a.id);
+    let idxB = ids.indexOf(b.id);
+    if (idxA < idxB) return -1;
+    else if (idxB < idxA) return 1;
+    else return 0;
+  });
+  return data;
+}
+
+export function remove(id) {
+  lockr.srem(LOCAL_STORAGE_TAB_IDS, id);
+  lockr.rm(LOCAL_STORAGE_TAB_DATA + id);
+}
+
+export default storage;

package/src/main/visualizerConfig.js

@@ -0,0 +1,7 @@
+const config = '../config.json';
+
+const defaultConfig = {};
+
+export function getConfig() {
+  return config.visualizerConfig || defaultConfig;
+}

package/src/static/style.css

@@ -0,0 +1,75 @@
+html,
+body,
+#visualizer-on-tabs,
+.visualizer-on-tabs-app,
+.visualizer-on-tabs-splash {
+  margin: 0;
+  padding: 0;
+  width: 100%;
+  height: 100%;
+  font-size: 14px;
+}
+
+.visualizer-on-tabs-app {
+  display: flex;
+  flex-flow: column;
+  position: relative;
+}
+
+.visualizer-on-tabs-splash {
+  position: absolute;
+  height: calc(100% - 3px);
+  display: flex;
+  flex-flow: column;
+  background: url(../images/splash.png) no-repeat center center fixed;
+  background-size: cover;
+  z-index: 1000;
+}
+
+.visualizer-on-tabs-login {
+  width: 500px;
+  margin: auto;
+}
+
+.visualizer-on-tabs-login > .form-group {
+  display: inline-block;
+}
+
+.visualizer-on-tabs-content,
+.tab-content,
+.tab-content > .active,
+.visualizer-on-tabs-splash-bg {
+  display: flex;
+  flex-direction: column;
+  flex: 2;
+}
+
+.visualizer-on-tabs-header {
+  height: 40px;
+}
+
+.visualizer-on-tabs-footer {
+  height: 20px;
+}
+
+.visualizer-on-tabs-progress {
+  width: 250px;
+}
+
+.close-tab-glyph {
+  font-size: 18px;
+  font-weight: bold;
+  line-height: 0;
+}
+
+.close-tab-glyph:hover {
+  color: #ff4136;
+}
+
+.nav-tabs > li > a {
+  outline: none;
+}
+
+.sync-progress-bar {
+  background-color: #ff4136;
+}

package/src/template/index.html

@@ -0,0 +1,15 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <link rel="stylesheet" href="static/bootstrap.min.css" />
+    <link rel="stylesheet" href="static/style.css" />
+    <title><%- title %></title>
+  </head>
+
+  <body>
+    <div id="visualizer-on-tabs"></div>
+    <script src="app.js?_=<%= uniqid %>"></script>
+  </body>
+</html>

package/src/util.js

@@ -0,0 +1,29 @@
+export function rewriteURL(rewriteRules, url) {
+  for (let i = 0; i < rewriteRules.length; i++) {
+    let rewriteRule = rewriteRules[i];
+    if (Array.isArray(rewriteRule)) {
+      let tmpUrl = url;
+      for (let j = 0; j < rewriteRule.length; j++) {
+        let reg = new RegExp(rewriteRule[j].reg);
+        let replace = rewriteRule[j].replace;
+        let optional = rewriteRule[j].optionalMatch;
+        let lastRule = j === rewriteRule.length - 1;
+        if (tmpUrl.match(reg) && lastRule) {
+          return tmpUrl.replace(reg, replace);
+        } else if (tmpUrl.match(reg)) {
+          tmpUrl = tmpUrl.replace(reg, replace);
+        } else if (!optional) {
+          break;
+        } else if (optional && lastRule) {
+          return tmpUrl;
+        }
+      }
+    } else {
+      let reg = new RegExp(rewriteRule.reg);
+      if (url.match(reg)) {
+        return url.replace(reg, rewriteRule.replace);
+      }
+    }
+  }
+  return null;
+}