@lvce-editor/server 0.0.26 → 0.0.29

package/static/0895dce/packages/renderer-worker/src/parts/TitleBarMenuBar/TitleBarMenuBar.js

@@ -1,247 +0,0 @@
-// TODO menu should not be needed initially, only when item is selected and menu is opened
-import * as Menu from '../Menu/Menu.js'
-import * as MenuEntries from '../MenuEntries/MenuEntries.js'
-import * as RendererProcess from '../RendererProcess/RendererProcess.js'
-
-export const state = {
-  /**
-   * @type{any[]}
-   */
-  titleBarEntries: [],
-  focusedIndex: 0,
-  isMenuOpen: false,
-}
-
-// TODO put this in json (e.g. defaultTitleBarMenu.json) and load from cache storage or via ajax
-// TODO only compute once if is electron and filter out during build process
-
-export const getEntries = async () => {
-  state.titleBarEntries = await MenuEntries.getMenuEntries('titleBar')
-  return state.titleBarEntries
-}
-
-/**
- * @param {number} index
- * @param {boolean} shouldBeFocused
- */
-const openMenuAtIndex = async (index, shouldBeFocused) => {
-  // TODO race conditions
-  // TODO send renderer process
-  // 1. open menu, items to show
-  // 2. focus menu
-  const id = state.titleBarEntries[index].id
-  const items = await MenuEntries.getMenuEntries(id)
-  Menu.state.menus = []
-  const bounds = await RendererProcess.invoke(
-    /* Viewlet.send */ 'Viewlet.send',
-    /* id */ 'TitleBar',
-    /* method */ 'menuGetEntryBounds',
-    /* index */ index
-  )
-  const x = bounds.left
-  const y = bounds.bottom
-  const width = Menu.getMenuWidth()
-  const height = Menu.getMenuHeight(items)
-  const menuFocusedIndex = shouldBeFocused
-    ? Menu.getIndexToFocusNextStartingAt(items, 0)
-    : -1
-  const menu = Menu.addMenuInternal({
-    id,
-    items,
-    focusedIndex: menuFocusedIndex,
-    level: Menu.state.menus.length,
-    x,
-    y,
-  })
-  RendererProcess.send([
-    /* Viewlet.send */ 'Viewlet.send',
-    /* id */ 'TitleBar',
-    /* method */ 'menuOpen',
-    /* unFocusIndex */ state.focusedIndex,
-    /* index */ index,
-    /* level */ menu.level,
-    /* menuItems */ menu.items,
-    /* menuFocusedIndex */ menuFocusedIndex,
-    /* focus */ shouldBeFocused,
-    /* x */ x,
-    /* y */ y,
-    /* width */ width,
-    /* height */ height,
-  ])
-  state.isMenuOpen = true
-}
-
-/**
- * @param {boolean} focus
- */
-export const openMenu = async (focus) => {
-  if (state.focusedIndex === -1) {
-    return
-  }
-  await openMenuAtIndex(state.focusedIndex, focus)
-}
-
-export const closeMenu = async (keepFocus) => {
-  // TODO send to renderer process
-  // 1. close menu
-  // 2. focus top level entry
-  const focusIndex = keepFocus ? state.focusedIndex : -1
-  // TODO use Viewlet.dispose instead
-  state.isMenuOpen = false
-  await RendererProcess.invoke(
-    /* Viewlet.send */ 'Viewlet.send',
-    /* id */ 'TitleBar',
-    /* method */ 'menuClose',
-    /* unFocusIndex */ state.focusedIndex,
-    /* focusIndex */ focusIndex
-  )
-}
-
-export const toggleMenu = async () => {
-  if (state.isMenuOpen) {
-    closeMenu(/* keepFocus */ true)
-  } else {
-    await openMenu(/* focus */ false)
-  }
-}
-
-export const focusIndex = async (index) => {
-  if (state.isMenuOpen) {
-    await openMenuAtIndex(index, /* focus */ false)
-  } else {
-    await RendererProcess.invoke(
-      /* TitleBarMenuBar.focusIndex */ 1371,
-      /* unFocusIndex */ state.focusedIndex,
-      /* index */ index
-    )
-  }
-  state.focusedIndex = index
-}
-
-export const toggleIndex = async (index) => {
-  if (state.isMenuOpen && state.focusedIndex === index) {
-    closeMenu(/* keepFocus */ true)
-  } else {
-    await openMenuAtIndex(index, /* focus */ false)
-  }
-  state.focusedIndex = index
-}
-
-export const focus = async () => {
-  await focusFirst()
-}
-
-const getIndexToFocusPreviousStartingAt = (items, index) => {
-  return (index + items.length) % items.length
-}
-
-export const focusPrevious = async () => {
-  const indexToFocus = getIndexToFocusPreviousStartingAt(
-    state.titleBarEntries,
-    state.focusedIndex - 1
-  )
-  await focusIndex(indexToFocus)
-}
-
-const getIndexToFocusNextStartingAt = (items, index) => {
-  return index % items.length
-}
-
-export const focusNext = async () => {
-  const indexToFocus = getIndexToFocusNextStartingAt(
-    state.titleBarEntries,
-    state.focusedIndex + 1
-  )
-  await focusIndex(indexToFocus)
-}
-
-export const focusFirst = async () => {
-  const indexToFocus = getIndexToFocusNextStartingAt(state.titleBarEntries, 0)
-  await focusIndex(indexToFocus)
-}
-
-export const focusLast = async () => {
-  const indexToFocus = getIndexToFocusPreviousStartingAt(
-    state.titleBarEntries,
-    state.titleBarEntries.length - 1
-  )
-  await focusIndex(indexToFocus)
-}
-
-export const handleKeyArrowLeft = async () => {
-  if (state.isMenuOpen && Menu.state.menus.length > 1) {
-    return
-  }
-  // TODO menu collapse
-  await focusPrevious()
-}
-
-export const handleKeyArrowUp = () => {
-  if (!state.isMenuOpen) {
-    return
-  }
-  Menu.focusPrevious()
-}
-
-export const handleKeyArrowRight = async () => {
-  console.log('arrow right')
-  if (state.isMenuOpen) {
-    // if menu can open sub menu to the right -> do that
-    const menu = Menu.state.menus.at(-1)
-    const item = menu.items[menu.focusedIndex]
-    if (item.flags === /* SubMenu */ 4) {
-      await Menu.showSubMenu(Menu.state.menus.length - 1, menu.focusedIndex)
-      return
-    }
-  }
-  await focusNext()
-}
-
-export const handleKeyHome = async () => {
-  if (state.isMenuOpen) {
-    Menu.focusFirst()
-  } else {
-    await focusFirst()
-  }
-}
-
-// TODO this is also use for pagedown -> maybe find a better name for this function
-export const handleKeyEnd = async () => {
-  if (state.isMenuOpen) {
-    Menu.focusLast()
-  } else {
-    await focusLast()
-  }
-}
-
-// TODO this is same as handle key enter -> merge the functions
-export const handleKeySpace = async () => {
-  if (state.isMenuOpen) {
-    await Menu.selectCurrent()
-  } else {
-    openMenu(/* focus */ true)
-  }
-}
-
-export const handleKeyEnter = async () => {
-  if (state.isMenuOpen) {
-    await Menu.selectCurrent()
-  } else {
-    openMenu(/* focus */ true)
-  }
-}
-
-export const handleKeyEscape = () => {
-  if (!state.isMenuOpen) {
-    return
-  }
-  closeMenu(/* keepFocus */ true)
-}
-
-export const handleKeyArrowDown = async () => {
-  if (state.isMenuOpen) {
-    Menu.focusNext()
-  } else {
-    await openMenu(/* focus */ true)
-  }
-}

package/static/0895dce/packages/renderer-worker/src/parts/Tokenizer/Tokenizer.js

@@ -1,70 +0,0 @@
-import * as TokenizePlainText from './TokenizePlainText.js'
-import * as Languages from '../Languages/Languages.js'
-import * as GlobalEventBus from '../GlobalEventBus/GlobalEventBus.js'
-
-export const state = {
-  tokenizers: Object.create(null),
-  tokenizePaths: Object.create(null),
-  listeners: [],
-  pending: Object.create(null),
-}
-
-// TODO more dynamic: should come from extensions anywhere on file system
-const getTokenizePath = (languageId) => {
-  for (const language of Languages.state.languages) {
-    if (language.id === languageId && language.tokenize) {
-      return language.tokenize
-    }
-  }
-  return ''
-}
-
-// TODO loadTokenizer should be invoked from renderer worker
-export const loadTokenizer = async (languageId) => {
-  if (languageId in state.tokenizers) {
-    return
-  }
-  const tokenizePath = getTokenizePath(languageId)
-  if (!tokenizePath) {
-    return
-  }
-  try {
-    // TODO check that tokenizer is valid
-    // 1. tokenizeLine should be of type function
-    // 2. getTokenClass should be of type function
-    const tokenizer = await import(tokenizePath)
-    if (typeof tokenizer.tokenizeLine !== 'function') {
-      console.warn(
-        `tokenizer.tokenizeLine should be a function in "${tokenizePath}"`
-      )
-      return
-    }
-    if (
-      !tokenizer.TokenMap ||
-      typeof tokenizer.TokenMap !== 'object' ||
-      Array.isArray(tokenizer.TokenMap)
-    ) {
-      console.warn(
-        `tokenizer.TokenMap should be an object in "${tokenizePath}"`
-      )
-      return
-    }
-    state.tokenizers[languageId] = tokenizer
-  } catch (error) {
-    state.tokenizers[languageId] = TokenizePlainText
-    // TODO better error handling
-    console.error(error)
-    return
-  }
-  GlobalEventBus.emitEvent('tokenizer.changed', languageId)
-}
-
-export const getTokenizer = (languageId) => {
-  if (languageId in state.tokenizers) {
-    return state.tokenizers[languageId]
-  }
-  if (languageId in state.pending) {
-    return TokenizePlainText
-  }
-  return TokenizePlainText
-}

package/static/0895dce/packages/renderer-worker/src/parts/Viewlet/Viewlet.ipc.js

@@ -1,6 +0,0 @@
-import * as Command from '../Command/Command.js'
-import * as Viewlet from './Viewlet.js'
-
-export const __initialize__ = () => {
-  Command.register(2133, Viewlet.send)
-}

package/static/0895dce/packages/renderer-worker/src/parts/Viewlet/Viewlet.js

@@ -1,188 +0,0 @@
-import * as RendererProcess from '../RendererProcess/RendererProcess.js'
-import * as GlobalEventBus from '../GlobalEventBus/GlobalEventBus.js'
-import * as Command from '../Command/Command.js'
-import * as Assert from '../Assert/Assert.js'
-
-export const state = {
-  instances: Object.create(null),
-  modules: Object.create(null),
-}
-
-/**
- * @deprecated
- */
-export const focus = (id) => {
-  // if(state.instances[id]){
-  // }
-  // console.log('focus', { id })
-  // // TODO open if it is not already open
-  // RendererProcess.send([/* viewletFocus */ 3027, /* id */ id])
-}
-// export const createOrFocus = async id=>{
-//   const instance = state.instances[id] || await create(id)
-// }
-
-/**
- * @deprecated
- */
-export const refreshInstance = async (instance, id) => {
-  if (!instance) {
-    return
-  }
-  if (instance.status === 'refreshing' || instance.status === 'disposed') {
-    return
-  }
-  instance.status = 'refreshing'
-  try {
-    await instance.factory.refresh(instance.state)
-  } catch (error) {
-    // TODO use ErrorHandling.handleError
-    // TODO show notification maybe
-    console.error(error)
-    instance.status = 'error'
-    return
-  }
-  instance.status = 'refreshed'
-}
-
-// TODO should refresh instance?
-/**
- * @deprecated
- */
-export const refresh = async (id) => {
-  const instance = state.instances[id]
-  if (!instance) {
-    return
-  }
-  await refreshInstance(instance, id)
-}
-
-/**
- * @deprecated
- */
-export const send = (id, method, ...args) => {
-  const instance = state.instances[id]
-  if (!instance) {
-    console.info('instance disposed', { id, method, args })
-    console.info(state.instances)
-    return
-  }
-  const fn = instance.factory[method]
-  Assert.fn(fn)
-  fn(instance.state, ...args)
-}
-
-/**
- * @deprecated
- */
-export const dispose = async (id) => {
-  if (!id) {
-    console.warn('no instance to dispose')
-    return
-  }
-  const instance = state.instances[id]
-  if (!instance) {
-    console.info('instance may already be disposed')
-    return
-  }
-  // TODO status should have enum
-  instance.status = 'disposing'
-  try {
-    if (!instance.factory) {
-      throw new Error(`${id} is missing a factory function`)
-    }
-    instance.factory.dispose(instance.state)
-    await RendererProcess.invoke(
-      /* Viewlet.dispose */ 'Viewlet.dispose',
-      /* id */ id
-    )
-  } catch (error) {
-    console.error(error)
-    // TODO use Error.cause once proper stack traces are supported by chrome
-    throw new Error(`Failed to dispose viewlet ${id}: ${error}`)
-  }
-  instance.status = 'disposed'
-  delete state.instances[id]
-  delete state.modules[id]
-  await GlobalEventBus.emitEvent(`Viewlet.dispose.${id}`)
-}
-
-/**
- * @deprecated
- */
-export const replace = () => {}
-
-// TODO maybe wrapViewletCommand should accept module instead of id string
-// then check if instance.factory matches module -> only compare reference (int) instead of string
-// should be faster
-export const wrapViewletCommand = (id, fn) => {
-  const wrappedViewletCommand = async (...args) => {
-    // TODO get actual focused instance
-    const activeInstance = state.instances[id]
-    if (!activeInstance) {
-      console.info(`no active instance for ${id}`)
-      return
-    }
-    if (activeInstance.factory && activeInstance.factory.hasFunctionalRender) {
-      const oldState = activeInstance.state
-      const newState = await fn(oldState, ...args)
-      if (!newState) {
-        console.log({ fn })
-      }
-      Assert.object(newState)
-      // console.log({ fn, newState })
-      if (oldState === newState) {
-        return
-      }
-      if (newState.disposed) {
-        await dispose(id)
-        console.log('DISPOSED')
-        return
-      }
-      const commands = activeInstance.factory.render(oldState, newState)
-      RendererProcess.send([
-        /* Viewlet.sendMultiple */ 'Viewlet.sendMultiple',
-        /* commands */ commands,
-      ])
-      state.instances[id].state = newState
-    } else {
-      return fn(activeInstance.state, ...args)
-    }
-  }
-  return wrappedViewletCommand
-}
-
-export const resize = (id, dimensions) => {
-  const instance = state.instances[id]
-  if (!instance || !instance.factory || !instance.factory.resize) {
-    console.warn('cannot resize', id)
-    return []
-  }
-  const oldState = instance.state
-  const { newState, commands } = instance.factory.resize(oldState, dimensions)
-  Assert.object(newState)
-  Assert.array(commands)
-  state.instances[id].state = newState
-  if (instance.factory.hasFunctionalRender) {
-    return instance.factory.render(oldState, newState)
-  }
-  return commands
-}
-
-export const getState = (id) => {
-  const instance = state.instances[id]
-  return instance.state
-}
-
-export const setState = (id, newState) => {
-  const instance = state.instances[id]
-  if (instance && instance.factory && instance.factory.hasFunctionalRender) {
-    const oldState = instance.state
-    const commands = instance.factory.render(oldState, newState)
-    RendererProcess.send([
-      /* Viewlet.sendMultiple */ 'Viewlet.sendMultiple',
-      /* commands */ commands,
-    ])
-    instance.state = newState
-  }
-}

package/static/0895dce/packages/renderer-worker/src/parts/Viewlet/ViewletActivityBar.ipc.js

@@ -1,21 +0,0 @@
-import * as Command from '../Command/Command.js'
-import * as Viewlet from '../Viewlet/Viewlet.js'
-import * as ActivityBar from './ViewletActivityBar.js'
-
-// prettier-ignore
-export const __initialize__ = () => {
-  Command.register('ActivityBar.toggleItem', Viewlet.wrapViewletCommand('ActivityBar', ActivityBar.toggleItem))
-  Command.register('ActivityBar.handleClick', Viewlet.wrapViewletCommand('ActivityBar', ActivityBar.handleClick))
-  Command.register('ActivityBar.handleContextMenu', Viewlet.wrapViewletCommand('ActivityBar', ActivityBar.handleContextMenu))
-  Command.register('ActivityBar.focus', Viewlet.wrapViewletCommand('ActivityBar', ActivityBar.focus))
-  Command.register('ActivityBar.focusNext', Viewlet.wrapViewletCommand('ActivityBar', ActivityBar.focusNext))
-  Command.register('ActivityBar.focusPrevious', Viewlet.wrapViewletCommand('ActivityBar', ActivityBar.focusPrevious))
-  Command.register('ActivityBar.focusFirst', Viewlet.wrapViewletCommand('ActivityBar', ActivityBar.focusFirst))
-  Command.register('ActivityBar.focusLast', Viewlet.wrapViewletCommand('ActivityBar', ActivityBar.focusLast))
-  Command.register('ActivityBar.selectCurrent', Viewlet.wrapViewletCommand('ActivityBar', ActivityBar.selectCurrent))
-  Command.register('ActivityBar.getItems', Viewlet.wrapViewletCommand('ActivityBar', ActivityBar.getItems))
-  Command.register('ActivityBar.getHiddenItems', Viewlet.wrapViewletCommand('ActivityBar', ActivityBar.getHiddenItems))
-  Command.register('ActivityBar.updateSourceControlCount', Viewlet.wrapViewletCommand('ActivityBar', ActivityBar.updateSourceControlCount))
-  Command.register('ActivityBar.handleSideBarViewletChange', Viewlet.wrapViewletCommand('ActivityBar', ActivityBar.handleSideBarViewletChange))
-  Command.register('ActivityBar.handleSideBarHidden', Viewlet.wrapViewletCommand('ActivityBar', ActivityBar.handleSideBarHidden))
-}