@lvce-editor/server 0.4.2 → 0.4.4

package/static/{db64c60 → 3d96d42}/packages/renderer-worker/src/parts/Developer/Developer.js

@@ -1,17 +1,13 @@
-import prettyBytes from '../../../static/js/pretty-bytes.js'
 import * as ColorTheme from '../ColorTheme/ColorTheme.js'
 import * as Command from '../Command/Command.js'
+import * as ElectronWindow from '../ElectronWindow/ElectronWindow.js'
 import * as IconTheme from '../IconTheme/IconTheme.js'
 import * as Platform from '../Platform/Platform.js'
+import * as PlatformType from '../PlatformType/PlatformType.js'
+import * as ProcessExplorer from '../ProcessExplorer/ProcessExplorer.js'
 import * as RendererProcess from '../RendererProcess/RendererProcess.js'
 import * as SharedProcess from '../SharedProcess/SharedProcess.js'
-import * as ElectronWindow from '../ElectronWindow/ElectronWindow.js'
-import * as ElectronWindowProcessExplorer from '../ElectronWindowProcessExplorer/ElectronWindowProcessExplorer.js'
-import * as PlatformType from '../PlatformType/PlatformType.js'
-
-const formatBytes = (bytes) => {
-  return prettyBytes(bytes)
-}
+import * as PrettyBytes from '../PrettyBytes/PrettyBytes.js'
 
 // TODO vscode's version of this is shorter
 // if it is a bottleneck, check performance of this function (not very optimized now)
@@ -271,13 +267,12 @@ const formatNodeMemoryUsage = (memoryUsage) => {
   }
   const header = ['Name', 'Memory']
   const rows = Object.entries(memoryUsage).map(([key, value]) => {
-    return [key, formatBytes(value)]
+    return [key, PrettyBytes.formatBytes(value)]
   })
   return toMarkdownTable(header, rows)
 }
 
 const formatRendererWorkerData = ({
-  memory,
   userAgentSpecificMemory,
   sent,
   received,
@@ -287,27 +282,20 @@ const formatRendererWorkerData = ({
     const header = ['Name', 'Value']
     const rows = []
     if (userAgentSpecificMemory.bytes) {
-      rows.push(['Bytes', formatBytes(userAgentSpecificMemory.bytes)])
+      rows.push([
+        'Bytes',
+        PrettyBytes.formatBytes(userAgentSpecificMemory.bytes),
+      ])
     }
     if (userAgentSpecificMemory.breakdown) {
       for (const item of userAgentSpecificMemory.breakdown) {
         if (!item.bytes) {
           continue
         }
-        rows.push([item.types[0] || 'n/a', formatBytes(item.bytes)])
+        rows.push([item.types[0] || 'n/a', PrettyBytes.formatBytes(item.bytes)])
       }
     }
     content += toMarkdownTable(header, rows)
-  } else if (memory) {
-    const header = ['Name', 'Value']
-    const rows = [
-      ['jsHeapSizeLimit', formatBytes(memory.jsHeapSizeLimit)],
-      ['Total JS HeapSize', formatBytes(memory.totalJSHeapSize)],
-      ['Used JS HeapSize', formatBytes(memory.usedJSHeapSize)],
-      ['Sent', formatBytes(sent)],
-      ['Received', formatBytes(received)],
-    ]
-    content += toMarkdownTable(header, rows)
   }
   return content
 }
@@ -318,49 +306,25 @@ const formatRendererProcessData = ({ memoryUsage }) => {
   }
   const header = ['Name', 'Value']
   const rows = [
-    ['jsHeapSizeLimit', formatBytes(memoryUsage.jsHeapSizeLimit)],
-    ['Total JS HeapSize', formatBytes(memoryUsage.totalJSHeapSize)],
-    ['Used JS HeapSize', formatBytes(memoryUsage.usedJSHeapSize)],
+    ['jsHeapSizeLimit', PrettyBytes.formatBytes(memoryUsage.jsHeapSizeLimit)],
+    ['Total JS HeapSize', PrettyBytes.formatBytes(memoryUsage.totalJSHeapSize)],
+    ['Used JS HeapSize', PrettyBytes.formatBytes(memoryUsage.usedJSHeapSize)],
   ]
   return toMarkdownTable(header, rows)
 }
 
-const getRendererWorkerMemoryUsage = async () => {
-  let userAgentSpecificMemory
-  let memory
-  // @ts-ignore
-  if (performance && performance.memory) {
-    // @ts-ignore
-    memory = performance.memory
-  }
-  // @ts-ignore
-  if (performance && performance.measureUserAgentSpecificMemory) {
-    // @ts-ignore
-    userAgentSpecificMemory = await performance.measureUserAgentSpecificMemory()
-  }
-  return {
-    memory,
-    userAgentSpecificMemory,
-  }
-}
-
 const getSharedProcessMemoryUsage = () => {
   return SharedProcess.invoke(
     /* Developer.sharedProcessMemoryUsage */ 'Developer.sharedProcessMemoryUsage'
   )
 }
 
-const getRendererProcessMemoryUsage = async () => {
-  const memoryUsage = await RendererProcess.invoke(
-    /* Developer.getMemoryUsage */ 284
-  )
-  return memoryUsage
+const getPerformanceMemory = () => {
+  return RendererProcess.invoke('Performance.getMemory')
 }
 
-const getExtensionHostMemoryUsage = async () => {
-  return SharedProcess.invoke(
-    /* ExtensionHost.getMemoryUsage */ 'ExtensionHost.getMemoryUsage'
-  )
+const getPerformanceUserAgentSpecificMemory = () => {
+  return RendererProcess.invoke('Performance.measureUserAgentSpecificMemory')
 }
 
 // TODO handle case when renderer process and renderer worker are same process communicating via messagePort
@@ -369,33 +333,26 @@ export const getMemoryUsageContent = async () => {
   const formattedSharedProcessMemoryUsage = formatNodeMemoryUsage(
     sharedProcessMemoryUsage
   )
-  const extensionHostMemoryUsage = await getExtensionHostMemoryUsage()
-  const formattedExtensionHostMemoryUsage = formatNodeMemoryUsage(
-    extensionHostMemoryUsage
-  )
-  const rendererWorkerMemoryUsage = await getRendererWorkerMemoryUsage()
+  const userAgentSpecificMemory = await getPerformanceUserAgentSpecificMemory()
   const totalSent = SharedProcess.state.totalSent
   const totalReceived = SharedProcess.state.totalReceived
   const formattedRendererWorkerMemoryUsage = formatRendererWorkerData({
-    memory: rendererWorkerMemoryUsage.memory,
-    userAgentSpecificMemory: rendererWorkerMemoryUsage.userAgentSpecificMemory,
+    userAgentSpecificMemory,
     sent: totalSent,
     received: totalReceived,
   })
-  const rendererProcessMemoryUsage = await getRendererProcessMemoryUsage()
+  const rendererProcessMemoryUsage = await getPerformanceMemory()
   const formattedRendererProcessMemoryUsage = formatRendererProcessData({
     memoryUsage: rendererProcessMemoryUsage,
   })
 
   const isWorker = typeof WorkerGlobalScope !== 'undefined'
+  console.log({ isWorker, rendererWorkerMemoryUsage: userAgentSpecificMemory })
   const text = isWorker
     ? `## Shared Process
 
 ${formattedSharedProcessMemoryUsage}
 
-## Extension Host
-
-${formattedExtensionHostMemoryUsage}
 
 ## Renderer Worker
 
@@ -413,31 +370,26 @@ ${formattedRendererWorkerMemoryUsage}
 
 ${formattedSharedProcessMemoryUsage}
 
-## Extension Host
-
-${formattedExtensionHostMemoryUsage}
-
-
 `
   return text
 }
 
-export const showMemoryUsage = async () => {
-  await Command.execute(
+export const showMemoryUsage = () => {
+  return Command.execute(
     /* Main.openUri */ 'Main.openUri',
     /* uri */ 'app://memory-usage'
   )
 }
 
 // TODO not sure if this function is useful
-export const allocateMemoryInSharedProcess = async () => {
-  await SharedProcess.invoke(
+export const allocateMemoryInSharedProcess = () => {
+  return SharedProcess.invoke(
     /* Developer.allocateMemoryInSharedProcess */ 'Developer.allocateMemoryInSharedProcess'
   )
 }
 
-export const crashSharedProcess = async () => {
-  await SharedProcess.invoke(
+export const crashSharedProcess = () => {
+  return SharedProcess.invoke(
     /* Developer.crashSharedProcess */ 'Developer.crashSharedProcess'
   )
 }
@@ -446,8 +398,8 @@ export const crashRendererProcess = () => {}
 
 export const crashRendererWorker = () => {}
 
-export const crashMainProcess = async () => {
-  await SharedProcess.invoke(
+export const crashMainProcess = () => {
+  return SharedProcess.invoke(
     /* Electron.crashMainProcess */ 'Electron.crashMainProcess'
   )
 }
@@ -544,7 +496,7 @@ export const openDataFolder = async () => {
 export const showMessageBox = () => {}
 
 export const openProcessExplorer = () => {
-  return ElectronWindowProcessExplorer.open()
+  return ProcessExplorer.open()
 }
 
 export const downloadViewletState = async () => {