@lvce-editor/server 0.0.27 → 0.0.28

package/static/eb65b4e/packages/renderer-worker/src/parts/Layout/Layout.js

@@ -1,447 +0,0 @@
-import * as Command from '../Command/Command.js'
-import * as RendererProcess from '../RendererProcess/RendererProcess.js'
-import * as Viewlet from '../Viewlet/Viewlet.js'
-import * as ViewletManager from '../ViewletManager/ViewletManager.js'
-
-// TODO where to force rendering of contents (need to call sidebar.openViewlet somewhere)
-
-export const state = {
-  activityBarLeft: 0,
-  activityBarTop: 0,
-  activityBarWidth: 48,
-  activityBarHeight: 0,
-  activityBarVisible: true,
-  mainLeft: 0,
-  mainTop: 0,
-  mainWidth: 0,
-  mainHeight: 0,
-  mainVisible: true,
-  panelLeft: 0,
-  panelTop: 0,
-  panelWidth: 0,
-  panelHeight: 160,
-  panelVisible: false,
-  sideBarLeft: 0,
-  sideBarTop: 0,
-  sideBarWidth: 240,
-  sideBarHeight: 0,
-  sideBarVisible: true,
-  statusBarLeft: 0,
-  statusBarTop: 0,
-  statusBarWidth: 0,
-  statusBarHeight: 0,
-  statusBarVisible: true,
-  titleBarLeft: 0,
-  titleBarTop: 0,
-  titleBarWidth: 0,
-  titleBarHeight: 0,
-  titleBarVisible: true,
-  windowWidth: 0,
-  windowHeight: 0,
-  sashId: '',
-}
-
-const SIDE_BAR_MIN_WIDTH = 170
-const SIDE_BAR_MAX_WIDTH = Infinity
-const PANEL_MIN_HEIGHT = 150
-const PANEL_MAX_HEIGHT = 600
-
-const clamp = (min, max, value) => {
-  if (value < min) {
-    return min
-  }
-  if (value > max) {
-    return max
-  }
-  return value
-}
-
-export const getPoints = (layout, bounds) => {
-  const windowWidth = bounds.windowWidth
-  const windowHeight = bounds.windowHeight
-  const titleBarHeight = bounds.titleBarHeight || 20
-
-  const activityBarVisible = layout.activityBarVisible
-  const panelVisible = layout.panelVisible
-  const sideBarVisible = layout.sideBarVisible
-  const statusBarVisible = layout.statusBarVisible
-  const titleBarVisible = layout.titleBarVisible
-
-  const activityBarWidth = 48 // TODO put magic numbers somewhere
-  const sideBarWidth = clamp(
-    SIDE_BAR_MIN_WIDTH,
-    SIDE_BAR_MAX_WIDTH,
-    layout.sideBarWidth
-  )
-
-  const panelHeight = clamp(
-    PANEL_MIN_HEIGHT,
-    PANEL_MAX_HEIGHT,
-    layout.panelHeight
-  ) // TODO check that it is in bounds of window
-  const statusBarHeight = 20
-
-  const p1 = /* Top */ 0
-  let p2 = /* End of Title Bar */ 0
-  let p3 = /* End of Main */ 0
-  let p4 = /* End of Panel */ 0
-  const p5 = /* End of StatusBar */ windowHeight
-
-  const p6 = /* Left */ 0
-  let p7 = /* End of Main */ windowWidth - activityBarWidth
-  let p8 = /* End of SideBar */ windowWidth
-  const p9 = /* End of ActivityBar */ windowWidth
-  if (titleBarVisible) {
-    p2 = titleBarHeight
-  }
-  if (statusBarVisible) {
-    p4 = windowHeight - statusBarHeight
-  }
-  p3 = panelVisible ? p4 - panelHeight : p4
-  if (activityBarVisible) {
-    p8 = windowWidth - activityBarWidth
-  }
-  if (sideBarVisible) {
-    p7 = p8 - sideBarWidth
-  }
-  return {
-    activityBarLeft: p8,
-    activityBarTop: p2,
-    activityBarWidth: 48,
-    activityBarHeight: p4 - p2,
-    activityBarVisible,
-    mainLeft: p6,
-    mainTop: p2,
-    mainWidth: p7 - p6,
-    mainHeight: p3 - p2,
-    mainVisible: true,
-    panelLeft: p6,
-    panelTop: p3,
-    panelWidth: p8 - p6,
-    panelHeight: p4 - p3,
-    panelVisible,
-    sideBarLeft: p7,
-    sideBarTop: p2,
-    sideBarWidth: p8 - p7,
-    sideBarHeight: p3 - p2,
-    sideBarVisible,
-    statusBarLeft: p1,
-    statusBarTop: p4,
-    statusBarWidth: windowWidth,
-    statusBarHeight: 20,
-    statusBarVisible,
-    titleBarLeft: p6,
-    titleBarTop: p1,
-    titleBarWidth: windowWidth,
-    titleBarHeight,
-    titleBarVisible: true,
-    windowWidth,
-    windowHeight,
-  }
-}
-
-export const updateLayout = async (layout) => {
-  const points = getPoints(layout, state)
-  Object.assign(state, points)
-  RendererProcess.invoke(
-    /* Layout.update */ 'Layout.update',
-    /* points */ points
-  )
-  await Command.execute(
-    /* LocalStorage.setJson */ 'LocalStorage.setJson',
-    /* key */ 'layout',
-    /* value */ state
-  )
-}
-
-const getDimensions = (state, id) => {
-  switch (id) {
-    case 'Main':
-      return {
-        top: state.mainTop,
-        left: state.mainLeft,
-        width: state.mainWidth,
-        height: state.mainHeight,
-      }
-    case 'SideBar':
-      return {
-        top: state.sideBarTop,
-        left: state.sideBarLeft,
-        width: state.sideBarWidth,
-        height: state.sideBarHeight,
-      }
-    case 'TitleBar':
-      return {
-        top: state.titleBarTop,
-        left: state.titleBarLeft,
-        width: state.titleBarWidth,
-        height: state.titleBarHeight,
-      }
-    case 'Panel':
-      return {
-        top: state.panelTop,
-        left: state.panelLeft,
-        width: state.panelWidth,
-        height: state.panelHeight,
-      }
-    case 'StatusBar':
-      return {
-        top: state.statusBarTop,
-        left: state.statusBarLeft,
-        width: state.statusBarWidth,
-        height: state.statusBarHeight,
-      }
-    case 'ActivityBar':
-      return {
-        top: state.activityBarTop,
-        left: state.activityBarLeft,
-        width: state.activityBarWidth,
-        height: state.activityBarHeight,
-      }
-    default:
-      throw new Error('unexpected component')
-  }
-}
-
-const show = async (key, id) => {
-  updateLayout({
-    ...state,
-    [key]: true,
-  })
-  const dimensions = getDimensions(state, id)
-  const instance = ViewletManager.create(
-    ViewletManager.getModule,
-    id,
-    '',
-    'builtin://',
-    dimensions.left,
-    dimensions.top,
-    dimensions.width,
-    dimensions.height
-  )
-  return ViewletManager.load(instance)
-}
-
-const hide = async (key, id) => {
-  updateLayout({
-    ...state,
-    [key]: false,
-  })
-  await Viewlet.dispose(id)
-}
-
-const toggle = async (key, id) => {
-  if (state[key]) {
-    await hide(key, id)
-  } else {
-    await show(key, id)
-  }
-}
-
-// TODO replace with one method in renderer process: setSideBarVisibility(true|false)
-export const showSideBar = async () => {
-  await show('sideBarVisible', 'SideBar')
-}
-
-export const hideSideBar = async () => {
-  await hide('sideBarVisible', 'SideBar')
-}
-
-export const toggleSideBar = async () => {
-  await toggle('sideBarVisible', 'SideBar')
-}
-
-// TODO replace with one method in renderer process: setPanelVisible(true|false)
-
-export const showPanel = async () => {
-  await show('panelVisible', 'Panel')
-}
-
-export const hidePanel = async () => {
-  await hide('panelVisible', 'Panel')
-}
-
-export const togglePanel = async () => {
-  await toggle('panelVisible', 'Panel')
-}
-
-export const showMain = async () => {
-  await show('mainVisible', 'Main')
-}
-
-export const togglePart = (partId) => {
-  switch (partId) {
-    case /* SideBar */ 1:
-      toggleSideBar()
-      break
-    case /* Panel */ 2:
-      togglePanel()
-      break
-    default:
-      break
-  }
-}
-
-export const isPanelVisible = () => {
-  return state.panelVisible
-}
-
-export const isSideBarVisible = () => {
-  return state.sideBarVisible
-}
-
-export const isVisible = (partId) => {
-  switch (partId) {
-    case /* SideBar */ 1:
-      return isSideBarVisible()
-    case /* Panel */ 2:
-      return isPanelVisible()
-    default:
-      return false
-  }
-}
-
-// TODO replace with one method in renderer process: setActivityBarVisible(true|false)
-
-export const showActivityBar = async () => {
-  await show('activityBarVisible', 'ActivityBar')
-}
-
-export const hideActivityBar = async () => {
-  await hide('activityBarVisible', 'ActivityBar')
-}
-
-export const toggleActivityBar = async () => {
-  await toggle('activityBarVisible', 'ActivityBar')
-}
-
-export const showStatusBar = async () => {
-  await show('statusBarVisible', 'StatusBar')
-}
-
-export const hideStatusBar = async () => {
-  await hide('statusBarVisible', 'StatusBar')
-}
-
-export const toggleStatusBar = async () => {
-  await toggle('statusBarVisible', 'StatusBar')
-}
-
-export const showTitleBar = async () => {
-  await show('titleBarVisible', 'TitleBar')
-}
-
-export const hideTitleBar = async () => {
-  await hide('titleBarVisible', 'TitleBar')
-}
-
-export const toggleTitleBar = async () => {
-  await toggle('titleBarVisible', 'TitleBar')
-}
-
-const getBounds = async () => {
-  return RendererProcess.invoke(/* Layout.getBounds */ 'Layout.getBounds')
-}
-
-const getInitialLayout = async () => {
-  // TODO this is very similar to state
-  const cachedLayout = await Command.execute(
-    /* LocalStorage.getJson */ 'LocalStorage.getJson',
-    /* key */ 'layout'
-  )
-  if (cachedLayout) {
-    return cachedLayout
-  }
-  return state
-}
-
-export const hydrate = async () => {
-  const windowBounds = await getBounds()
-  const initialLayout = await getInitialLayout()
-  const points = getPoints(initialLayout, windowBounds)
-  Object.assign(state, points)
-  await RendererProcess.invoke(
-    /* Layout.show */ 'Layout.show',
-    /* points */ points
-  )
-}
-
-const isChild = (id) => {
-  return (
-    id === 'Main' ||
-    id === 'SideBar' ||
-    id === 'ActivityBar' ||
-    id === 'Panel' ||
-    id === 'TitleBar'
-  )
-}
-
-export const handleSashPointerDown = (id) => {
-  state.sashId = id
-  console.log({ id })
-}
-
-// TODO make this functional
-export const handleSashPointerMove = async (x, y) => {
-  if (state.sashId === 'SideBar') {
-    const newSideBarWidth = state.windowWidth - state.activityBarWidth - x
-    if (newSideBarWidth <= SIDE_BAR_MIN_WIDTH / 2) {
-      state.sideBarVisible = false
-      state.mainWidth = state.windowWidth - state.activityBarWidth
-    } else if (newSideBarWidth <= SIDE_BAR_MIN_WIDTH) {
-      state.sideBarVisible = true
-      state.sideBarWidth = SIDE_BAR_MIN_WIDTH
-      state.mainWidth =
-        state.windowWidth - state.activityBarWidth - SIDE_BAR_MIN_WIDTH
-      state.sideBarLeft =
-        state.windowWidth - state.activityBarWidth - SIDE_BAR_MIN_WIDTH
-    } else {
-      state.sideBarVisible = true
-      state.mainWidth = x
-      state.sideBarLeft = x
-      state.sideBarWidth = newSideBarWidth
-    }
-  } else if (state.sashId === 'Panel') {
-    const newPanelHeight = state.windowHeight - state.statusBarHeight - y
-    if (newPanelHeight < PANEL_MIN_HEIGHT / 2) {
-      state.panelVisible = false
-      state.mainHeight =
-        state.windowHeight - state.statusBarHeight - state.titleBarHeight
-    } else if (newPanelHeight <= PANEL_MIN_HEIGHT) {
-      state.panelVisible = true
-      state.panelHeight = PANEL_MIN_HEIGHT
-      state.mainHeight =
-        state.windowHeight - state.activityBarHeight - PANEL_MIN_HEIGHT
-    } else {
-      state.panelVisible = true
-      state.mainHeight = y - state.titleBarHeight
-      state.panelTop = y
-      state.panelHeight = state.windowHeight - state.statusBarHeight - y
-    }
-  }
-
-  await updateLayout(state)
-}
-
-// TODO a bit unnecessary to send the same layout very often, but it avoids keeping state in renderer process
-export const handleResize = async (bounds) => {
-  const points = getPoints(state, bounds)
-  Object.assign(state, points)
-  await RendererProcess.invoke(
-    /* Layout.update */ 'Layout.update',
-    /* points */ points
-  )
-  const ids = ['Main', 'ActivityBar', 'SideBar', 'TitleBar', 'StatusBar']
-  const resizeInstance = (id) => {
-    const dimensions = getDimensions(state, id)
-    return Viewlet.resize(id, dimensions)
-  }
-  const commands = ids.flatMap(resizeInstance)
-  if (commands.length === 0) {
-    return
-  }
-  // TODO send the whole batch at once
-  for (const command of commands) {
-    RendererProcess.invoke(...command)
-  }
-}

package/static/eb65b4e/packages/renderer-worker/src/parts/LifeCycle/LifeCycle.js

@@ -1,44 +0,0 @@
-export const state = {
-  listenerMap: Object.create(null),
-  phase: 0,
-}
-
-export const PHASE_ZERO = 0
-export const PHASE_ONE = 1
-export const PHASE_TWO = 2
-export const PHASE_THREE = 3
-export const PHASE_FOUR = 4
-export const PHASE_FIVE = 5
-export const PHASE_SIX = 6
-export const PHASE_SEVEN = 7
-export const PHASE_EIGHT = 8
-export const PHASE_NINE = 9
-export const PHASE_TEN = 10
-export const PHASE_ELEVEN = 11
-export const PHASE_TWELVE = 12
-export const PHASE_THIRTEEN = 13
-export const PHASE_FOURTEEN = 14
-export const PHASE_FIFTEEN = 15
-export const PHASE_SIXTEEN = 16
-export const PHASE_SEVENTEEN = 17
-
-export const once = (event, listener) => {
-  if (state.phase >= event) {
-    listener()
-  } else {
-    // TODO could also statically allocate listenermap at start as array[13]
-    state.listenerMap[event] ||= []
-    state.listenerMap[event].push(listener)
-  }
-}
-
-export const mark = (event) => {
-  const listeners = state.listenerMap[event] || []
-  for (const listener of listeners) {
-    listener()
-  }
-  state.phase = event
-  if (event === PHASE_TWELVE) {
-    state.listenerMap = Object.create(null)
-  }
-}

package/static/eb65b4e/packages/renderer-worker/src/parts/Listener/Listener.ipc.js

@@ -1,7 +0,0 @@
-import * as Command from '../Command/Command.js'
-import * as Listener from './Listener.js'
-
-
-export const __initialize__ = () => {
-  Command.register(3444, Listener.execute)
-}

package/static/eb65b4e/packages/renderer-worker/src/parts/Location/Location.js

@@ -1,18 +0,0 @@
-import * as RendererProcess from '../RendererProcess/RendererProcess.js'
-
-export const getPathName = () => {
-  return RendererProcess.invoke(
-    /* Location.getPathName */ 'Location.getPathName'
-  )
-}
-
-export const setPathName = (pathName) => {
-  return RendererProcess.invoke(
-    /* Location.setPathName */ 'Location.setPathName',
-    /* pathName */ pathName
-  )
-}
-
-export const hydrate = () => {
-  return RendererProcess.invoke(/* Location.hydrate */ 'Location.hydrate')
-}

package/static/eb65b4e/packages/renderer-worker/src/parts/Menu/Menu.ipc.js

@@ -1,14 +0,0 @@
-import * as Command from '../Command/Command.js'
-import * as Menu from './Menu.js'
-
-export const __initialize__ = () => {
-  Command.register('Menu.show', Menu.show)
-  Command.register('Menu.hide', Menu.hide)
-  Command.register('Menu.selectIndex', Menu.selectIndex)
-  Command.register('Menu.focusNext', Menu.focusNext)
-  Command.register('Menu.focusPrevious', Menu.focusPrevious)
-  Command.register('Menu.focusFirst', Menu.focusFirst)
-  Command.register('Menu.focusLast', Menu.focusLast)
-  Command.register('Menu.focusIndex', Menu.focusIndex)
-  Command.register('Menu.handleMouseEnter', Menu.handleMouseEnter)
-}