Current Dev State

static/js/ketcher2/node_modules/budo/lib/reload/client.js

@@ -0,0 +1,134 @@
+var reloadCSS = require('reload-css')
+module.exports = connect()
+
+function connect () {
+  var reconnectPoll = 1000
+  var maxRetries = 50
+  var retries = 0
+  var reconnectInterval
+  var isReconnecting = false
+  var protocol = document.location.protocol
+  var hostname = document.location.hostname
+  var port = document.location.port
+  var host = hostname + ':' + port
+
+  var isIOS = /(iOS|iPhone|iPad|iPod)/i.test(navigator.userAgent)
+  var isSSL = /^https:/i.test(protocol)
+  var queued = []
+  var socket = createWebSocket()
+  var listeners = []
+
+  var api = {
+    send: function (message) {
+      message = JSON.stringify(message)
+      if (socket && socket.readyState === 1) {
+        socket.send(message)
+      } else {
+        queued.push(message)
+      }
+    },
+    listen: function (cb) {
+      if (typeof cb !== 'function') {
+        throw new TypeError('cb must be a function!')
+      }
+      listeners.push(cb)
+    },
+    reloadPage: reloadPage,
+    reloadCSS: reloadCSS
+  }
+
+  return api
+
+  function scheduleReconnect () {
+    if (isIOS && isSSL) {
+      // Special case for iOS with a self-signed certificate.
+      console.warn('[budo] LiveReload disconnected. You may need to generate and ' +
+        'trust a self-signed certificate, see here:\n' +
+        'https://github.com/mattdesl/budo/blob/master/docs/' +
+        'command-line-usage.md#ssl-on-ios')
+      return
+    }
+    if (isSSL) {
+      // Don't attempt to re-connect in SSL since it will likely be insecure
+      console.warn('[budo] LiveReload disconnected. Please reload the page to retry.')
+      return
+    }
+    if (retries >= maxRetries) {
+      console.warn('[budo] LiveReload disconnected, exceeded retry count. Please reload the page to retry.')
+      return
+    }
+    if (!isReconnecting) {
+      isReconnecting = true
+      console.warn('[budo] LiveReload disconnected, retrying...')
+    }
+    retries++
+    clearTimeout(reconnectInterval)
+    reconnectInterval = setTimeout(reconnect, reconnectPoll)
+  }
+
+  function reconnect () {
+    if (socket) {
+      // force close the existing socket
+      socket.onclose = function () {}
+      socket.close()
+    }
+    socket = createWebSocket()
+  }
+
+  function createWebSocket () {
+    var wsProtocol = isSSL ? 'wss://' : 'ws://'
+    var wsUrl = wsProtocol + host + '/livereload'
+    var ws = new window.WebSocket(wsUrl)
+    ws.onmessage = function (event) {
+      var data
+      try {
+        data = JSON.parse(event.data)
+      } catch (err) {
+        console.warn('Error parsing LiveReload server data: ' + event.data)
+        return
+      }
+
+      if (data.event === 'reload') {
+        if (/^\.?css$/i.test(data.ext)) {
+          reloadCSS(data.url)
+        } else {
+          reloadPage()
+        }
+      }
+
+      // let listeners receive data
+      listeners.forEach(function (listener) {
+        listener(data)
+      })
+    }
+    ws.onclose = function (ev) {
+      if (ev.code === 1000 || ev.code === 1001) {
+        // Browser is navigating away.
+        return
+      }
+      scheduleReconnect()
+    }
+    ws.onopen = function () {
+      if (isReconnecting) {
+        isReconnecting = false
+        retries = 0
+        console.warn('[budo] LiveReload reconnected.')
+      }
+      if (queued.length && ws.readyState === 1) {
+        queued.forEach(function (message) {
+          ws.send(message)
+        })
+        queued.length = 0
+      }
+    }
+    ws.onerror = function () {
+      return false
+    }
+    return ws
+  }
+}
+
+function reloadPage () {
+  window.location.reload(true)
+}
+

static/js/ketcher2/node_modules/budo/lib/reload/server.js

@@ -0,0 +1,78 @@
+var WebSocketServer = require('ws').Server
+var log = require('bole')('budo')
+var path = require('path')
+var isAbsolute = require('path-is-absolute')
+var color = require('term-color')
+
+module.exports = function (server, opts) {
+  opts = opts || {}
+  log.info({ message: 'LiveReload running' })
+
+  // get a list of static folders to use as base dirs
+  var cwd = path.resolve(opts.cwd || process.cwd())
+  var staticDirs = Array.isArray(opts.dir) ? opts.dir : [ opts.dir ]
+  staticDirs = staticDirs.map(function (dir) {
+    return path.resolve(dir)
+  })
+  if (staticDirs.indexOf(cwd) === -1) staticDirs.push(cwd)
+
+  var closed = false
+  var wss = new WebSocketServer({
+    server: server,
+    perMessageDeflate: false
+  })
+
+  return {
+    webSocketServer: wss,
+    reload: reload,
+    close: function () {
+      if (closed) return
+      wss.close()
+      closed = true
+    }
+  }
+
+  function reload (file) {
+    if (closed) return
+    var url, ext
+
+    if (file && typeof file === 'string') {
+      // absolute file path
+      file = isAbsolute(file) ? path.normalize(file) : path.resolve(cwd, file)
+
+      // make it relative, removing the static folder parts
+      for (var i = 0; i < staticDirs.length; i++) {
+        var dir = staticDirs[i]
+        url = path.relative(dir, file)
+        // if the path doesn't starts with "../", then
+        // it should be relative to this folder
+        if (!/^(\.\.[/\\]|[/\\])/.test(url)) break
+      }
+
+      // turn it into a URL
+      url = url.replace(/\\/g, '/')
+
+      // ensure it starts at root of app
+      if (url.charAt(0) !== '/') url = '/' + url
+
+      ext = path.extname(file)
+    }
+
+    broadcast({ event: 'reload', ext: ext, url: url })
+  }
+
+  function broadcast (data) {
+    if (closed) return
+    data = JSON.stringify(data)
+    try {
+      wss.clients.forEach(function (client) {
+        client.send(data, {
+          binary: false
+        })
+      })
+    } catch (err) {
+      console.error(color.red('ERROR'), 'Error sending LiveReload event to client:')
+      console.error(err)
+    }
+  }
+}