@lvce-editor/shared-process 0.15.16 → 0.15.18

package/src/parts/WebSocketServer/WebSocketServer.js

@@ -1,6 +1,6 @@
 import { Buffer } from 'node:buffer'
 import * as _ws from 'ws'
-import * as Socket from '../Socket/Socket.js'
+import * as IsSocket from '../IsSocket/IsSocket.js'
 
 // workaround for jest or node bug
 const WebSocketServer = _ws.WebSocketServer
@@ -8,13 +8,6 @@ const WebSocketServer = _ws.WebSocketServer
   : // @ts-ignore
     _ws.default.WebSocketServer
 
-const encode = (commandId, callbackId) => (commandId << 16) | callbackId
-const decodeCommand = (encodedCommand) => encodedCommand >> 16
-const decodeCallback = (encodedCommand) => encodedCommand & 0x0000FFFF
-
-// console.log('ws', _ws)
-// console.log('server', ws.WebSocketServer)
-
 const webSocketServer = new WebSocketServer({
   noServer: true,
 
@@ -22,22 +15,15 @@ const webSocketServer = new WebSocketServer({
   // perMessageDeflate: true
 })
 
-// TODO should not import command directly -> Websocket server should be independent of business logic
-
-const handleSocket = (socket) => {
-  Socket.set(socket)
-}
-
-webSocketServer.on('connection', handleSocket)
-
-export const handleUpgrade = (request, socket) => {
-  const upgradeCallback = (ws) => {
-    webSocketServer.emit('connection', ws, request)
+export const handleUpgrade = async (request, socket) => {
+  if (!IsSocket.isSocket(socket)) {
+    throw new TypeError(`socket must be of type Socket`)
   }
-  webSocketServer.handleUpgrade(
-    request,
-    socket,
-    Buffer.alloc(0),
-    upgradeCallback
-  )
+  const webSocket = await new Promise((resolve, reject) => {
+    const upgradeCallback = (ws) => {
+      resolve(ws)
+    }
+    webSocketServer.handleUpgrade(request, socket, Buffer.alloc(0), upgradeCallback)
+  })
+  return webSocket
 }

package/src/sharedProcessMain.cjs

@@ -0,0 +1 @@
+import('./sharedProcessMain.js')

package/src/sharedProcessMain.js

@@ -3,6 +3,7 @@ import * as ErrorHandling from './parts/ErrorHandling/ErrorHandling.js'
 import * as Module from './parts/Module/Module.js'
 import * as ParentIpc from './parts/ParentIpc/ParentIpc.js'
 import * as Process from './parts/Process/Process.js'
+import * as Signal from './parts/Signal/Signal.js'
 // TODO handle structure: one shared process multiple extension hosts
 
 // TODO use named functions here
@@ -34,10 +35,10 @@ const main = async () => {
   console.log('[shared process] started')
   // process.on('beforeExit', handleBeforeExit)
   process.on('disconnect', handleDisconnect)
-  process.on('SIGTERM', handleSigTerm)
+  process.on(Signal.SIGTERM, handleSigTerm)
 
   process.on('uncaughtExceptionMonitor', ErrorHandling.handleUncaughtExceptionMonitor)
-  ParentIpc.listen()
+  await ParentIpc.listen()
 
   // ExtensionHost.start() // TODO start on demand, e.g. not when extensions should be disabled
 }

package/extensions/builtin.language-basics-json5/README.md

@@ -1,16 +0,0 @@
-# Language Basics JSON5
-
-Provides syntax highlighting in JSON5 files.
-
-## Contributing
-
-```sh
-git clone git@github.com:lvce-editor/language-basics-json5.git &&
-cd language-basics-json5 &&
-npm ci &&
-npm test
-```
-
-## Gitpod
-
-[![Open in Gitpod](https://gitpod.io/button/open-in-gitpod.svg)](https://gitpod.io/#https://github.com/lvce-editor/language-basics-json5)

package/extensions/builtin.language-basics-json5/extension.json

@@ -1,12 +0,0 @@
-{
-  "id": "builtin.language-basics-json5",
-  "name": "Language Basics JSON5",
-  "description": "Provides syntax highlighting and bracket matching in JSON5 files.",
-  "languages": [
-    {
-      "id": "json5",
-      "extensions": [".json5"],
-      "tokenize": "src/tokenizeJson5.js"
-    }
-  ]
-}

package/extensions/builtin.language-basics-json5/src/tokenizeJson5.js

@@ -1,321 +0,0 @@
-/**
- * @enum number
- */
-export const State = {
-  TopLevelContent: 1,
-  AfterCurlyOpen: 2,
-  InsideString: 3,
-  AfterPropertyName: 4,
-  AfterPropertyNameAfterColon: 5,
-  AfterPropertyValue: 6,
-  JsonPropertyKey: 7,
-  InsideLineComment: 8,
-  InsidePropertyNameString: 9,
-}
-
-export const StateMap = {
-  [State.TopLevelContent]: 'TopLevelContent',
-  [State.AfterCurlyOpen]: 'AfterCurlyOpen',
-  [State.InsideString]: 'InsideString',
-  [State.AfterPropertyName]: 'AfterPropertyName',
-  [State.AfterPropertyNameAfterColon]: 'AfterPropertyNameAfterColon',
-  [State.AfterPropertyValue]: 'AfterPropertyValue',
-  [State.JsonPropertyKey]: 'JsonPropertyKey',
-}
-
-/**
- * @enum number
- */
-export const TokenType = {
-  CssSelector: 1,
-  Whitespace: 2,
-  Punctuation: 3,
-  PropertyName: 4,
-  PropertyValue: 5,
-  CurlyOpen: 6,
-  CurlyClose: 7,
-  PropertyColon: 8,
-  PropertySemicolon: 9,
-  String: 10,
-  LanguageConstant: 11,
-  NewLine: 12,
-  JsonPropertyName: 13,
-  PropertyValueString: 14,
-  Numeric: 15,
-  LanguageConstantBoolean: 16,
-  Comment: 17,
-  Error: 18,
-  Unknown: 19,
-  Text: 20,
-  JsonPropertyValueString: 21,
-}
-
-export const TokenMap = {
-  [TokenType.CssSelector]: 'CssSelector',
-  [TokenType.Whitespace]: 'Whitespace',
-  [TokenType.Punctuation]: 'Punctuation',
-  [TokenType.PropertyName]: 'PropertyName',
-  [TokenType.PropertyValue]: 'PropertyValue',
-  [TokenType.CurlyOpen]: 'CurlyOpen',
-  [TokenType.CurlyClose]: 'CurlyClose',
-  [TokenType.PropertyColon]: 'PropertyColon',
-  [TokenType.PropertySemicolon]: 'PropertySemicolon',
-  [TokenType.String]: 'String',
-  [TokenType.LanguageConstant]: 'LanguageConstant',
-  [TokenType.LanguageConstantBoolean]: 'LanguageConstantBoolean',
-  [TokenType.JsonPropertyName]: 'JsonPropertyName',
-  [TokenType.PropertyValueString]: 'PropertyValueString',
-  [TokenType.Comment]: 'Comment',
-  [TokenType.Error]: 'Error',
-  [TokenType.Unknown]: 'Unknown',
-  [TokenType.NewLine]: 'NewLine',
-  [TokenType.Text]: 'Text',
-  [TokenType.Numeric]: 'Numeric',
-  [TokenType.JsonPropertyValueString]: 'JsonPropertyValueString',
-}
-
-const RE_SELECTOR = /^[\.a-zA-Z\d\-\:>]+/
-const RE_WHITESPACE = /^\s+/
-const RE_CURLY_OPEN = /^\{/
-const RE_CURLY_CLOSE = /^\}/
-const RE_COLON = /^:/
-const RE_PROPERTY_VALUE = /^[^\n;]+/
-const RE_SEMICOLON = /^;/
-const RE_COMMA = /^,/
-const RE_DOUBLE_QUOTE = /^"/
-const RE_STRING_DOUBLE_QUOTE_CONTENT = /^[^"\\]+/
-const RE_LANGUAGE_CONSTANT = /^(?:true|false|null)/
-const RE_SQUARE_OPEN = /^\[/
-const RE_SQUARE_CLOSE = /^\]/
-const RE_LINE_COMMENT = /^\/\/.*/
-const RE_ANYTHING = /^.+/s
-const RE_NUMERIC =
-  /^((0(x|X)[0-9a-fA-F]*)|(\-?([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(\+|-)?[0-9]+)?)\b/
-const RE_TEXT = /^[^\s\{\}\[\]]+/
-// const RE_ESCAPED_QUOTE = /^\\"/
-// const RE_BACK_SLASH = /^\\/
-const RE_STRING_ESCAPE = /^\\.?/
-const RE_WORD = /^\w+/
-
-export const initialLineState = {
-  state: State.TopLevelContent,
-  stack: [],
-}
-
-export const hasArrayReturn = true
-
-/**
- * @param {string} line
- * @param {any} lineState
- */
-export const tokenizeLine = (line, lineState) => {
-  let next
-  let index = 0
-  let token
-  let state = lineState.state
-  let __r = 0
-  const tokens = []
-  const stack = lineState.stack
-  state
-  while (index < line.length) {
-    if (__r++ > 100_000_000_000) {
-      throw new Error('endless loop')
-    }
-    const part = line.slice(index)
-    switch (state) {
-      case State.TopLevelContent:
-        if ((next = part.match(RE_CURLY_OPEN))) {
-          token = TokenType.Punctuation
-          state = State.AfterCurlyOpen
-          stack.push(State.TopLevelContent)
-        } else if ((next = part.match(RE_SQUARE_OPEN))) {
-          token = TokenType.Punctuation
-          state = State.TopLevelContent
-          stack.push(State.TopLevelContent)
-        } else if ((next = part.match(RE_WHITESPACE))) {
-          token = TokenType.Whitespace
-          state = State.TopLevelContent
-        } else if ((next = part.match(RE_SQUARE_CLOSE))) {
-          token = TokenType.Punctuation
-          state = stack.pop()
-        } else if ((next = part.match(RE_COMMA))) {
-          token = TokenType.Punctuation
-          state = State.TopLevelContent
-        } else if ((next = part.match(RE_NUMERIC))) {
-          token = TokenType.Numeric
-          state = State.TopLevelContent
-        } else if ((next = part.match(RE_LANGUAGE_CONSTANT))) {
-          token = TokenType.LanguageConstant
-          state = State.TopLevelContent
-        } else if ((next = part.match(RE_DOUBLE_QUOTE))) {
-          token = TokenType.Punctuation
-          state = State.InsideString
-          stack.push(State.TopLevelContent)
-        } else if ((next = part.match(RE_LINE_COMMENT))) {
-          token = TokenType.Comment
-          state = State.InsideLineComment
-        } else if ((next = part.match(RE_CURLY_CLOSE))) {
-          token = TokenType.CurlyClose
-          state = stack.pop()
-        } else if ((next = part.match(RE_ANYTHING))) {
-          token = TokenType.Text
-          state = State.TopLevelContent
-        } else {
-          part //?
-          throw new Error('no')
-        }
-        break
-      case State.AfterCurlyOpen:
-        if ((next = part.match(RE_WHITESPACE))) {
-          token = TokenType.Whitespace
-          state = State.AfterCurlyOpen
-        } else if ((next = part.match(RE_DOUBLE_QUOTE))) {
-          token = TokenType.Punctuation
-          state = State.InsidePropertyNameString
-          stack.push(State.AfterPropertyName)
-        } else if ((next = part.match(RE_CURLY_CLOSE))) {
-          token = TokenType.Punctuation
-          state = stack.pop()
-          if (!state) {
-            throw new Error('imbalanced json')
-          }
-        } else if ((next = part.match(RE_LINE_COMMENT))) {
-          token = TokenType.Comment
-          state = State.AfterCurlyOpen
-        } else if ((next = part.match(RE_WORD))) {
-          token = TokenType.PropertyName
-          state = State.AfterPropertyName
-        } else if ((next = part.match(RE_ANYTHING))) {
-          token = TokenType.Text
-          state = State.AfterCurlyOpen
-        } else {
-          part //?
-          throw new Error('no')
-        }
-        break
-      case State.InsidePropertyNameString:
-        if ((next = part.match(RE_STRING_DOUBLE_QUOTE_CONTENT))) {
-          token = TokenType.JsonPropertyName
-          state = State.InsidePropertyNameString
-        } else if ((next = part.match(RE_DOUBLE_QUOTE))) {
-          token = TokenType.Punctuation
-          state = stack.pop()
-          state
-        } else if ((next = part.match(RE_STRING_ESCAPE))) {
-          token = TokenType.JsonPropertyName
-          state = State.InsidePropertyNameString
-        } else {
-          throw new Error('no')
-        }
-        break
-      case State.InsideString:
-        if ((next = part.match(RE_STRING_DOUBLE_QUOTE_CONTENT))) {
-          token = TokenType.JsonPropertyValueString
-          state = State.InsideString
-        } else if ((next = part.match(RE_DOUBLE_QUOTE))) {
-          token = TokenType.Punctuation
-          state = stack.pop()
-        } else if ((next = part.match(RE_STRING_ESCAPE))) {
-          token = TokenType.String
-          state = State.InsideString
-        } else {
-          line.slice(0, index) //?
-          part //?
-          throw new Error('no')
-        }
-        break
-      case State.AfterPropertyName:
-        if ((next = part.match(RE_COLON))) {
-          token = TokenType.Punctuation
-          state = State.AfterPropertyNameAfterColon
-        } else if ((next = part.match(RE_WHITESPACE))) {
-          token = TokenType.Whitespace
-          state = State.AfterPropertyName
-        } else if ((next = part.match(RE_ANYTHING))) {
-          token = TokenType.Text
-          state = State.AfterCurlyOpen
-        } else {
-          throw new Error('no')
-        }
-        break
-      case State.AfterPropertyNameAfterColon:
-        if ((next = part.match(RE_WHITESPACE))) {
-          token = TokenType.Whitespace
-          state = State.AfterPropertyNameAfterColon
-        } else if ((next = part.match(RE_DOUBLE_QUOTE))) {
-          token = TokenType.Punctuation
-          state = State.InsideString
-          stack.push(State.AfterPropertyValue)
-        } else if ((next = part.match(RE_LANGUAGE_CONSTANT))) {
-          token = TokenType.LanguageConstant
-          state = State.AfterPropertyValue
-        } else if ((next = part.match(RE_NUMERIC))) {
-          token = TokenType.Numeric
-          state = State.AfterPropertyValue
-        } else if ((next = part.match(RE_TEXT))) {
-          token = TokenType.Text
-          state = State.AfterCurlyOpen
-        } else if ((next = part.match(RE_CURLY_OPEN))) {
-          token = TokenType.Punctuation
-          state = State.AfterCurlyOpen
-          stack.push(State.AfterPropertyValue)
-        } else if ((next = part.match(RE_SQUARE_OPEN))) {
-          token = TokenType.Punctuation
-          state = State.TopLevelContent
-          stack.push(State.AfterPropertyValue)
-        } else {
-          line.slice(0, index) //?
-          throw new Error('no')
-        }
-        break
-      case State.AfterPropertyValue:
-        if ((next = part.match(RE_CURLY_CLOSE))) {
-          token = TokenType.Punctuation
-          state = stack.pop()
-          if (!state) {
-            throw new Error('inbalanced json')
-          }
-        } else if ((next = part.match(RE_WHITESPACE))) {
-          token = TokenType.Whitespace
-          state = State.AfterPropertyValue
-        } else if ((next = part.match(RE_COMMA))) {
-          token = TokenType.Punctuation
-          state = State.AfterCurlyOpen
-        } else if ((next = part.match(RE_ANYTHING))) {
-          token = TokenType.Text
-          state = State.AfterCurlyOpen
-        } else {
-          part //?
-          throw new Error('no')
-        }
-        break
-      case State.InsideLineComment:
-        if ((next = part.match(RE_ANYTHING))) {
-          token = TokenType.Comment
-          state = State.TopLevelContent
-        } else {
-          throw new Error('no')
-        }
-        break
-      default:
-        state
-        throw new Error('no')
-    }
-
-    const currentTokenText = next[0]
-    const currentTokenLength = currentTokenText.length
-    index += currentTokenLength
-    tokens.push(token, currentTokenLength)
-  }
-  if (state === State.InsideLineComment) {
-    state = State.TopLevelContent
-  }
-  if (state === State.AfterPropertyValue) {
-    state = State.AfterCurlyOpen
-  }
-  return {
-    state,
-    stack,
-    tokens,
-  }
-}

package/src/parts/Socket/Socket.js

@@ -1,77 +0,0 @@
-import * as Command from '../Command/Command.js'
-import * as GetResponse from '../GetResponse/GetResponse.js'
-import { VError } from '../VError/VError.js'
-
-export const state = {
-  /**
-   * @type {any}
-   */
-  socket: undefined,
-}
-
-export const send = (message) => {
-  if (!state.socket) {
-    console.warn('socket not yet available')
-    return
-  }
-  state.socket.send(message)
-}
-
-const handleMessage = async (event) => {
-  const object = JSON.parse(event.data)
-  if (object.id) {
-    if (!object.params) {
-      console.warn('[shared-process] invalid message 1', typeof object, object.params, object)
-      return
-    }
-    const response = await GetResponse.getResponse(object, state.socket)
-    send(response)
-  } else {
-    if (!object.params) {
-      console.warn('invalid message', typeof object, object.params, object)
-      return
-    }
-    Command.execute(object.method, state.socket, ...object.params)
-  }
-}
-
-const handleError = (error) => {
-  // console.error(error)
-  throw new VError(error, 'Shared Process Socket Error')
-
-  // console.error('[Shared Process: Socket Error]', event)
-}
-
-// TODO
-const createAbstractSocket = (socket) => {
-  return {
-    _socket: socket,
-    send(message) {
-      socket.send(JSON.stringify(message))
-    },
-    on(event, listener) {
-      switch (event) {
-        case 'message':
-          socket.on('message', listener)
-          break
-        case 'close':
-          socket.on('close', listener)
-          break
-        default:
-          console.warn('socket event not implemented', event, listener)
-          break
-      }
-    },
-  }
-}
-
-export const set = (socket) => {
-  socket.on('close', () => {
-    console.log('[shared-process] socket closed')
-  })
-  socket.onmessage = handleMessage
-  // socket.onerror = handleError
-  socket.on('error', handleError)
-  const abstractSocket = createAbstractSocket(socket)
-  state.socket = abstractSocket
-}