@lvce-editor/shared-process 0.11.6 → 0.11.8

package/extensions/builtin.language-basics-typescript/src/tokenizeTypeScript.js

@@ -25,6 +25,15 @@ const State = {
   AfterKeywordEnumAfterVariableName: 22,
   InsideEnum: 23,
   InsideEnumAfterVariableName: 24,
+  InsideObjectDestructuring: 25,
+  InsideObjectDestructuringAfterValue: 26,
+  AfterKeywordInterface: 27,
+  InsideTypeObject: 28,
+  AfterMethodName: 29,
+  InsideMethodParameters: 30,
+  InsideMethodParametersAfterVariableName: 31,
+  AfterMethodParameters: 32,
+  // AfterKeywordImport: 27,
 }
 
 /**
@@ -53,6 +62,7 @@ export const TokenType = {
   Class: 17,
   StorageModifier: 18,
   KeywordVoid: 19,
+  Function: 20,
 }
 
 export const TokenMap = {
@@ -78,6 +88,7 @@ export const TokenMap = {
   [TokenType.Class]: 'Class',
   [TokenType.StorageModifier]: 'StorageModifier',
   [TokenType.KeywordVoid]: 'KeywordVoid',
+  [TokenType.Function]: 'Function',
 }
 
 export const initialLineState = {
@@ -89,14 +100,14 @@ export const initialLineState = {
 }
 
 const RE_KEYWORD =
-  /^(?:yield|with|while|void|var|typeof|type|true|try|throw|this|static|switch|super|return|public|protected|private|package|null|new|let|interface|instanceof|in|import|implements|if|function|for|finally|from|false|extends|export|enum|else|do|delete|default|debugger|declare|continue|const|class|catch|case|break|await)\b/
+  /^(?:yield|with|while|void|var|typeof|type|true|try|throw|this|static|switch|super|return|public|protected|private|package|null|new|let|interface|instanceof|in|import|implements|if|function|for|finally|from|false|extends|export|enum|else|do|delete|default|debugger|declare|continue|const|class|catch|case|break|await|async)\b/
 const RE_WHITESPACE = /^\s+/
-const RE_VARIABLE_NAME = /^[\$a-zA-Z]+/
+const RE_VARIABLE_NAME = /^[\$a-zA-Z\_][\$a-zA-Z\_\d]*/
 const RE_PUNCTUATION = /^[:,;\{\}\[\]\.=\(\)>\+]/
 const RE_QUOTE_SINGLE = /^'/
 const RE_QUOTE_DOUBLE = /^"/
-const RE_STRING_SINGLE_QUOTE_CONTENT = /^[^']+/
-const RE_STRING_DOUBLE_QUOTE_CONTENT = /^[^"]+/
+const RE_STRING_SINGLE_QUOTE_CONTENT = /^[^\\']+/
+const RE_STRING_DOUBLE_QUOTE_CONTENT = /^[^\\"]+/
 const RE_NUMERIC = /^\d+/
 const RE_COLON = /^\:/
 const RE_TYPE_PRIMITIVE = /^(?:string|boolean|number|bigint|symbol|void|any)\b/
@@ -131,6 +142,15 @@ const RE_COMMA = /^\,/
 const RE_DOT = /^\./
 const RE_SQUARE_OPEN = /^\[/
 const RE_SQUARE_CLOSE = /^\]/
+const RE_QUESTION_MARK = /^\?/
+const RE_EXCLAMATION_MARK = /^\!/
+const RE_STAR = /^\*/
+const RE_AS = /^as/
+const RE_ESCAPE = /^\\.?/
+const RE_ANGLE_OPEN = /^</
+const RE_ANGLE_CLOSE = /^>/
+const RE_OPERATOR = /^[!\*\?\.\:\|\%\&\^@]/
+const RE_METHOD_NAME = /^[\w\d]+(?=\s*(\(|\:\s*function|\:\s*\())/
 
 export const hasArrayReturn = true
 
@@ -149,8 +169,6 @@ export const tokenizeLine = (line, lineState) => {
   let stack = lineState.stack
   while (index < line.length) {
     const part = line.slice(index)
-    part
-    state
     switch (state) {
       case State.TopLevelContent:
         if ((next = part.match(RE_WHITESPACE))) {
@@ -178,6 +196,10 @@ export const tokenizeLine = (line, lineState) => {
             case 'if':
             case 'break':
             case 'throw':
+            case 'while':
+            case 'try':
+            case 'catch':
+            case 'finally':
               token = TokenType.KeywordControl
               state = State.TopLevelContent
               break
@@ -211,6 +233,10 @@ export const tokenizeLine = (line, lineState) => {
               token = TokenType.KeywordVoid
               state = State.TopLevelContent
               break
+            case 'interface':
+              token = TokenType.Keyword
+              state = State.AfterKeywordInterface
+              break
             default:
               token = TokenType.Keyword
               state = State.TopLevelContent
@@ -246,7 +272,10 @@ export const tokenizeLine = (line, lineState) => {
         } else if ((next = part.match(RE_QUOTE_DOUBLE))) {
           token = TokenType.Punctuation
           state = State.InsideDoubleQuoteString
-        } else if ((next = part.match(RE_VERTICAL_LINE))) {
+        } else if ((next = part.match(RE_OPERATOR))) {
+          token = TokenType.Punctuation
+          state = State.TopLevelContent
+        } else if ((next = part.match(RE_ANGLE_OPEN))) {
           token = TokenType.Punctuation
           state = State.TopLevelContent
         } else {
@@ -261,6 +290,9 @@ export const tokenizeLine = (line, lineState) => {
         } else if ((next = part.match(RE_STRING_SINGLE_QUOTE_CONTENT))) {
           token = TokenType.String
           state = State.InsideSingleQuoteString
+        } else if ((next = part.match(RE_ESCAPE))) {
+          token = TokenType.String
+          state = State.InsideSingleQuoteString
         } else {
           throw new Error('no')
         }
@@ -272,6 +304,9 @@ export const tokenizeLine = (line, lineState) => {
         } else if ((next = part.match(RE_STRING_DOUBLE_QUOTE_CONTENT))) {
           token = TokenType.String
           state = State.InsideDoubleQuoteString
+        } else if ((next = part.match(RE_ESCAPE))) {
+          token = TokenType.String
+          state = State.InsideDoubleQuoteString
         } else {
           throw new Error('no')
         }
@@ -292,13 +327,18 @@ export const tokenizeLine = (line, lineState) => {
         } else if ((next = part.match(RE_EQUAL))) {
           token = TokenType.Punctuation
           state = State.TopLevelContent
+        } else if ((next = part.match(RE_CURLY_OPEN))) {
+          token = TokenType.Punctuation
+          state = State.InsideObjectDestructuring
+        } else if ((next = part.match(RE_DOT))) {
+          token = TokenType.Punctuation
+          state = State.TopLevelContent
         } else {
           line
           part
           throw new Error('no')
         }
         break
-
       case State.AfterKeywordTypeDeclaration:
         if ((next = part.match(RE_WHITESPACE))) {
           token = TokenType.Whitespace
@@ -315,14 +355,13 @@ export const tokenizeLine = (line, lineState) => {
         }
         break
       case State.BeforeType:
-        part
         if ((next = part.match(RE_WHITESPACE))) {
           token = TokenType.Whitespace
           state = State.BeforeType
         } else if ((next = part.match(RE_TYPE_PRIMITIVE))) {
           part
           token = TokenType.TypePrimitive
-          state = State.AfterType
+          state = stack.pop() || State.AfterType
         } else if ((next = part.match(RE_VARIABLE_NAME))) {
           part
           token = TokenType.Type
@@ -333,6 +372,7 @@ export const tokenizeLine = (line, lineState) => {
         } else if ((next = part.match(RE_ROUND_OPEN))) {
           token = TokenType.Punctuation
           state = State.InsideTypeExpression
+          stack.push(State.AfterTypeExpression)
         } else if ((next = part.match(RE_ARROW))) {
           token = TokenType.Punctuation
           state = State.BeforeType
@@ -345,20 +385,25 @@ export const tokenizeLine = (line, lineState) => {
         } else if ((next = part.match(RE_NUMERIC))) {
           token = TokenType.Numeric
           state = State.AfterType
+        } else if ((next = part.match(RE_CURLY_OPEN))) {
+          token = TokenType.Punctuation
+          state = State.InsideTypeObject
+        } else if ((next = part.match(RE_QUOTE_SINGLE))) {
+          token = TokenType.Punctuation
+          state = State.InsideSingleQuoteString
+          stack.push(State.BeforeType)
         } else {
           part
           throw new Error('no')
         }
         break
       case State.InsideTypeExpression:
-        part
         if ((next = part.match(RE_ROUND_CLOSE))) {
           token = TokenType.Punctuation
           state = State.AfterTypeExpression
         } else if ((next = part.match(RE_VARIABLE_NAME))) {
           token = TokenType.VariableName
           state = State.AfterVariableName
-          stack.push(State.InsideTypeExpression)
         } else if ((next = part.match(RE_WHITESPACE))) {
           token = TokenType.Whitespace
           state = State.InsideTypeExpression
@@ -376,6 +421,15 @@ export const tokenizeLine = (line, lineState) => {
         } else if ((next = part.match(RE_WHITESPACE))) {
           token = TokenType.Whitespace
           state = State.AfterTypeExpression
+        } else if ((next = part.match(RE_COMMA))) {
+          token = TokenType.Punctuation
+          state = State.InsideTypeExpression
+        } else if ((next = part.match(RE_ROUND_CLOSE))) {
+          token = TokenType.Punctuation
+          state = stack.pop() || State.AfterTypeExpression
+        } else if ((next = part.match(RE_CURLY_CLOSE))) {
+          token = TokenType.Punctuation
+          state = stack.pop() || State.TopLevelContent
         } else {
           part
           throw new Error('no')
@@ -404,7 +458,6 @@ export const tokenizeLine = (line, lineState) => {
         }
         break
       case State.AfterType:
-        part
         if ((next = part.match(RE_SEMICOLON))) {
           token = TokenType.Punctuation
           state = stack.pop() || State.TopLevelContent
@@ -423,7 +476,7 @@ export const tokenizeLine = (line, lineState) => {
           state = State.BeforeType
         } else if ((next = part.match(RE_ROUND_CLOSE))) {
           token = TokenType.Punctuation
-          state = State.BeforeType
+          state = stack.pop() || State.BeforeType
         } else if ((next = part.match(RE_COMMA))) {
           token = TokenType.Punctuation
           state = stack.pop() || State.TopLevelContent
@@ -433,9 +486,23 @@ export const tokenizeLine = (line, lineState) => {
         } else if ((next = part.match(RE_SQUARE_OPEN))) {
           token = TokenType.Punctuation
           state = State.AfterType
+          stack.push(State.AfterType)
         } else if ((next = part.match(RE_SQUARE_CLOSE))) {
           token = TokenType.Punctuation
           state = State.AfterType
+        } else if ((next = part.match(RE_VERTICAL_LINE))) {
+          token = TokenType.Punctuation
+          state = State.BeforeType
+        } else if ((next = part.match(RE_ANGLE_OPEN))) {
+          token = TokenType.Punctuation
+          state = State.BeforeType
+          stack.push(State.AfterType)
+        } else if ((next = part.match(RE_VARIABLE_NAME))) {
+          token = TokenType.Type
+          state = State.AfterType
+        } else if ((next = part.match(RE_ANGLE_CLOSE))) {
+          token = TokenType.Punctuation
+          state = State.AfterType
         } else {
           // stack.push(State.AfterType)
           part
@@ -525,7 +592,7 @@ export const tokenizeLine = (line, lineState) => {
           state = State.InsideBlockComment
         } else if ((next = part.match(RE_BLOCK_COMMENT_END))) {
           token = TokenType.Comment
-          state = State.TopLevelContent
+          state = stack.pop() || State.TopLevelContent
         } else if ((next = part.match(RE_ANYTHING_UNTIL_END))) {
           token = TokenType.Comment
           state = State.InsideBlockComment
@@ -582,11 +649,124 @@ export const tokenizeLine = (line, lineState) => {
           stack
           token = TokenType.Punctuation
           state = stack.pop() || State.TopLevelContent
+        } else if ((next = part.match(RE_SEMICOLON))) {
+          token = TokenType.Punctuation
+          state = State.InsideClass
+        } else {
+          part
+          throw new Error('no')
+        }
+        break
+      case State.InsideObjectDestructuring:
+        if ((next = part.match(RE_WHITESPACE))) {
+          token = TokenType.Whitespace
+          state = State.InsideObjectDestructuring
+        } else if ((next = part.match(RE_VARIABLE_NAME))) {
+          token = TokenType.VariableName
+          state = State.InsideObjectDestructuringAfterValue
+        } else {
+          throw new Error('no')
+        }
+        break
+      case State.InsideObjectDestructuringAfterValue:
+        if ((next = part.match(RE_WHITESPACE))) {
+          token = TokenType.Whitespace
+          state = State.InsideObjectDestructuringAfterValue
+        } else if ((next = part.match(RE_CURLY_CLOSE))) {
+          token = TokenType.Punctuation
+          state = State.AfterKeywordDeclaration
+        } else {
+          throw new Error('no')
+        }
+        break
+      case State.AfterKeywordInterface:
+        if ((next = part.match(RE_WHITESPACE))) {
+          token = TokenType.Whitespace
+          state = State.AfterKeywordInterface
+        } else if ((next = part.match(RE_VARIABLE_NAME))) {
+          token = TokenType.Type
+          state = State.BeforeType
+        } else {
+          throw new Error('no')
+        }
+        break
+      case State.InsideTypeObject:
+        if ((next = part.match(RE_WHITESPACE))) {
+          token = TokenType.Whitespace
+          state = State.InsideTypeObject
+        } else if ((next = part.match(RE_BLOCK_COMMENT_START))) {
+          token = TokenType.Comment
+          state = State.InsideBlockComment
+          stack.push(State.InsideTypeObject)
+        } else if ((next = part.match(RE_METHOD_NAME))) {
+          token = TokenType.Function
+          state = State.AfterMethodName
+        } else if ((next = part.match(RE_VARIABLE_NAME))) {
+          token = TokenType.VariableName
+          state = State.InsideTypeObject
+        } else if ((next = part.match(RE_CURLY_CLOSE))) {
+          token = TokenType.Punctuation
+          state = stack.pop() || State.TopLevelContent
+        } else if ((next = part.match(RE_COLON))) {
+          token = TokenType.Punctuation
+          state = State.BeforeType
+          stack.push(State.InsideTypeObject)
+        } else if ((next = part.match(RE_COMMA))) {
+          token = TokenType.Punctuation
+          state = State.InsideTypeObject
+        } else if ((next = part.match(RE_SEMICOLON))) {
+          token = TokenType.Punctuation
+          state = State.InsideTypeObject
         } else {
           part
           throw new Error('no')
         }
         break
+      case State.AfterMethodName:
+        if ((next = part.match(RE_ROUND_OPEN))) {
+          token = TokenType.Punctuation
+          state = State.InsideMethodParameters
+          // stack.push()
+        } else {
+          throw new Error('no')
+        }
+        break
+      case State.InsideMethodParameters:
+        if ((next = part.match(RE_VARIABLE_NAME))) {
+          token = TokenType.VariableName
+          state = State.InsideMethodParametersAfterVariableName
+        } else if ((next = part.match(RE_ROUND_CLOSE))) {
+          token = TokenType.Punctuation
+          state = State.AfterMethodParameters
+        } else if ((next = part.match(RE_CURLY_CLOSE))) {
+          token = TokenType.Punctuation
+          state = stack.pop() || State.TopLevelContent
+        } else if ((next = part.match(RE_COLON))) {
+          token = TokenType.Punctuation
+          state = State.BeforeType
+        } else {
+          part
+          throw new Error('no')
+        }
+        break
+      case State.InsideMethodParametersAfterVariableName:
+        if ((next = part.match(RE_COLON))) {
+          token = TokenType.Punctuation
+          state = State.BeforeType
+          stack.push(State.InsideMethodParameters)
+        } else {
+          throw new Error('no')
+        }
+        break
+      case State.AfterMethodParameters:
+        if ((next = part.match(RE_COLON))) {
+          token = TokenType.Punctuation
+          state = State.BeforeType
+          stack.push(State.InsideTypeObject)
+        } else {
+          throw new Error('no')
+        }
+        break
       default:
         state
         throw new Error('no')
@@ -598,6 +778,8 @@ export const tokenizeLine = (line, lineState) => {
   if (state === State.AfterType && stack[0] === State.InsideClass) {
     state = State.InsideClass
     stack.pop()
+  } else if (state === State.AfterType) {
+    state = stack.pop() || State.TopLevelContent
   }
   return {
     state,

package/extensions/builtin.language-basics-xml/src/tokenizeXml.js

@@ -79,7 +79,7 @@ const RE_SLASH = /^\//
 const RE_STRING_DOUBLE_QUOTE_CONTENT = /^[^"]+/
 const RE_STRING_SINGLE_QUOTE_CONTENT = /^[^']+/
 const RE_TAG_TEXT = /^[^\s>]+/
-const RE_TAGNAME = /^[!\w]+/
+const RE_TAGNAME = /^[!\w\-]+/
 const RE_TEXT = /^[^<>\n]+/
 const RE_WHITESPACE = /^\s+/
 const RE_WORD = /^[^\s]+/

package/extensions/builtin.theme-ayu/color-theme.json

@@ -12,6 +12,8 @@
     "ContextMenuBackground": "rgb(252, 252, 252)",
     "ContextMenuForeground": "rgb(138, 145, 153)",
 
+    "DebugSectionHeaderBackground": "#f8f9fa",
+
     "EditorBackGround": "",
     "EditorScrollBarBackground": "rgba(138, 145, 153, 0.6)",
     "EditorCursorBackground": "#ffaa33",

package/extensions/builtin.theme-slime/color-theme.json

@@ -19,6 +19,8 @@
     "InputBackground": "rgb(36, 41, 42)",
     "InputForeground": "rgb(225, 225, 225)",
 
+    "LinkForeground": "#3794ff",
+
     "ListActiveSelectionBackground": "#515f59",
     "ListActiveSelectionForeground": "#ffffff",
     "ListHoverBackground": "#405c5033",
@@ -224,6 +226,10 @@
     {
       "name": "CssAtRule",
       "foreground": "#E78484"
+    },
+    {
+      "name": "KeywordThis",
+      "foreground": "#BE9296"
     }
   ]
 }

package/index.js

@@ -5,12 +5,15 @@ const __dirname = dirname(fileURLToPath(import.meta.url))
 
 export const sharedProcessPath = join(__dirname, 'src', 'sharedProcessMain.js')
 
-export const exportStatic = async ({ extensionPath = process.cwd() } = {}) => {
+export const exportStatic = async ({
+  extensionPath = process.cwd(),
+  testPath = '',
+} = {}) => {
   const fn = await import('./src/parts/ExportStatic/ExportStatic.js')
   const root = process.cwd()
   if (extensionPath !== root) {
     extensionPath = join(root, extensionPath)
   }
   const pathPrefix = process.env.PATH_PREFIX || ''
-  await fn.exportStatic({ root, pathPrefix, extensionPath })
+  await fn.exportStatic({ root, pathPrefix, extensionPath, testPath })
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/shared-process",
-  "version": "0.11.6",
+  "version": "0.11.8",
   "description": "Utility package for @lvce-editor/server",
   "main": "index.js",
   "type": "module",
@@ -17,12 +17,12 @@
   },
   "dependencies": {
     "@babel/code-frame": "^7.18.6",
-    "@lvce-editor/extension-host": "0.11.6",
-    "@lvce-editor/extension-host-helper-process": "0.11.6",
-    "@lvce-editor/pty-host": "0.11.6",
+    "@lvce-editor/extension-host": "0.11.8",
+    "@lvce-editor/extension-host-helper-process": "0.11.8",
+    "@lvce-editor/pty-host": "0.11.8",
     "debug": "^4.3.4",
     "execa": "^6.1.0",
-    "exit-hook": "^3.1.2",
+    "exit-hook": "^3.1.4",
     "got": "^12.5.3",
     "is-object": "^1.0.2",
     "lines-and-columns": "^2.0.3",

package/src/parts/Command/Command.js

@@ -1,8 +1,8 @@
 import * as ModuleMap from '../ModuleMap/ModuleMap.js'
+import { VError } from '../VError/VError.js'
 
 export const state = {
   commands: Object.create(null),
-  invocables: Object.create(null),
   pendingModules: Object.create(null),
   async load(moduleId) {},
 }
@@ -19,67 +19,65 @@ const initializeModule = (module) => {
     }
     return
   }
-  throw new Error(`module ${module.name} is missing commands`)
+  throw new Error(
+    `module ${module.name} is missing an initialize function and commands`
+  )
+}
+
+const loadModule = async (moduleId) => {
+  try {
+    const module = await state.load(moduleId)
+    initializeModule(module)
+  } catch (error) {
+    if (
+      error &&
+      error instanceof SyntaxError &&
+      error.stack === `SyntaxError: ${error.message}`
+    ) {
+      Error.captureStackTrace(error, loadModule)
+    }
+    throw new VError(error, `failed to load module ${moduleId}`)
+  }
 }
 
 const getOrLoadModule = (moduleId) => {
   if (!state.pendingModules[moduleId]) {
-    const importPromise = state.load(moduleId)
-    state.pendingModules[moduleId] = importPromise
-      .then(initializeModule)
-      .catch((error) => {
-        console.error(error)
-      })
+    state.pendingModules[moduleId] = loadModule(moduleId)
   }
   return state.pendingModules[moduleId]
 }
 
-const loadCommand = (command) => getOrLoadModule(ModuleMap.getModuleId(command))
+const loadCommand = async (command) => {
+  await getOrLoadModule(ModuleMap.getModuleId(command))
+}
 
 export const register = (commandId, listener) => {
   state.commands[commandId] = listener
 }
 
-export const registerInvocable = (commandId, listener) => {
-  state.invocables[commandId] = listener
-}
+const hasThrown = new Set()
 
-export const invoke = async (command, ...args) => {
-  if (!(command in state.commands)) {
+const executeCommandAsync = async (command, ...args) => {
+  try {
     await loadCommand(command)
-    if (!(command in state.commands)) {
-      console.warn(`[shared process] Unknown command "${command}"`)
-      throw new Error(`Command ${command} not found`)
-    }
+  } catch (error) {
+    throw new VError(error, `Failed to load command ${command}`)
   }
-  if (typeof state.commands[command] !== 'function') {
-    throw new TypeError(`Command ${command} is not a function`)
+  if (!(command in state.commands)) {
+    if (hasThrown.has(command)) {
+      return
+    }
+    hasThrown.add(command)
+    throw new Error(`Command did not register "${command}"`)
   }
-  return state.commands[command](...args)
+  return execute(command, ...args)
 }
 
 export const execute = (command, ...args) => {
   if (command in state.commands) {
-    state.commands[command](...args)
-  } else {
-    loadCommand(command)
-      // TODO can skip then block in prod (only to prevent endless loop in dev)
-      .then(() => {
-        if (!(command in state.commands)) {
-          console.warn(`Unknown command "${command}"`)
-          return
-        }
-        try {
-          execute(command, ...args)
-        } catch (error) {
-          console.error('[shared process] command failed to execute')
-          console.error(error)
-        }
-      })
-      .catch((error) => {
-        console.error(error)
-      })
+    return state.commands[command](...args)
   }
+  return executeCommandAsync(command, ...args)
 }
 
 export const setLoad = (load) => {

package/src/parts/ErrorCodes/ErrorCodes.js

@@ -19,3 +19,5 @@ export const E_ICON_THEME_NOT_FOUND = 'E_ICON_THEME_NOT_FOUND'
 export const ECONNRESET = 'ECONNRESET'
 
 export const EPERM = 'EPERM'
+
+export const ERR_MODULE_NOT_FOUND = 'ERR_MODULE_NOT_FOUND'