@jsenv/core 27.0.0-alpha.8 → 27.0.0-alpha.82

package/src/build/plugins/bundle_js_module/jsenv_plugin_bundle_js_module.js

@@ -1,227 +0,0 @@
-import { isFileSystemPath, urlToRelativeUrl } from "@jsenv/filesystem"
-
-import { applyRollupPlugins } from "@jsenv/utils/js_ast/apply_rollup_plugins.js"
-import { sourcemapConverter } from "@jsenv/utils/sourcemap/sourcemap_converter.js"
-import { fileUrlConverter } from "@jsenv/core/src/omega/file_url_converter.js"
-
-export const jsenvPluginBundleJsModule = () => {
-  return {
-    name: "jsenv:bundle_js_module",
-    appliesDuring: {
-      build: true,
-    },
-    bundle: {
-      js_module: async (
-        jsModuleUrlInfos,
-        {
-          signal,
-          logger,
-          rootDirectoryUrl,
-          buildDirectoryUrl,
-          urlGraph,
-          runtimeSupport,
-          sourcemaps,
-        },
-      ) => {
-        const { jsModuleBundleUrlInfos } = await buildWithRollup({
-          signal,
-          logger,
-          rootDirectoryUrl,
-          buildDirectoryUrl,
-          urlGraph,
-          jsModuleUrlInfos,
-
-          runtimeSupport,
-          sourcemaps,
-        })
-        return jsModuleBundleUrlInfos
-      },
-    },
-  }
-}
-
-export const buildWithRollup = async ({
-  signal,
-  logger,
-  rootDirectoryUrl,
-  buildDirectoryUrl,
-  urlGraph,
-  jsModuleUrlInfos,
-
-  runtimeSupport,
-  sourcemaps,
-}) => {
-  const resultRef = { current: null }
-  await applyRollupPlugins({
-    rollupPlugins: [
-      rollupPluginJsenv({
-        signal,
-        logger,
-        rootDirectoryUrl,
-        buildDirectoryUrl,
-        urlGraph,
-        jsModuleUrlInfos,
-
-        runtimeSupport,
-        sourcemaps,
-        resultRef,
-      }),
-    ],
-    inputOptions: {
-      input: [],
-      onwarn: (warning) => {
-        if (warning.code === "CIRCULAR_DEPENDENCY") {
-          return
-        }
-        logger.warn(String(warning))
-      },
-    },
-  })
-  return resultRef.current
-}
-
-const rollupPluginJsenv = ({
-  // logger,
-  rootDirectoryUrl,
-  buildDirectoryUrl,
-  urlGraph,
-  jsModuleUrlInfos,
-  sourcemaps,
-
-  resultRef,
-}) => {
-  let _rollupEmitFile = () => {
-    throw new Error("not implemented")
-  }
-  const emitChunk = (chunk) => {
-    return _rollupEmitFile({
-      type: "chunk",
-      ...chunk,
-    })
-  }
-  const urlImporters = {}
-
-  return {
-    name: "jsenv",
-    async buildStart() {
-      _rollupEmitFile = (...args) => this.emitFile(...args)
-      let previousNonEntryPointModuleId
-      jsModuleUrlInfos.forEach((jsModuleUrlInfo) => {
-        const id = jsModuleUrlInfo.url
-        if (jsModuleUrlInfo.data.isEntryPoint) {
-          emitChunk({
-            id,
-          })
-          return
-        }
-        emitChunk({
-          id,
-          implicitlyLoadedAfterOneOf: previousNonEntryPointModuleId
-            ? [previousNonEntryPointModuleId]
-            : null,
-        })
-        previousNonEntryPointModuleId = id
-      })
-    },
-    async generateBundle(outputOptions, rollupResult) {
-      _rollupEmitFile = (...args) => this.emitFile(...args)
-
-      const jsModuleBundleUrlInfos = {}
-      Object.keys(rollupResult).forEach((fileName) => {
-        const rollupFileInfo = rollupResult[fileName]
-        // there is 3 types of file: "placeholder", "asset", "chunk"
-        if (rollupFileInfo.type === "chunk") {
-          const jsModuleBundleUrlInfo = {
-            // buildRelativeUrl: rollupFileInfo.fileName,
-            data: {
-              generatedBy: "rollup",
-            },
-            contentType: "application/javascript",
-            content: rollupFileInfo.code,
-            sourcemap: rollupFileInfo.map,
-          }
-          let url
-          if (rollupFileInfo.facadeModuleId) {
-            url = fileUrlConverter.asFileUrl(rollupFileInfo.facadeModuleId)
-          } else {
-            url = new URL(rollupFileInfo.fileName, rootDirectoryUrl).href
-          }
-          jsModuleBundleUrlInfos[url] = jsModuleBundleUrlInfo
-        }
-      })
-      resultRef.current = {
-        jsModuleBundleUrlInfos,
-      }
-    },
-    outputOptions: (outputOptions) => {
-      // const sourcemapFile = buildDirectoryUrl
-      Object.assign(outputOptions, {
-        format: "esm",
-        dir: fileUrlConverter.asFilePath(buildDirectoryUrl),
-        sourcemap: sourcemaps === "file" || sourcemaps === "inline",
-        // sourcemapFile,
-        sourcemapPathTransform: (relativePath) => {
-          return new URL(relativePath, buildDirectoryUrl).href
-        },
-        entryFileNames: () => {
-          return `[name].js`
-        },
-        chunkFileNames: (chunkInfo) => {
-          // preserves relative path parts:
-          // the goal is to maintain the original relative path (relative to the root directory)
-          // so that later in the build process, when resolving these urls, we are able to
-          // re-resolve the specifier againt the original parent url and find the original url
-          if (chunkInfo.facadeModuleId) {
-            const fileUrl = fileUrlConverter.asFileUrl(chunkInfo.facadeModuleId)
-            const relativePath = urlToRelativeUrl(fileUrl, rootDirectoryUrl)
-            return relativePath
-          }
-          // chunk generated dynamically by rollup to share code.
-          // we prefix with "__rollup__/" to avoid potential conflict of filename
-          // between this one and a file with the same name existing in the root directory
-          return `__rollup__/${chunkInfo.name}.js`
-        },
-        // https://rollupjs.org/guide/en/#outputpaths
-        // paths: (id) => {
-        //   return id
-        // },
-      })
-    },
-    resolveId: (specifier, importer = rootDirectoryUrl) => {
-      if (isFileSystemPath(importer)) {
-        importer = fileUrlConverter.asFileUrl(importer)
-      }
-      const url = new URL(specifier, importer).href
-      const existingImporter = urlImporters[url]
-      if (!existingImporter) {
-        urlImporters[url] = importer
-      }
-      if (!url.startsWith("file:")) {
-        return { url, external: true }
-      }
-      const filePath = fileUrlConverter.asFilePath(url)
-      return filePath
-    },
-    async load(rollupId) {
-      const fileUrl = fileUrlConverter.asFileUrl(rollupId)
-      const urlInfo = urlGraph.getUrlInfo(fileUrl)
-      return {
-        code: urlInfo.content,
-        map: urlInfo.sourcemap
-          ? sourcemapConverter.toFilePaths(urlInfo.sourcemap)
-          : urlInfo.sourcemap,
-      }
-    },
-    // resolveFileUrl: ({ moduleId }) => {
-    //   return `${fileUrlConverter.asFileUrl(moduleId)}`
-    // },
-    renderChunk: (code, chunkInfo) => {
-      const { facadeModuleId } = chunkInfo
-      if (!facadeModuleId) {
-        // happens for inline module scripts for instance
-        return null
-      }
-      return null
-    },
-  }
-}

package/src/build/plugins/minify_html/jsenv_plugin_minify_html.js

@@ -1,30 +0,0 @@
-import { createRequire } from "node:module"
-
-const require = createRequire(import.meta.url)
-
-// https://github.com/kangax/html-minifier#options-quick-reference
-export const jsenvPluginMinifyHtml = ({
-  collapseWhitespace = true,
-  removeComments = true,
-} = {}) => {
-  return {
-    name: "jsenv:minify_html",
-    appliesDuring: {
-      build: true,
-    },
-    optimize: {
-      html: async (htmlUrlInfo) => {
-        return minifyHtml(htmlUrlInfo.content, {
-          collapseWhitespace,
-          removeComments,
-        })
-      },
-    },
-  }
-}
-
-const minifyHtml = (htmlString, options) => {
-  const { minify } = require("html-minifier")
-  const htmlMinified = minify(htmlString, options)
-  return htmlMinified
-}

package/src/dev/plugins/autoreload/client/event_source_connection.js

@@ -1,195 +0,0 @@
-export const createEventSourceConnection = (
-  eventSourceUrl,
-  events = {},
-  { retryMaxAttempt = Infinity, retryAllocatedMs = Infinity, lastEventId } = {},
-) => {
-  const { EventSource } = window
-  if (typeof EventSource !== "function") {
-    return () => {}
-  }
-
-  const eventSourceOrigin = new URL(eventSourceUrl).origin
-  Object.keys(events).forEach((eventName) => {
-    const eventCallback = events[eventName]
-    events[eventName] = (e) => {
-      if (e.origin === eventSourceOrigin) {
-        if (e.lastEventId) {
-          lastEventId = e.lastEventId
-        }
-        eventCallback(e)
-      }
-    }
-  })
-
-  const status = {
-    value: "default",
-    goTo: (value) => {
-      if (value === status.value) {
-        return
-      }
-      status.value = value
-      status.onchange()
-    },
-    onchange: () => {},
-  }
-  let _disconnect = () => {}
-
-  const attemptConnection = (url) => {
-    const eventSource = new EventSource(url, {
-      withCredentials: true,
-    })
-    _disconnect = () => {
-      if (status.value !== "connecting" && status.value !== "connected") {
-        console.warn(
-          `disconnect() ignored because connection is ${status.value}`,
-        )
-        return
-      }
-      eventSource.onerror = undefined
-      eventSource.close()
-      Object.keys(events).forEach((eventName) => {
-        eventSource.removeEventListener(eventName, events[eventName])
-      })
-      status.goTo("disconnected")
-    }
-    let retryCount = 0
-    let firstRetryMs = Date.now()
-    eventSource.onerror = (errorEvent) => {
-      if (errorEvent.target.readyState === EventSource.CONNECTING) {
-        if (retryCount > retryMaxAttempt) {
-          console.info(`could not connect after ${retryMaxAttempt} attempt`)
-          _disconnect()
-          return
-        }
-
-        if (retryCount === 0) {
-          firstRetryMs = Date.now()
-        } else {
-          const allRetryDuration = Date.now() - firstRetryMs
-          if (retryAllocatedMs && allRetryDuration > retryAllocatedMs) {
-            console.info(
-              `could not connect in less than ${retryAllocatedMs} ms`,
-            )
-            _disconnect()
-            return
-          }
-        }
-
-        retryCount++
-        status.goTo("connecting")
-        return
-      }
-
-      if (errorEvent.target.readyState === EventSource.CLOSED) {
-        _disconnect()
-        return
-      }
-    }
-    eventSource.onopen = () => {
-      status.goTo("connected")
-    }
-    Object.keys(events).forEach((eventName) => {
-      eventSource.addEventListener(eventName, events[eventName])
-    })
-    if (!events.hasOwnProperty("welcome")) {
-      eventSource.addEventListener("welcome", (e) => {
-        if (e.origin === eventSourceOrigin && e.lastEventId) {
-          lastEventId = e.lastEventId
-        }
-      })
-    }
-    status.goTo("connecting")
-  }
-
-  let connect = () => {
-    attemptConnection(eventSourceUrl)
-    connect = () => {
-      attemptConnection(
-        lastEventId
-          ? addLastEventIdIntoUrlSearchParams(eventSourceUrl, lastEventId)
-          : eventSourceUrl,
-      )
-    }
-  }
-
-  const removePageUnloadListener = listenPageUnload(() => {
-    if (status.value === "connecting" || status.value === "connected") {
-      _disconnect()
-    }
-  })
-
-  const destroy = () => {
-    removePageUnloadListener()
-    _disconnect()
-  }
-
-  return {
-    status,
-    connect,
-    disconnect: () => _disconnect(),
-    destroy,
-  }
-}
-
-const addLastEventIdIntoUrlSearchParams = (url, lastEventId) => {
-  if (url.indexOf("?") === -1) {
-    url += "?"
-  } else {
-    url += "&"
-  }
-  return `${url}last-event-id=${encodeURIComponent(lastEventId)}`
-}
-
-// const listenPageMightFreeze = (callback) => {
-//   const removePageHideListener = listenEvent(window, "pagehide", (pageHideEvent) => {
-//     if (pageHideEvent.persisted === true) {
-//       callback(pageHideEvent)
-//     }
-//   })
-//   return removePageHideListener
-// }
-
-// const listenPageFreeze = (callback) => {
-//   const removeFreezeListener = listenEvent(document, "freeze", (freezeEvent) => {
-//     callback(freezeEvent)
-//   })
-//   return removeFreezeListener
-// }
-
-// const listenPageIsRestored = (callback) => {
-//   const removeResumeListener = listenEvent(document, "resume", (resumeEvent) => {
-//     removePageshowListener()
-//     callback(resumeEvent)
-//   })
-//   const removePageshowListener = listenEvent(window, "pageshow", (pageshowEvent) => {
-//     if (pageshowEvent.persisted === true) {
-//       removePageshowListener()
-//       removeResumeListener()
-//       callback(pageshowEvent)
-//     }
-//   })
-//   return () => {
-//     removeResumeListener()
-//     removePageshowListener()
-//   }
-// }
-
-const listenPageUnload = (callback) => {
-  const removePageHideListener = listenEvent(
-    window,
-    "pagehide",
-    (pageHideEvent) => {
-      if (pageHideEvent.persisted !== true) {
-        callback(pageHideEvent)
-      }
-    },
-  )
-  return removePageHideListener
-}
-
-const listenEvent = (emitter, event, callback) => {
-  emitter.addEventListener(event, callback)
-  return () => {
-    emitter.removeEventListener(event, callback)
-  }
-}