Dump.fs

module Dump
// assuming you have LinqPad.Runtime nuget package installed,
// dumpH function will produce a html file that knows how to refresh itself
// at every 'interval' milliseconds based on the interval value in the live.js
// source code given below. install and run dotnet-serve global tool with
//  dotnet-serve -o
// and you'll have a browser page showing your html dump. it will refresh automatically
// every time dumpH is called from your code.
let liveJs =
    """
      /*
      Live.js - One script closer to Designing in the Browser
      Written for Handcraft.com by Martin Kool (@mrtnkl).

      Version 4.
      Recent change: Made stylesheet and mimetype checks case insensitive.

      http://livejs.com
      http://livejs.com/license (MIT)  
      @livejs

      Include live.js#css to monitor css changes only.
      Include live.js#js to monitor js changes only.
      Include live.js#html to monitor html changes only.
      Mix and match to monitor a preferred combination such as live.js#html,css  

      By default, just include live.js to monitor all css, js and html changes.
      
      Live.js can also be loaded as a bookmarklet. It is best to only use it for CSS then,
      as a page reload due to a change in html or css would not re-include the bookmarklet.
      To monitor CSS and be notified that it has loaded, include it as: live.js#css,notify
    */
    (function () {

      var headers = { "Etag": 1, "Last-Modified": 1, "Content-Length": 1, "Content-Type": 1 },
          resources = {},
          pendingRequests = {},
          currentLinkElements = {},
          oldLinkElements = {},
          interval = 300,
          loaded = false,
          active = { "html": 1, "css": 1, "js": 1 };

      var Live = {

        // performs a cycle per interval
        heartbeat: function () {      
          if (document.body) {        
            // make sure all resources are loaded on first activation
            if (!loaded) Live.loadresources();
            Live.checkForChanges();
          }
          setTimeout(Live.heartbeat, interval);
        },

        // loads all local css and js resources upon first activation
        loadresources: function () {

          // helper method to assert if a given url is local
          function isLocal(url) {
            var loc = document.location,
                reg = new RegExp("^\\.|^\/(?!\/)|^[\\w]((?!://).)*$|" + loc.protocol + "//" + loc.host);
            return url.match(reg);
          }

          // gather all resources
          var scripts = document.getElementsByTagName("script"),
              links = document.getElementsByTagName("link"),
              uris = [];

          // track local js urls
          for (var i = 0; i < scripts.length; i++) {
            var script = scripts[i], src = script.getAttribute("src");
            if (src && isLocal(src))
              uris.push(src);
            if (src && src.match(/\blive.js#/)) {
              for (var type in active)
                active[type] = src.match("[#,|]" + type) != null
              if (src.match("notify")) 
                alert("Live.js is loaded.");
            }
          }
          if (!active.js) uris = [];
          if (active.html) uris.push(document.location.href);

          // track local css urls
          for (var i = 0; i < links.length && active.css; i++) {
            var link = links[i], rel = link.getAttribute("rel"), href = link.getAttribute("href", 2);
            if (href && rel && rel.match(new RegExp("stylesheet", "i")) && isLocal(href)) {
              uris.push(href);
              currentLinkElements[href] = link;
            }
          }

          // initialize the resources info
          for (var i = 0; i < uris.length; i++) {
            var url = uris[i];
            Live.getHead(url, function (url, info) {
              resources[url] = info;
            });
          }

          // add rule for morphing between old and new css files
          var head = document.getElementsByTagName("head")[0],
              style = document.createElement("style"),
              rule = "transition: all .3s ease-out;"
          css = [".livejs-loading * { ", rule, " -webkit-", rule, "-moz-", rule, "-o-", rule, "}"].join('');
          style.setAttribute("type", "text/css");
          head.appendChild(style);
          style.styleSheet ? style.styleSheet.cssText = css : style.appendChild(document.createTextNode(css));

          // yep
          loaded = true;
        },

        // check all tracking resources for changes
        checkForChanges: function () {
          for (var url in resources) {
            if (pendingRequests[url])
              continue;

            Live.getHead(url, function (url, newInfo) {
              var oldInfo = resources[url],
                  hasChanged = false;
              resources[url] = newInfo;
              for (var header in oldInfo) {
                // do verification based on the header type
                var oldValue = oldInfo[header],
                    newValue = newInfo[header],
                    contentType = newInfo["Content-Type"];
                switch (header.toLowerCase()) {
                  case "etag":
                    if (!newValue) break;
                    // fall through to default
                  default:
                    hasChanged = oldValue != newValue;
                    break;
                }
                // if changed, act
                if (hasChanged) {
                  Live.refreshResource(url, contentType);
                  break;
                }
              }
            });
          }
        },

        // act upon a changed url of certain content type
        refreshResource: function (url, type) {
          switch (type.toLowerCase()) {
            // css files can be reloaded dynamically by replacing the link element                               
            case "text/css":
              var link = currentLinkElements[url],
                  html = document.body.parentNode,
                  head = link.parentNode,
                  next = link.nextSibling,
                  newLink = document.createElement("link");

              html.className = html.className.replace(/\s*livejs\-loading/gi, '') + ' livejs-loading';
              newLink.setAttribute("type", "text/css");
              newLink.setAttribute("rel", "stylesheet");
              newLink.setAttribute("href", url + "?now=" + new Date() * 1);
              next ? head.insertBefore(newLink, next) : head.appendChild(newLink);
              currentLinkElements[url] = newLink;
              oldLinkElements[url] = link;

              // schedule removal of the old link
              Live.removeoldLinkElements();
              break;

            // check if an html resource is our current url, then reload                               
            case "text/html":
              if (url != document.location.href)
                return;

              // local javascript changes cause a reload as well
            case "text/javascript":
            case "application/javascript":
            case "application/x-javascript":
              document.location.reload();
          }
        },

        // removes the old stylesheet rules only once the new one has finished loading
        removeoldLinkElements: function () {
          var pending = 0;
          for (var url in oldLinkElements) {
            // if this sheet has any cssRules, delete the old link
            try {
              var link = currentLinkElements[url],
                  oldLink = oldLinkElements[url],
                  html = document.body.parentNode,
                  sheet = link.sheet || link.styleSheet,
                  rules = sheet.rules || sheet.cssRules;
              if (rules.length >= 0) {
                oldLink.parentNode.removeChild(oldLink);
                delete oldLinkElements[url];
                setTimeout(function () {
                  html.className = html.className.replace(/\s*livejs\-loading/gi, '');
                }, 100);
              }
            } catch (e) {
              pending++;
            }
            if (pending) setTimeout(Live.removeoldLinkElements, 50);
          }
        },

        // performs a HEAD request and passes the header info to the given callback
        getHead: function (url, callback) {
          pendingRequests[url] = true;
          var xhr = window.XMLHttpRequest ? new XMLHttpRequest() : new ActiveXObject("Microsoft.XmlHttp");
          xhr.open("HEAD", url, true);
          xhr.onreadystatechange = function () {
            delete pendingRequests[url];
            if (xhr.readyState == 4 && xhr.status != 304) {
              xhr.getAllResponseHeaders();
              var info = {};
              for (var h in headers) {
                var value = xhr.getResponseHeader(h);
                // adjust the simple Etag variant to match on its significant part
                if (h.toLowerCase() == "etag" && value) value = value.replace(/^W\//, '');
                if (h.toLowerCase() == "content-type" && value) value = value.replace(/^(.*?);.*?$/i, "$1");
                info[h] = value;
              }
              callback(url, info);
            }
          }
          xhr.send();
        }
      };

      // start listening
      if (document.location.protocol != "file:") {
        if (!window.liveJsLoaded)
          Live.heartbeat();

        window.liveJsLoaded = true;
      }
      else if (window.console)
        console.log("Live.js doesn't support the file protocol. It needs http.");    
    })();
    """
let dumpFile = "../../../tmp.html"
let liveResult (x: string) = x.Replace("<head>", $"<head> <script type=\"text/javascript\">{liveJs}</script>")
let dumpH (o: obj) =        
        System.IO.File.WriteAllLines (dumpFile, [o |> LINQPad.Util.ToHtmlString |> liveResult])