@jsenv/core 24.1.0-alpha.0 → 24.3.1

package/src/internal/toolbar/backtolist/toolbar.backtolist.js

@@ -1,33 +0,0 @@
-export const renderBackToListInToolbar = ({
-  outDirectoryRelativeUrl,
-  exploringHtmlFileRelativeUrl,
-}) => {
-  const exploringHtmlFileUrl = `/${outDirectoryRelativeUrl}otherwise/${exploringHtmlFileRelativeUrl}`
-
-  document.querySelector("#file-list-link a").href = exploringHtmlFileUrl
-  document.querySelector("#file-list-link a").onclick = (clickEvent) => {
-    if (clickEvent.defaultPrevented) {
-      return
-    }
-
-    if (isClickToOpenTab(clickEvent)) {
-      return
-    }
-
-    window.parent.location.href = exploringHtmlFileUrl
-  }
-}
-
-const isClickToOpenTab = (clickEvent) => {
-  if (clickEvent.button !== 0) {
-    // Chrome < 55 fires a click event when the middle mouse button is pressed
-    return true
-  }
-  if (clickEvent.metaKey) {
-    return true
-  }
-  if (clickEvent.ctrlKey) {
-    return true
-  }
-  return false
-}

package/src/internal/toolbar/eventsource/connectCompileServerEventSource.js

@@ -1,74 +0,0 @@
-import { connectEventSource } from "./connectEventSource.js"
-import { jsenvLogger } from "../util/jsenvLogger.js"
-
-export const connectCompileServerEventSource = (
-  fileRelativeUrl,
-  {
-    onFileModified,
-    onFileRemoved,
-    onConnecting,
-    onConnectionCancelled,
-    onConnectionFailed,
-    onConnected,
-    lastEventId,
-  },
-) => {
-  const eventSourceUrl = `${window.origin}/${fileRelativeUrl}`
-
-  let cancel = () => {}
-
-  const connect = () => {
-    return new Promise((resolve) => {
-      cancel = connectEventSource(
-        eventSourceUrl,
-        {
-          "file-modified": ({ data }) => {
-            jsenvLogger.debug(`${data} modified`)
-            onFileModified(data)
-          },
-          "file-removed": ({ data }) => {
-            jsenvLogger.debug(`${data} removed`)
-            onFileRemoved(data)
-          },
-        },
-        {
-          connecting: ({ cancel }) => {
-            jsenvLogger.debug(`connecting to ${eventSourceUrl}`)
-            onConnecting({
-              cancel: () => {
-                cancel()
-              },
-            })
-          },
-          connected: ({ cancel }) => {
-            jsenvLogger.debug(`connected to ${eventSourceUrl}`)
-            resolve(true)
-            onConnected({
-              cancel: () => {
-                cancel()
-              },
-            })
-          },
-          cancelled: ({ connect }) => {
-            jsenvLogger.debug(`disconnected from ${eventSourceUrl}`)
-            resolve(false)
-            onConnectionCancelled({ connect })
-          },
-          failed: ({ connect }) => {
-            jsenvLogger.debug(`disconnected from ${eventSourceUrl}`)
-            resolve(false)
-            onConnectionFailed({ connect })
-          },
-          retryMaxAttempt: Infinity,
-          retryAllocatedMs: 20 * 1000,
-          lastEventId,
-        },
-      )
-    })
-  }
-
-  return {
-    connect,
-    disconnect: () => cancel(),
-  }
-}

package/src/internal/toolbar/eventsource/toolbar.eventsource.js

@@ -1,239 +0,0 @@
-import { removeForceHideElement } from "../util/dom.js"
-import { createPromiseAndHooks } from "../util/util.js"
-import { createPreference } from "../util/preferences.js"
-import { enableVariant } from "../variant/variant.js"
-
-import {
-  toggleTooltip,
-  removeAutoShowTooltip,
-  autoShowTooltip,
-} from "../tooltip/tooltip.js"
-import { connectCompileServerEventSource } from "./connectCompileServerEventSource.js"
-
-const livereloadingPreference = createPreference("livereloading")
-let eventSourceState = "default"
-let livereloadingAvailableOnServer = false
-
-export const initToolbarEventSource = ({
-  executedFileRelativeUrl,
-  livereloading,
-}) => {
-  const getLivereloadCallback = (originalFileProjectRelativeUrl) => {
-    const callbacks = window.parent.__jsenv__.livereloadingCallbacks
-    return callbacks[originalFileProjectRelativeUrl]
-  }
-
-  removeForceHideElement(document.querySelector("#eventsource-indicator"))
-  connectEventSource({ executedFileRelativeUrl, getLivereloadCallback })
-  livereloadingAvailableOnServer = livereloading
-  if (!livereloadingAvailableOnServer) {
-    disableLivereloadSetting()
-  }
-
-  const livereloadCheckbox = document.querySelector("#toggle-livereload")
-  livereloadCheckbox.checked = shouldLivereload()
-  livereloadCheckbox.onchange = () => {
-    livereloadingPreference.set(livereloadCheckbox.checked)
-    updateEventSourceIndicator()
-  }
-  updateEventSourceIndicator()
-}
-
-const shouldLivereload = () => {
-  return livereloadingAvailableOnServer && getLivereloadingPreference()
-}
-
-const disableLivereloadSetting = () => {
-  document
-    .querySelector(".settings-livereload")
-    .setAttribute("data-disabled", "true")
-  document
-    .querySelector(".settings-livereload")
-    .setAttribute("title", `Livereload not available: disabled by server`)
-  document.querySelector("#toggle-livereload").disabled = true
-}
-
-const parentEventSource = window.parent.__jsenv_eventsource__()
-const latestChangeMap = parentEventSource.latestChangeMap
-let eventSourceHooks = {}
-let eventSourceConnection
-let connectionReadyPromise
-
-const handleFileChange = ({ file, eventType, livereloadCallback }) => {
-  latestChangeMap[file] = eventType
-  updateEventSourceIndicator()
-
-  if (shouldLivereload()) {
-    if (livereloadCallback) {
-      livereloadCallback({
-        file,
-        latestChangeMap,
-        reloadPage,
-      })
-    } else if (
-      file.endsWith(".css") ||
-      file.endsWith(".scss") ||
-      file.endsWith(".sass")
-    ) {
-      reloadAllCss()
-      delete latestChangeMap[file]
-      updateEventSourceIndicator()
-    } else {
-      reloadPage()
-    }
-  }
-}
-
-const reloadAllCss = () => {
-  const links = Array.from(window.parent.document.getElementsByTagName("link"))
-  links.forEach((link) => {
-    if (link.rel === "stylesheet") {
-      const url = new URL(link.href)
-      url.searchParams.set("t", Date.now())
-      link.href = String(url)
-    }
-  })
-}
-
-const reloadPage = () => {
-  window.parent.location.reload(true)
-}
-
-const reloadChanges = () => {
-  const fullReloadRequired = Object.keys(latestChangeMap).some(
-    (key) => !key.endsWith(".css"),
-  )
-  if (fullReloadRequired) {
-    reloadPage()
-    return
-  }
-  const cssReloadRequired = Object.keys(latestChangeMap).some((key) =>
-    key.endsWith(".css"),
-  )
-  if (cssReloadRequired) {
-    reloadAllCss()
-    Object.keys(latestChangeMap).forEach((key) => {
-      if (key.endsWith(".css")) {
-        delete latestChangeMap[key]
-      }
-      updateEventSourceIndicator()
-    })
-  }
-}
-
-const connectEventSource = ({
-  executedFileRelativeUrl,
-  getLivereloadCallback,
-}) => {
-  updateEventSourceIndicator()
-  connectionReadyPromise = createPromiseAndHooks()
-
-  eventSourceConnection = connectCompileServerEventSource(
-    executedFileRelativeUrl,
-    {
-      onFileModified: (file) => {
-        handleFileChange({
-          file,
-          eventType: "modified",
-          livereloadCallback: getLivereloadCallback(file),
-        })
-      },
-      onFileRemoved: (file) => {
-        handleFileChange({
-          file,
-          eventType: "removed",
-          livereloadCallback: getLivereloadCallback(file),
-        })
-      },
-      onFileAdded: (file) => {
-        handleFileChange({
-          file,
-          eventType: "added",
-          livereloadCallback: getLivereloadCallback(file),
-        })
-      },
-      onConnecting: ({ cancel }) => {
-        eventSourceState = "connecting"
-        eventSourceHooks = { abort: cancel }
-        updateEventSourceIndicator()
-      },
-      onConnectionCancelled: ({ connect }) => {
-        eventSourceState = "disabled"
-        eventSourceHooks = { connect }
-        updateEventSourceIndicator()
-      },
-      onConnectionFailed: ({ connect }) => {
-        eventSourceState = "failed"
-        eventSourceHooks = { reconnect: connect }
-        updateEventSourceIndicator()
-      },
-      onConnected: ({ cancel }) => {
-        eventSourceState = "connected"
-        eventSourceHooks = { disconnect: cancel }
-        updateEventSourceIndicator()
-        connectionReadyPromise.resolve()
-        parentEventSource.disconnect()
-      },
-      lastEventId: parentEventSource.lastEventId,
-    },
-  )
-
-  eventSourceConnection.connect()
-}
-
-const getLivereloadingPreference = () => {
-  return livereloadingPreference.has() ? livereloadingPreference.get() : true
-}
-
-export const disconnectEventSource = () => {
-  if (eventSourceConnection) {
-    eventSourceConnection.disconnect()
-    eventSourceConnection = undefined
-  }
-}
-
-export const waitEventSourceReady = () => connectionReadyPromise
-
-const updateEventSourceIndicator = () => {
-  const { connect, abort, reconnect } = eventSourceHooks
-
-  const eventSourceIndicator = document.querySelector("#eventsource-indicator")
-  const changeCount = Object.keys(latestChangeMap).length
-  enableVariant(eventSourceIndicator, {
-    eventsource: eventSourceState,
-    livereload: shouldLivereload() ? "on" : "off",
-    changes: changeCount > 0 ? "yes" : "no",
-  })
-
-  const variantNode = document.querySelector(
-    "#eventsource-indicator > [data-when-active]",
-  )
-  variantNode.querySelector("button").onclick = () => {
-    toggleTooltip(eventSourceIndicator)
-  }
-
-  if (eventSourceState === "disabled") {
-    variantNode.querySelector("a").onclick = connect
-  } else if (eventSourceState === "connecting") {
-    variantNode.querySelector("a").onclick = abort
-  } else if (eventSourceState === "connected") {
-    removeAutoShowTooltip(eventSourceIndicator)
-    if (changeCount) {
-      const changeLink = variantNode.querySelector(".eventsource-changes-link")
-      changeLink.innerHTML = changeCount
-      changeLink.onclick = () => {
-        console.log(
-          JSON.stringify(latestChangeMap, null, "  "),
-          latestChangeMap,
-        )
-        // eslint-disable-next-line no-alert
-        window.parent.alert(JSON.stringify(latestChangeMap, null, "  "))
-      }
-      variantNode.querySelector(".eventsource-reload-link").onclick =
-        reloadChanges
-    }
-  } else if (eventSourceState === "failed") {
-    autoShowTooltip(eventSourceIndicator)
-    variantNode.querySelector("a").onclick = reconnect
-  }
-}

package/src/internal/toolbar/notification/toolbar.notification.js

@@ -1,121 +0,0 @@
-import { createPreference } from "../util/preferences.js"
-
-const notificationPreference = createPreference("notification")
-
-const arrayOfOpenedNotifications = []
-export const renderToolbarNotification = () => {
-  const notifCheckbox = document.querySelector("#toggle-notifs")
-  notifCheckbox.checked = getNotificationPreference()
-  notifCheckbox.onchange = () => {
-    setNotificationPreference(notifCheckbox.checked)
-    if (notifCheckbox.checked) {
-      // request permission early
-      // especially useful on firefox where you can request permission
-      // only inside a user generated event such as this onchange handler
-      requestPermission()
-    } else {
-      // slice because arrayOfOpenedNotifications can be mutated while looping
-      arrayOfOpenedNotifications.slice().forEach((notification) => {
-        notification.close()
-      })
-    }
-  }
-}
-
-export const notifyExecutionResult = (
-  executedFileRelativeUrl,
-  execution,
-  previousExecution,
-) => {
-  const notificationEnabled = getNotificationPreference()
-  if (!notificationEnabled) return
-
-  const notificationOptions = {
-    lang: "en",
-    icon: getFaviconHref(),
-    clickToFocus: true,
-    clickToClose: true,
-  }
-
-  if (execution.status === "errored") {
-    if (previousExecution) {
-      if (previousExecution.status === "completed") {
-        notify("Broken", {
-          ...notificationOptions,
-          body: `${executedFileRelativeUrl} execution now failing.`,
-        })
-      } else {
-        notify("Still failing", {
-          ...notificationOptions,
-          body: `${executedFileRelativeUrl} execution still failing.`,
-        })
-      }
-    } else {
-      notify("Failing", {
-        ...notificationOptions,
-        body: `${executedFileRelativeUrl} execution failed.`,
-      })
-    }
-  } else if (previousExecution && previousExecution.status === "errored") {
-    notify("Fixed", {
-      ...notificationOptions,
-      body: `${executedFileRelativeUrl} execution fixed.`,
-    })
-  }
-}
-
-const notificationAvailable = typeof window.Notification === "function"
-
-const getNotificationPreference = () =>
-  notificationPreference.has() ? notificationPreference.get() : true
-
-const setNotificationPreference = (value) => notificationPreference.set(value)
-
-const getFaviconHref = () => {
-  const link = document.querySelector('link[rel="icon"]')
-  return link ? link.href : undefined
-}
-
-const notify = notificationAvailable
-  ? async (
-      title,
-      { clickToFocus = false, clickToClose = false, ...options } = {},
-    ) => {
-      const permission = await requestPermission()
-      if (permission === "granted") {
-        const notification = new Notification(title, options)
-        arrayOfOpenedNotifications.push(notification)
-        notification.onclick = () => {
-          // but if the user navigated inbetween
-          // focusing window will show something else
-          // in that case it could be great to do something
-          // maybe like showing a message saying this execution
-          // is no longer visible
-          // we could also navigauate to this file execution but
-          // there is no guarantee re-executing the file would give same output
-          // and it would also trigger an other notification
-          if (clickToFocus) window.focus()
-          if (clickToClose) notification.close()
-        }
-        notification.onclose = () => {
-          const index = arrayOfOpenedNotifications.indexOf(notification)
-          if (index > -1) {
-            arrayOfOpenedNotifications.splice(index, 1)
-          }
-        }
-        return notification
-      }
-      return null
-    }
-  : () => {}
-
-let permissionPromise
-const requestPermission = notificationAvailable
-  ? async () => {
-      if (permissionPromise) return permissionPromise
-      permissionPromise = Notification.requestPermission()
-      const permission = await permissionPromise
-      permissionPromise = undefined
-      return permission
-    }
-  : () => Promise.resolve("denied")

package/src/nodeRuntime.js

@@ -1,5 +0,0 @@
-import { createNodeRuntime } from "./internal/runtime/createNodeRuntime/createNodeRuntime.js"
-
-export const nodeRuntime = {
-  create: createNodeRuntime,
-}