@lvce-editor/server 0.4.3 → 0.5.0

package/static/{2394f34 → 4d80653}/packages/renderer-worker/src/parts/Ajax/Ajax.js

@@ -1,8 +1,10 @@
 import ky, { HTTPError } from '../../../static/js/ky.js'
 import { VError } from '../VError/VError.js'
+import * as Assert from '../Assert/Assert.js'
 
 export const getJson = async (url, options = {}) => {
   try {
+    Assert.string(url)
     // cannot use ky(url).json() because it sets "accept: application/json"
     // which doesn't work with preload, see
     // https://stackoverflow.com/questions/41655955/why-are-preload-link-not-working-for-json-requests#answer-48645748

package/static/{2394f34 → 4d80653}/packages/renderer-worker/src/parts/Arrays/Arrays.js

@@ -23,3 +23,29 @@ export const splice = (array, start, deleteCount, newItems) => {
   insertInto(array, start, newItems)
   return result
 }
+
+export const last = (array) => {
+  return array[array.length - 1]
+}
+
+export const first = (array) => {
+  return array[0]
+}
+
+// TODO use this function more often
+export const firstIndex = (array) => {
+  return 0
+}
+
+// TODO use this function more often
+export const lastIndex = (array) => {
+  return array.length - 1
+}
+
+export const fromAsync = async (asyncIterable, mapFn) => {
+  const children = []
+  for await (const value of asyncIterable) {
+    children.push(mapFn(value))
+  }
+  return children
+}

package/static/{2394f34 → 4d80653}/packages/renderer-worker/src/parts/Base64/Base64.ipc.js

@@ -2,4 +2,5 @@ import * as Base64 from './Base64.js'
 
 export const Commands = {
   'Base64.decode': Base64.decode,
+  'Base64.encode': Base64.encode,
 }

package/static/4d80653/packages/renderer-worker/src/parts/Base64/Base64.js

@@ -0,0 +1,12 @@
+import * as JsBase64 from '../../../static/js/js-base64.js'
+
+export const decode = (encoded) => {
+  const decoded = JsBase64.decode(encoded)
+  return decoded
+}
+
+// TODO figure out if btoa could be a faster alternative to this
+export const encode = (content) => {
+  const encoded = JsBase64.encode(content)
+  return encoded
+}

package/static/{2394f34 → 4d80653}/packages/renderer-worker/src/parts/Blob/Blob.ipc.js

@@ -2,4 +2,6 @@ import * as Blob from './Blob.js'
 
 export const Commands = {
   'Blob.base64StringToBlob': Blob.base64StringToBlob,
+  'Blob.binaryStringToBlob': Blob.binaryStringToBlob,
+  'Blob.blobToBinaryString': Blob.blobToBinaryString,
 }

package/static/4d80653/packages/renderer-worker/src/parts/Blob/Blob.js

@@ -0,0 +1,13 @@
+import * as BlobUtil from '../../../static/js/blob-util.js'
+
+export const base64StringToBlob = (base64String) => {
+  return BlobUtil.base64StringToBlob(base64String)
+}
+
+export const binaryStringToBlob = (string, type) => {
+  return BlobUtil.binaryStringToBlob(string, type)
+}
+
+export const blobToBinaryString = (blob) => {
+  return BlobUtil.blobToBinaryString(blob)
+}

package/static/4d80653/packages/renderer-worker/src/parts/BrowserErrorTypes/BrowserErrorTypes.js

@@ -0,0 +1,10 @@
+export const BrowserErrorNames = {
+  NotAllowedError: 'NotAllowedError',
+  UnknownError: 'UnknownError',
+}
+
+export const isNotAllowedError = (error) => {
+  return error && error.name === BrowserErrorNames.NotAllowedError
+}
+
+// export const isUserActivationError

package/static/4d80653/packages/renderer-worker/src/parts/Clamp/Clamp.js

@@ -0,0 +1,3 @@
+export const clamp = (num, min, max) => {
+  return Math.min(Math.max(num, min), max)
+}

package/static/{2394f34 → 4d80653}/packages/renderer-worker/src/parts/ColorTheme/ColorTheme.js

@@ -5,6 +5,7 @@ import * as Platform from '../Platform/Platform.js'
 import * as Preferences from '../Preferences/Preferences.js'
 import * as SharedProcess from '../SharedProcess/SharedProcess.js'
 import * as PlatformType from '../PlatformType/PlatformType.js'
+import { VError } from '../VError/VError.js'
 
 // TODO by default color theme should come from local storage, session storage, cache storage, indexeddb or blob url -> fast initial load
 // actual color theme can be computed after workbench has loaded (most times will be the same and doesn't need to be computed)
@@ -33,9 +34,12 @@ const getColorThemeJsonFromSharedProcess = async (colorThemeId) => {
   )
 }
 
+const getColorThemeUrlWeb = (colorThemeId) => {
+  return `/extensions/builtin.theme-${colorThemeId}/color-theme.json`
+}
+
 const getColorThemeJsonFromStaticFolder = (colorThemeId) => {
-  const assetDir = Platform.getAssetDir()
-  const url = `${assetDir}/themes/${colorThemeId}.json`
+  const url = getColorThemeUrlWeb(colorThemeId)
   // TODO handle error ?
   return Command.execute(/* Ajax.getJson */ 'Ajax.getJson', /* url */ url)
 }
@@ -83,7 +87,7 @@ const applyColorTheme = async (colorThemeId) => {
       await Meta.setThemeColor(themeColor)
     }
   } catch (error) {
-    throw new Error(`Failed to apply color theme "${colorThemeId}": ${error}`)
+    throw new VError(error, `Failed to apply color theme "${colorThemeId}"`)
   }
 }
 

package/static/{2394f34 → 4d80653}/packages/renderer-worker/src/parts/Developer/Developer.js

@@ -1,17 +1,14 @@
-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'
+import * as ElectronDeveloper from '../ElectronDeveloper/ElectronDeveloper.js'
 
 // TODO vscode's version of this is shorter
 // if it is a bottleneck, check performance of this function (not very optimized now)
@@ -226,9 +223,7 @@ const getElectronEntries = async () => {
   ) {
     return undefined
   }
-  const result = await SharedProcess.invoke(
-    /* Electron.getPerformanceEntries */ 'Electron.getPerformanceEntries'
-  )
+  const result = await ElectronDeveloper.getPerformanceEntries()
   return result
 }
 
@@ -271,13 +266,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 +281,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 +305,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 +332,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 +369,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 +397,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 +495,7 @@ export const openDataFolder = async () => {
 export const showMessageBox = () => {}
 
 export const openProcessExplorer = () => {
-  return ElectronWindowProcessExplorer.open()
+  return ProcessExplorer.open()
 }
 
 export const downloadViewletState = async () => {

package/static/{2394f34 → 4d80653}/packages/renderer-worker/src/parts/Dialog/Dialog.js

@@ -4,13 +4,33 @@ import * as ElectronWindowAbout from '../ElectronWindowAbout/ElectronWindowAbout
 import * as Platform from '../Platform/Platform.js'
 import * as RendererProcess from '../RendererProcess/RendererProcess.js'
 import * as PlatformType from '../PlatformType/PlatformType.js'
+import { VError } from '../VError/VError.js'
 
 export const state = {
   dialog: undefined,
 }
 
-const openFolderWeb = () => {
-  console.warn('open folder - not implemented')
+const isAbortError = (error) => {
+  if (error && error.message === 'The user aborted a request.') {
+    return true
+  }
+  return false
+}
+
+const openFolderWeb = async () => {
+  try {
+    const result = await Command.execute('FilePicker.showDirectoryPicker', {
+      startIn: 'pictures',
+      mode: 'readwrite',
+    })
+    await Command.execute('PersistentFileHandle.addHandle', result)
+    await Command.execute('Workspace.setPath', `html://${result.name}`)
+  } catch (error) {
+    if (isAbortError(error)) {
+      return
+    }
+    throw new VError(error, `Failed to open folder`)
+  }
 }
 
 const openFolderRemote = async () => {

package/static/4d80653/packages/renderer-worker/src/parts/DiffDom/DiffDom.js

@@ -0,0 +1,23 @@
+const diffProps = (oldProps, newProps) => {}
+
+const diffNodes = (oldNodes, newNodes) => {}
+
+export const diffDom = (oldDom, newDom) => {
+  const oldChildCount = oldDom.children.length
+  const newChildCount = newDom.children.length
+  if (oldChildCount < newChildCount) {
+    // add some nodes
+  } else if (oldChildCount === newChildCount) {
+    // diff the nodes
+  } else {
+    // remove some nodes
+    return [
+      {
+        method: 'remove',
+        params: {
+          count: oldChildCount - newChildCount,
+        },
+      },
+    ]
+  }
+}

package/static/{2394f34 → 4d80653}/packages/renderer-worker/src/parts/Download/Download.js

@@ -2,6 +2,7 @@ import * as Assert from '../Assert/Assert.js'
 import * as Json from '../Json/Json.js'
 import * as RendererProcess from '../RendererProcess/RendererProcess.js'
 import { VError } from '../VError/VError.js'
+import * as Url from '../Url/Url.js'
 
 export const downloadFile = async (fileName, url) => {
   Assert.string(fileName)
@@ -20,11 +21,11 @@ export const downloadJson = async (json, fileName) => {
     const blob = new Blob([stringified], {
       type: 'application/json',
     })
-    url = URL.createObjectURL(blob)
+    url = Url.createObjectUrl(blob)
     await downloadFile(fileName, url)
   } catch (error) {
     throw new VError(error, `Failed to download ${fileName}`)
   } finally {
-    URL.revokeObjectURL(url)
+    Url.revokeObjectUrl(url)
   }
 }

package/static/{2394f34 → 4d80653}/packages/renderer-worker/src/parts/Editor/Editor.js

@@ -168,7 +168,6 @@ export const scheduleDocumentAndCursorsSelections = (editor, changes) => {
     ...editor,
     lines: newLines,
   }
-  console.log({ partialNewEditor })
   const newSelections = EditorSelection.applyEdit(partialNewEditor, changes)
   // TODO should separate rendering from business logic somehow
   // currently hard to test because need to mock editor height, top, left,

package/static/{2394f34 → 4d80653}/packages/renderer-worker/src/parts/EditorCommand/EditorCommandComposition.js

@@ -38,7 +38,6 @@ const getCompositionChanges = (selections, data) => {
 export const editorCompositionUpdate = (editor, data) => {
   const selections = editor.selections
   const changes = getCompositionChanges(selections, data)
-  console.log('composition update', changes)
   state.compositionText = data
   return Editor.scheduleDocumentAndCursorsSelections(editor, changes)
 }
@@ -46,7 +45,6 @@ export const editorCompositionUpdate = (editor, data) => {
 export const editorCompositionEnd = (editor, data) => {
   const selections = editor.selections
   const changes = getCompositionChanges(selections, data)
-  console.log('composition end', { changes })
   state.isComposing = false
   state.compositionText = ''
   return Editor.scheduleDocumentAndCursorsSelections(editor, changes)