@lvce-editor/shared-process 0.95.1 → 0.95.3

package/config/defaultSettings.json

@@ -11,7 +11,7 @@
   "editor.fontLigatures": true,
   "editor.links": true,
   "editor.tabSize": 2,
-  "editor.hover": false,
+  "editor.hover": true,
 
   "editor.autoClosingBrackets": true,
   "editor.autoClosingQuotes": true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/shared-process",
-  "version": "0.95.1",
+  "version": "0.95.3",
   "main": "index.js",
   "type": "module",
   "keywords": [
@@ -19,7 +19,7 @@
   "dependencies": {
     "@lvce-editor/assert": "1.7.0",
     "@lvce-editor/auth-process": "1.12.0",
-    "@lvce-editor/extension-host-helper-process": "0.95.1",
+    "@lvce-editor/extension-host-helper-process": "0.95.3",
     "@lvce-editor/ipc": "16.6.0",
     "@lvce-editor/json-rpc": "8.5.0",
     "@lvce-editor/jsonc-parser": "1.5.0",

package/src/parts/BuiltinExtensionsPath/BuiltinExtensionsPath.js

@@ -3,6 +3,6 @@ import { fileURLToPath } from 'url'
 
 export const getBuiltinExtensionsPath = () => {
   const staticServerPath = fileURLToPath(import.meta.resolve('@lvce-editor/static-server'))
-  const builtinExtensionsPath = join(staticServerPath, '..', '..', 'static', '2572a83', 'extensions')
+  const builtinExtensionsPath = join(staticServerPath, '..', '..', 'static', '6f688db', 'extensions')
   return builtinExtensionsPath
 }

package/src/parts/LanguageServer/LanguageServer.js

@@ -13,6 +13,7 @@ import { normalizeLanguageServerDocumentUri } from '../NormalizeLanguageServerDo
                                   
                      
                          
+                           
                                      
                       
  
@@ -20,6 +21,7 @@ import { normalizeLanguageServerDocumentUri } from '../NormalizeLanguageServerDo
                                     
                                   
                      
+                           
                                      
                       
  
@@ -61,23 +63,23 @@ const getConnection = (id, uri, argv, rootUri) => {
   return connection
 }
 
-export const complete = async ({ argv, id, offset, textDocument, uri }                 ) => {
+export const complete = async ({ argv, id, offset, rootUri, textDocument, uri }                 ) => {
   const normalizedDocument = {
     ...textDocument,
     uri: normalizeLanguageServerDocumentUri(textDocument.uri),
   }
-  const rootUri = getRootUri(normalizedDocument.uri)
-  const connection = getConnection(`${id}:${rootUri}`, uri, argv, rootUri)
+  const normalizedRootUri = rootUri ? normalizeLanguageServerDocumentUri(rootUri) : getRootUri(normalizedDocument.uri)
+  const connection = getConnection(`${id}:${normalizedRootUri}`, uri, argv, normalizedRootUri)
   return connection.complete(normalizedDocument, offset)
 }
 
-export const diagnostic = async ({ argv, id, textDocument, uri }                   ) => {
+export const diagnostic = async ({ argv, id, rootUri, textDocument, uri }                   ) => {
   const normalizedDocument = {
     ...textDocument,
     uri: normalizeLanguageServerDocumentUri(textDocument.uri),
   }
-  const rootUri = getRootUri(normalizedDocument.uri)
-  const connection = getConnection(`${id}:${rootUri}`, uri, argv, rootUri)
+  const normalizedRootUri = rootUri ? normalizeLanguageServerDocumentUri(rootUri) : getRootUri(normalizedDocument.uri)
+  const connection = getConnection(`${id}:${normalizedRootUri}`, uri, argv, normalizedRootUri)
   return connection.diagnostic(normalizedDocument)
 }
 

package/src/parts/LanguageServerConnection/LanguageServerConnection.js

@@ -23,6 +23,22 @@ import {
                                             
  
 
+                              
+                                         
+                                                       
+ 
+
+                            
+                           
+                                         
+   
+ 
+
+                    
+                                 
+                              
+ 
+
                         
                              
                        
@@ -74,17 +90,40 @@ const getWorkspaceName = (rootUri) => {
   }
 }
 
+const createDeferred = () => {
+  let resolve = () => {}
+  const promise = new Promise      ((resolvePromise) => {
+    resolve = resolvePromise
+  })
+  return { promise, resolve }
+}
+
+const wait = (duration) => {
+  return new Promise((resolve) => {
+    setTimeout(resolve, duration)
+  })
+}
+
+const PublishDiagnosticsTimeout = 1_000
+
 export class LanguageServerConnection {
                    child                                
+                   configurationHandled = createDeferred()
+                   diagnosticWaiters = new Map                                 ()
                    documents = new Map                       ()
+                   initializationProgressEnded = createDeferred()
+                   initializationProgressStarted = createDeferred()
                    parser = new LanguageServerMessageParser()
                    pendingRequests = new Map                                 ()
+                   publishedDiagnostics = new Map                            ()
                    ready               
                    rootUri        
+          initializationProgressWasStarted = false
           markdownConfigured = false
           nextRequestId = 1
           running = true
           stderr = ''
+          supportsPullDiagnostics = false
 
   constructor({ argv, rootUri, uri }                                 ) {
     this.rootUri = rootUri
@@ -147,16 +186,29 @@ export class LanguageServerConnection {
   async diagnostic(textDocument)                              {
     await this.ready
     this.configureMarkdown(textDocument.languageId)
-    this.syncDocument(textDocument)
-    const result = await this.sendRequest('textDocument/diagnostic', {
-      textDocument: {
-        uri: textDocument.uri,
-      },
-    })
-    if (result && typeof result === 'object' && Array.isArray((result).items)) {
-      return (result).items
+    if (this.supportsPullDiagnostics) {
+      this.syncDocument(textDocument)
+      const result = await this.sendRequest('textDocument/diagnostic', {
+        textDocument: {
+          uri: textDocument.uri,
+        },
+      })
+      if (result && typeof result === 'object' && Array.isArray((result).items)) {
+        return (result).items
+      }
+      return []
     }
-    return []
+    const previous = this.documents.get(textDocument.uri)
+    const documentChanged = !previous || previous.languageId !== textDocument.languageId || previous.text !== textDocument.text
+    const cached = this.publishedDiagnostics.get(textDocument.uri)
+    if (!documentChanged && cached) {
+      return cached
+    }
+    const diagnostics = this.waitForPublishedDiagnostics(textDocument.uri)
+    if (documentChanged) {
+      this.syncDocument(textDocument)
+    }
+    return diagnostics
   }
 
           configureMarkdown(languageId)       {
@@ -206,7 +258,7 @@ export class LanguageServerConnection {
   }
 
           async initialize()                {
-    await this.sendRequest('initialize', {
+    const result = (await this.sendRequest('initialize', {
       capabilities: {
         textDocument: {
           completion: {
@@ -218,11 +270,17 @@ export class LanguageServerConnection {
             dynamicRegistration: false,
             relatedDocumentSupport: false,
           },
+          publishDiagnostics: {
+            relatedInformation: true,
+          },
           synchronization: {
             didSave: true,
             dynamicRegistration: false,
           },
         },
+        window: {
+          workDoneProgress: true,
+        },
         workspace: {
           configuration: true,
           workspaceFolders: true,
@@ -239,8 +297,15 @@ export class LanguageServerConnection {
           uri: this.rootUri,
         },
       ],
-    })
+    }))                    
+    this.supportsPullDiagnostics = Boolean(result?.capabilities?.diagnosticProvider)
     this.sendNotification('initialized', {})
+    await Promise.race([this.initializationProgressStarted.promise, wait(100)])
+    if (this.initializationProgressWasStarted) {
+      await Promise.race([this.initializationProgressEnded.promise, wait(30_000)])
+    }
+    await Promise.race([this.configurationHandled.promise, wait(100)])
+    await wait(0)
   }
 
           syncDocument(textDocument)       {
@@ -303,6 +368,14 @@ export class LanguageServerConnection {
   }
 
           handleMessage(message)       {
+    if (message.method === 'textDocument/publishDiagnostics') {
+      this.handlePublishedDiagnostics(message.params)
+      return
+    }
+    if (message.method === '$/progress') {
+      this.handleProgress(message.params)
+      return
+    }
     if (message.method && message.id !== undefined && message.id !== null) {
       void this.handleServerRequest(message)
       return
@@ -322,12 +395,45 @@ export class LanguageServerConnection {
     pending.resolve(message.result)
   }
 
+          handlePublishedDiagnostics(params)       {
+    if (!params || typeof params !== 'object') {
+      return
+    }
+    const { diagnostics, uri } = params                                                              
+    if (typeof uri !== 'string' || !Array.isArray(diagnostics)) {
+      return
+    }
+    this.publishedDiagnostics.set(uri, diagnostics)
+    const waiters = this.diagnosticWaiters.get(uri)
+    if (!waiters) {
+      return
+    }
+    this.diagnosticWaiters.delete(uri)
+    for (const waiter of waiters) {
+      waiter.resolve(diagnostics)
+    }
+  }
+
+          handleProgress(params)       {
+    if (!params || typeof params !== 'object') {
+      return
+    }
+    const { value } = params                                
+    if (!value || typeof value !== 'object' || (value).kind !== 'end') {
+      return
+    }
+    this.initializationProgressEnded.resolve()
+  }
+
           async handleServerRequest(message)                {
     try {
       let result          = null
       if (message.method === 'workspace/configuration') {
         const itemCount = Array.isArray(message.params?.items) ? message.params.items.length : 0
         result = Array.from({ length: itemCount }).fill(null)
+      } else if (message.method === 'window/workDoneProgress/create') {
+        this.initializationProgressWasStarted = true
+        this.initializationProgressStarted.resolve()
       } else if (message.method === 'workspace/workspaceFolders') {
         result = [
           {
@@ -346,6 +452,9 @@ export class LanguageServerConnection {
         jsonrpc: '2.0',
         result,
       })
+      if (message.method === 'workspace/configuration') {
+        this.configurationHandled.resolve()
+      }
     } catch (error) {
       this.sendMessage({
         error: {
@@ -371,6 +480,12 @@ export class LanguageServerConnection {
       pending.reject(error)
     }
     this.pendingRequests.clear()
+    for (const waiters of this.diagnosticWaiters.values()) {
+      for (const waiter of waiters) {
+        waiter.reject(error)
+      }
+    }
+    this.diagnosticWaiters.clear()
   }
 
           sendNotification(method, params)       {
@@ -398,6 +513,32 @@ export class LanguageServerConnection {
     return promise
   }
 
+          waitForPublishedDiagnostics(uri)                              {
+    return new Promise                    ((resolve, reject) => {
+      const waiters = this.diagnosticWaiters.get(uri) || new Set()
+      let timeout                               
+      const waiter = {
+        reject(error)       {
+          clearTimeout(timeout)
+          reject(error)
+        },
+        resolve(value)       {
+          clearTimeout(timeout)
+          resolve(value)
+        },
+      }
+      timeout = setTimeout(() => {
+        waiters.delete(waiter)
+        if (waiters.size === 0) {
+          this.diagnosticWaiters.delete(uri)
+        }
+        resolve(this.publishedDiagnostics.get(uri) || [])
+      }, PublishDiagnosticsTimeout)
+      waiters.add(waiter)
+      this.diagnosticWaiters.set(uri, waiters)
+    })
+  }
+
           sendMessage(message)       {
     const content = JSON.stringify(message)
     const header = `Content-Length: ${Buffer.byteLength(content)}\r\n\r\n`

package/src/parts/NormalizeLanguageServerDocumentUri/NormalizeLanguageServerDocumentUri.js

@@ -2,9 +2,22 @@ import { pathToFileURL } from 'node:url'
 
 const windowsFileUriRegex = /^file:\/\/\/([a-z])(?::|%3a)(?=\/|$)/i
 
+const normalizeRemoteFileUrl = (uri) => {
+  try {
+    const url = new URL(uri)
+    if ((url.protocol === 'http:' || url.protocol === 'https:') && url.pathname.startsWith('/remote/')) {
+      return `file://${url.pathname.slice('/remote'.length)}`
+    }
+  } catch {
+    return undefined
+  }
+  return undefined
+}
+
 export const normalizeLanguageServerDocumentUri = (uri) => {
   if (uri.startsWith('/')) {
     return pathToFileURL(uri).href
   }
-  return uri.replace(windowsFileUriRegex, (_, driveLetter) => `file:///${driveLetter.toLowerCase()}%3A`)
+  const normalizedUri = normalizeRemoteFileUrl(uri) || uri
+  return normalizedUri.replace(windowsFileUriRegex, (_, driveLetter) => `file:///${driveLetter.toLowerCase()}%3A`)
 }

package/src/parts/Platform/Platform.js

@@ -61,11 +61,11 @@ export const getSetupName = () => {
   return 'Lvce-Setup'
 }
 
-export const version = '0.95.1'
+export const version = '0.95.3'
 
-export const commit = '2572a83'
+export const commit = '6f688db'
 
-export const date = '2026-07-29T14:03:33.000Z'
+export const date = '2026-07-29T19:12:57.000Z'
 
 export const getVersion = () => {
   return version

package/src/parts/PreloadUrl/PreloadUrl.js

@@ -2,5 +2,5 @@ import { join } from 'node:path'
 import * as Root from '../Root/Root.js'
 
 export const getPreloadUrl = () => {
-  return join(Root.root, 'static', '2572a83', 'packages', 'preload', 'dist', 'index.js')
+  return join(Root.root, 'static', '6f688db', 'packages', 'preload', 'dist', 'index.js')
 }