@lvce-editor/shared-process 0.85.3 → 0.86.0

package/src/parts/SendIncomingIpc/SendIncomingIpc.js

@@ -1,32 +1,35 @@
-import * as HandleIpc from '../HandleIpc/HandleIpc.js';
-import * as IpcId from '../IpcId/IpcId.js';
-import * as IpcTransferState from '../IpcTransferState/IpcTransferState.js';
-import * as JsonRpc from '../JsonRpc/JsonRpc.js';
+import * as HandleIpc from '../HandleIpc/HandleIpc.js'
+import * as IpcId from '../IpcId/IpcId.js'
+import * as IpcTransferState from '../IpcTransferState/IpcTransferState.js'
+import * as JsonRpc from '../JsonRpc/JsonRpc.js'
+
 const supportsPartialIpcHandling = (ipcId) => {
-    switch (ipcId) {
-        case IpcId.AuthProcess:
-        case IpcId.TerminalProcess:
-        case IpcId.ProcessExplorer:
-        case IpcId.EmbedsProcess:
-            return true;
-        default:
-            return false;
-    }
-};
+  switch (ipcId) {
+    case IpcId.AuthProcess:
+    case IpcId.TerminalProcess:
+    case IpcId.ProcessExplorer:
+    case IpcId.EmbedsProcess:
+      return true
+    default:
+      return false
+  }
+}
+
 // TODO fork ipc object instead of ref counting
 // duplicated ipc object sends and receives one message
 // original ipc object is never used and can
 // be collected after being out of scope
 // duplicated ipc can also be collected
 // when it is out of scope
+
 export const sendIncomingIpc = async (target, response, ipcId) => {
-    if (!IpcTransferState.has(ipcId) && supportsPartialIpcHandling(ipcId)) {
-        HandleIpc.handleIpc(target);
-    }
-    IpcTransferState.add(ipcId);
-    await JsonRpc.invokeAndTransfer(target, response.method, ...response.params);
-    IpcTransferState.remove(ipcId);
-    if (!IpcTransferState.has(ipcId) && supportsPartialIpcHandling(ipcId)) {
-        HandleIpc.unhandleIpc(target);
-    }
-};
+  if (!IpcTransferState.has(ipcId) && supportsPartialIpcHandling(ipcId)) {
+    HandleIpc.handleIpc(target)
+  }
+  IpcTransferState.add(ipcId)
+  await JsonRpc.invokeAndTransfer(target, response.method, ...response.params)
+  IpcTransferState.remove(ipcId)
+  if (!IpcTransferState.has(ipcId) && supportsPartialIpcHandling(ipcId)) {
+    HandleIpc.unhandleIpc(target)
+  }
+}

package/src/parts/SetHeaders/SetHeaders.js

@@ -1,5 +1,5 @@
 export const setHeaders = (response, headers) => {
-    for (const [key, value] of Object.entries(headers)) {
-        response.setHeader(key, value);
-    }
-};
+  for (const [key, value] of Object.entries(headers)) {
+    response.setHeader(key, value)
+  }
+}

package/src/parts/ShouldLogError/ShouldLogError.js

@@ -1,7 +1,8 @@
-import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js';
+import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
+
 export const shouldLogError = (error) => {
-    if (error && error.code === ErrorCodes.ENOENT) {
-        return false;
-    }
-    return true;
-};
+  if (error && error.code === ErrorCodes.ENOENT) {
+    return false
+  }
+  return true
+}

package/src/parts/ShouldTranspileTypescript/ShouldTranspileTypescript.js

@@ -1,11 +1,12 @@
-import * as IsTypeScriptPath from '../IsTypeScriptPath/IsTypeScriptPath.js';
+import * as IsTypeScriptPath from '../IsTypeScriptPath/IsTypeScriptPath.js'
+
 export const shouldTranspileTypescript = (request, url) => {
-    if (!IsTypeScriptPath.isTypeScriptPath(url)) {
-        return false;
-    }
-    const acceptHeader = request.headers['accept'];
-    if (acceptHeader === 'text/plain') {
-        return false;
-    }
-    return true;
-};
+  if (!IsTypeScriptPath.isTypeScriptPath(url)) {
+    return false
+  }
+  const acceptHeader = request.headers['accept']
+  if (acceptHeader === 'text/plain') {
+    return false
+  }
+  return true
+}

package/src/parts/Signal/Signal.js

@@ -1,3 +1,3 @@
-export const SIGUSR1 = 'SIGUSR1';
-export const SIGTERM = 'SIGTERM';
-export const SIGINT = 'SIGINT';
+export const SIGUSR1 = 'SIGUSR1'
+export const SIGTERM = 'SIGTERM'
+export const SIGINT = 'SIGINT'

package/src/parts/SplitLines/SplitLines.js

@@ -1,4 +1,5 @@
-import * as Character from '../Character/Character.js';
+import * as Character from '../Character/Character.js'
+
 export const splitLines = (lines) => {
-    return lines.split(Character.NewLine);
-};
+  return lines.split(Character.NewLine)
+}

package/src/parts/StaticPath/StaticPath.js

@@ -1,13 +1,14 @@
-import { join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import * as IsBuiltServer from '../IsBuiltServer/IsBuiltServer.js';
-import * as Root from '../Root/Root.js';
+import { join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import * as IsBuiltServer from '../IsBuiltServer/IsBuiltServer.js'
+import * as Root from '../Root/Root.js'
+
 export const getStaticPath = () => {
-    if (IsBuiltServer.isBuiltServer) {
-        // TODO maybe move static files to separate package
-        const staticServerUri = fileURLToPath(import.meta.resolve('@lvce-editor/static-server'));
-        const staticPath = join(staticServerUri, '..', '..', 'static');
-        return staticPath;
-    }
-    return join(Root.root, 'static');
-};
+  if (IsBuiltServer.isBuiltServer) {
+    // TODO maybe move static files to separate package
+    const staticServerUri = fileURLToPath(import.meta.resolve('@lvce-editor/static-server'))
+    const staticPath = join(staticServerUri, '..', '..', 'static')
+    return staticPath
+  }
+  return join(Root.root, 'static')
+}

package/src/parts/StaticServerPath/StaticServerPath.js

@@ -1,3 +1,4 @@
-import { join } from 'path';
-import * as Root from '../Root/Root.js';
-export const staticServerPath = join(Root.root, 'packages', 'static-server');
+import { join } from 'path'
+import * as Root from '../Root/Root.js'
+
+export const staticServerPath = join(Root.root, 'packages', 'static-server')

package/src/parts/SymLink/SymLink.js

@@ -1,4 +1,5 @@
-import * as NetworkProcess from '../NetworkProcess/NetworkProcess.js';
+import * as NetworkProcess from '../NetworkProcess/NetworkProcess.js'
+
 export const createSymLink = (target, path) => {
-    return NetworkProcess.invoke('Symlink.createSymLink', target, path);
-};
+  return NetworkProcess.invoke('Symlink.createSymLink', target, path)
+}

package/src/parts/TemporaryMessagePort/TemporaryMessagePort.ipc.js

@@ -1,8 +1,10 @@
-import * as TemporaryMessagePort from './TemporaryMessagePort.js';
-export const name = 'TemporaryMessagePort';
+import * as TemporaryMessagePort from './TemporaryMessagePort.js'
+
+export const name = 'TemporaryMessagePort'
+
 export const Commands = {
-    getPortTuple3: TemporaryMessagePort.getPortTuple3,
-    handlePorts: TemporaryMessagePort.handlePorts,
-    sendTo2: TemporaryMessagePort.sendTo2,
-    sendToElectron: TemporaryMessagePort.sendToElectron,
-};
+  getPortTuple3: TemporaryMessagePort.getPortTuple3,
+  handlePorts: TemporaryMessagePort.handlePorts,
+  sendTo2: TemporaryMessagePort.sendTo2,
+  sendToElectron: TemporaryMessagePort.sendToElectron,
+}

package/src/parts/TemporaryMessagePort/TemporaryMessagePort.js

@@ -1,71 +1,76 @@
-import { VError } from '@lvce-editor/verror';
-import * as Assert from '../Assert/Assert.js';
-import * as Id from '../Id/Id.js';
-import * as IpcId from '../IpcId/IpcId.js';
-import * as JsonRpc from '../JsonRpc/JsonRpc.js';
-import * as ParentIpc from '../MainProcess/MainProcess.js';
-import { get } from '@lvce-editor/rpc-registry';
-export const state = {
-    ports: Object.create(null),
-};
+import { VError } from '@lvce-editor/verror'
+import * as Assert from '../Assert/Assert.js'
+import * as Id from '../Id/Id.js'
+import * as IpcId from '../IpcId/IpcId.js'
+import * as JsonRpc from '../JsonRpc/JsonRpc.js'
+import * as ParentIpc from '../MainProcess/MainProcess.js'
+import { get } from '@lvce-editor/rpc-registry'
+
+export const state      = {
+  ports: Object.create(null),
+}
+
 export const getPortTuple3 = async (id1, id2, rpcId) => {
-    await ParentIpc.invoke('TemporaryMessagePort.createPortTuple', id1, id2);
-    const port1 = state.ports[id1];
-    const port2 = state.ports[id2];
-    delete state.ports[id1];
-    delete state.ports[id2];
-    if (rpcId === IpcId.SharedProcess) {
-        return {
-            port1,
-            port2,
-        };
-    }
-    const ipc = get(rpcId);
-    if (!ipc) {
-        throw new Error('ipc not found' + rpcId);
-    }
-    await JsonRpc.invokeAndTransfer(ipc, 'TemporaryMessagePort.handlePorts', port1, port2, id1, id2);
+  await ParentIpc.invoke('TemporaryMessagePort.createPortTuple', id1, id2)
+  const port1 = state.ports[id1]
+  const port2 = state.ports[id2]
+  delete state.ports[id1]
+  delete state.ports[id2]
+  if (rpcId === IpcId.SharedProcess) {
     return {
-        port1: undefined,
-        port2: undefined,
-    };
-};
+      port1,
+      port2,
+    }
+  }
+  const ipc = get(rpcId)
+  if (!ipc) {
+    throw new Error('ipc not found' + rpcId)
+  }
+  await JsonRpc.invokeAndTransfer(ipc, 'TemporaryMessagePort.handlePorts', port1, port2, id1, id2)
+  return {
+    port1: undefined,
+    port2: undefined,
+  }
+}
+
 export const getPortTuple = async () => {
-    const id1 = Id.create();
-    const id2 = Id.create();
-    return getPortTuple3(id1, id2, IpcId.SharedProcess);
-};
+  const id1 = Id.create()
+  const id2 = Id.create()
+  return getPortTuple3(id1, id2, IpcId.SharedProcess)
+}
+
 export const sendTo = async (name, port, ipcId) => {
-    Assert.string(name);
-    Assert.object(port);
-    await ParentIpc.invokeAndTransfer('TemporaryMessagePort.sendTo', port, name, ipcId);
-};
+  Assert.string(name)
+  Assert.object(port)
+  await ParentIpc.invokeAndTransfer('TemporaryMessagePort.sendTo', port, name, ipcId)
+}
+
 export const sendTo2 = async (port, targetRpcId, sourceIpcId) => {
-    try {
-        Assert.object(port);
-        Assert.number(targetRpcId);
-        await ParentIpc.invokeAndTransfer('TemporaryMessagePort.sendTo2', port, targetRpcId, sourceIpcId);
-    }
-    catch (error) {
-        throw new VError(error, `Failed to send message port to electron utility process`);
-    }
-};
+  try {
+    Assert.object(port)
+    Assert.number(targetRpcId)
+    await ParentIpc.invokeAndTransfer('TemporaryMessagePort.sendTo2', port, targetRpcId, sourceIpcId)
+  } catch (error) {
+    throw new VError(error, `Failed to send message port to electron utility process`)
+  }
+}
+
 export const handlePorts = (port1, port2, id1, id2) => {
-    Assert.number(id1);
-    Assert.number(id2);
-    Assert.object(port1);
-    Assert.object(port2);
-    state.ports[id1] = port1;
-    state.ports[id2] = port2;
-};
+  Assert.number(id1)
+  Assert.number(id2)
+  Assert.object(port1)
+  Assert.object(port2)
+  state.ports[id1] = port1
+  state.ports[id2] = port2
+}
+
 export const sendToElectron = async (port, targetRpcId, sourceIpcId) => {
-    try {
-        Assert.object(port);
-        Assert.number(targetRpcId);
-        Assert.number(sourceIpcId);
-        ParentIpc.invokeAndTransfer('HandleElectronMessagePort.handleElectronMessagePort', port, sourceIpcId);
-    }
-    catch (error) {
-        throw new VError(error, `Failed to send message port to main process`);
-    }
-};
+  try {
+    Assert.object(port)
+    Assert.number(targetRpcId)
+    Assert.number(sourceIpcId)
+    ParentIpc.invokeAndTransfer('HandleElectronMessagePort.handleElectronMessagePort', port, sourceIpcId)
+  } catch (error) {
+    throw new VError(error, `Failed to send message port to main process`)
+  }
+}

package/src/parts/Terminal/Terminal.ipc.js

@@ -1,8 +1,10 @@
-import * as Terminal from './Terminal.js';
-export const name = 'Terminal';
+import * as Terminal from './Terminal.js'
+
+export const name = 'Terminal'
+
 export const Commands = {
-    create: Terminal.create,
-    dispose: Terminal.dispose,
-    resize: Terminal.resize,
-    write: Terminal.write,
-};
+  create: Terminal.create,
+  dispose: Terminal.dispose,
+  resize: Terminal.resize,
+  write: Terminal.write,
+}

package/src/parts/Terminal/Terminal.js

@@ -1,74 +1,79 @@
-import * as Assert from '../Assert/Assert.js';
-import { JsonRpcEvent } from '../JsonRpc/JsonRpc.js';
-import * as PtyHost from '../PtyHost/PtyHost.js';
-import * as TerminalState from '../TerminalState/TerminalState.js';
-import { VError } from '../VError/VError.js';
+import * as Assert from '../Assert/Assert.js'
+import { JsonRpcEvent } from '../JsonRpc/JsonRpc.js'
+import * as PtyHost from '../PtyHost/PtyHost.js'
+import * as TerminalState from '../TerminalState/TerminalState.js'
+import { VError } from '../VError/VError.js'
+
 const createTerminal = (ptyHost, socket) => {
-    const handleMessage = (message) => {
-        socket.send(message);
-    };
-    const handleClose = () => {
-        // socket.off('close', handleClose)
-        ptyHost.off('message', handleMessage);
-        ptyHost.dispose();
-    };
-    const dispose = () => {
-        ptyHost.off('message', handleMessage);
-        socket.off('close', handleClose);
-    };
-    ptyHost.on('message', handleMessage);
-    socket.on('close', handleClose);
-    return {
-        ptyHost,
-        socket,
-        handleMessage,
-        handleClose,
-        dispose,
-    };
-};
+  const handleMessage = (message) => {
+    socket.send(message)
+  }
+  const handleClose = () => {
+    // socket.off('close', handleClose)
+    ptyHost.off('message', handleMessage)
+    ptyHost.dispose()
+  }
+  const dispose = () => {
+    ptyHost.off('message', handleMessage)
+    socket.off('close', handleClose)
+  }
+  ptyHost.on('message', handleMessage)
+  socket.on('close', handleClose)
+  return {
+    ptyHost,
+    socket,
+    handleMessage,
+    handleClose,
+    dispose,
+  }
+}
+
 export const create = async (ipc, id, cwd, command, args) => {
-    try {
-        Assert.object(ipc);
-        Assert.number(id);
-        Assert.string(cwd);
-        // TODO race condition because of await
-        const ptyHost = await PtyHost.getOrCreate();
-        const terminal = createTerminal(ptyHost, ipc);
-        TerminalState.add(id, terminal);
-        // TODO improve ipc error handling and await promise
-        // current can't await promise because when process exits
-        // because of native module error, promise is not resolved
-        // causing application which waits on this promise to hang
-        PtyHost.invoke('Terminal.create', id, cwd, command, args);
-    }
-    catch (error) {
-        throw new VError(error, `Failed to create terminal`);
-    }
-};
+  try {
+    Assert.object(ipc)
+    Assert.number(id)
+    Assert.string(cwd)
+    // TODO race condition because of await
+    const ptyHost = await PtyHost.getOrCreate()
+    const terminal = createTerminal(ptyHost, ipc)
+    TerminalState.add(id, terminal)
+    // TODO improve ipc error handling and await promise
+    // current can't await promise because when process exits
+    // because of native module error, promise is not resolved
+    // causing application which waits on this promise to hang
+    PtyHost.invoke('Terminal.create', id, cwd, command, args)
+  } catch (error) {
+    throw new VError(error, `Failed to create terminal`)
+  }
+}
+
 export const write = (id, data) => {
-    Assert.number(id);
-    Assert.string(data);
-    const ptyHost = PtyHost.getCurrentInstance();
-    if (!ptyHost) {
-        console.log('[shared-process] pty host not ready');
-        return;
-    }
-    // TODO should use invoke
-    const message = JsonRpcEvent.create('Terminal.write', [id, data]);
-    ptyHost.send(message);
-};
+  Assert.number(id)
+  Assert.string(data)
+  const ptyHost = PtyHost.getCurrentInstance()
+  if (!ptyHost) {
+    console.log('[shared-process] pty host not ready')
+    return
+  }
+  // TODO should use invoke
+  const message = JsonRpcEvent.create('Terminal.write', [id, data])
+  ptyHost.send(message)
+}
+
 export const resize = (state, columns, rows) => {
-    // state.pty.resize(columns, rows)
-};
+  // state.pty.resize(columns, rows)
+}
+
 export const dispose = async (id) => {
-    const terminal = TerminalState.get(id);
-    terminal.dispose();
-    TerminalState.remove(id);
-    const ptyHost = await PtyHost.getOrCreate();
-    const message = JsonRpcEvent.create('Terminal.dispose', [id]);
-    // TODO use invoke
-    ptyHost.send(message);
-};
+  const terminal = TerminalState.get(id)
+  terminal.dispose()
+  TerminalState.remove(id)
+  const ptyHost = await PtyHost.getOrCreate()
+  const message = JsonRpcEvent.create('Terminal.dispose', [id])
+  // TODO use invoke
+  ptyHost.send(message)
+}
+
 export const disposeAll = () => {
-    PtyHost.disposeAll();
-};
+  PtyHost.disposeAll()
+}

package/src/parts/TerminalState/TerminalState.js

@@ -1,12 +1,15 @@
-export const state = {
-    terminals: Object.create(null),
-};
+export const state      = {
+  terminals: Object.create(null),
+}
+
 export const add = (id, terminal) => {
-    state.terminals[id] = terminal;
-};
+  state.terminals[id] = terminal
+}
+
 export const get = (id) => {
-    return state.terminals[id];
-};
+  return state.terminals[id]
+}
+
 export const remove = (id) => {
-    delete state.terminals[id];
-};
+  delete state.terminals[id]
+}

package/src/parts/TextDocument/TextDocument.ipc.js

@@ -1,4 +1,5 @@
-import * as TextDocument from './TextDocument.js';
+import * as TextDocument from './TextDocument.js'
+
 export const Commands = {
-    4820: TextDocument.applyEdit,
-};
+  4820: TextDocument.applyEdit,
+}

package/src/parts/TextDocument/TextDocument.js

@@ -1,9 +1,11 @@
-import * as JoinLines from '../JoinLines/JoinLines.js';
-export const state = {
-    textDocuments: Object.create(null),
-    /** @type{any[]} */
-    listeners: [],
-};
+import * as JoinLines from '../JoinLines/JoinLines.js'
+
+export const state      = {
+  textDocuments: Object.create(null),
+  /** @type{any[]} */
+  listeners: [],
+}
+
 // const toOffsetBasedEdit = (textDocument, documentEdit) => {
 //   let offset = 0
 //   let rowIndex = 0
@@ -17,18 +19,21 @@ export const state = {
 //     deleted: documentEdit.deleted,
 //   }
 // }
+
 export const applyEdit = (socket, textDocument, documentEdits) => {
-    // TODO avoid extra object allocation and anonymous function
-    // const offsetBasedEdits = documentEdits.map((e) =>
-    //   toOffsetBasedEdit(textDocument, e)
-    // )
-    for (const listener of state.listeners) {
-        listener(textDocument, documentEdits);
-    }
-};
+  // TODO avoid extra object allocation and anonymous function
+  // const offsetBasedEdits = documentEdits.map((e) =>
+  //   toOffsetBasedEdit(textDocument, e)
+  // )
+  for (const listener of state.listeners) {
+    listener(textDocument, documentEdits)
+  }
+}
+
 export const getText = (textDocument) => {
-    return JoinLines.joinLines(textDocument.lines);
-};
+  return JoinLines.joinLines(textDocument.lines)
+}
+
 export const onChange = (listener) => {
-    state.listeners.push(listener);
-};
+  state.listeners.push(listener)
+}

package/src/parts/Timeout/Timeout.js

@@ -1,6 +1,7 @@
 export const setTimeout = (listener, ms) => {
-    return globalThis.setTimeout(listener, ms);
-};
+  return globalThis.setTimeout(listener, ms)
+}
+
 export const clearTimeout = (timeoutId) => {
-    globalThis.clearTimeout(timeoutId);
-};
+  globalThis.clearTimeout(timeoutId)
+}

package/src/parts/TmpFile/TmpFile.js

@@ -1,13 +1,15 @@
-import { file, dir } from 'tmp-promise';
+import { file, dir } from 'tmp-promise'
+
 export const getTmpFile = async () => {
-    const { path } = await file({
-        prefix: 'lvce-extension-',
-    });
-    return path;
-};
+  const { path } = await file({
+    prefix: 'lvce-extension-',
+  })
+  return path
+}
+
 export const getTmpDir = async () => {
-    const { path } = await dir({
-        prefix: 'lvce-extension-',
-    });
-    return path;
-};
+  const { path } = await dir({
+    prefix: 'lvce-extension-',
+  })
+  return path
+}

package/src/parts/ToAbsolutePaths/ToAbsolutePaths.js

@@ -1,8 +1,9 @@
-import * as Path from '../Path/Path.js';
+import * as Path from '../Path/Path.js'
+
 export const toAbsolutePaths = (path, dirents) => {
-    const absolutePaths = [];
-    for (const dirent of dirents) {
-        absolutePaths.push(Path.join(path, dirent));
-    }
-    return absolutePaths;
-};
+  const absolutePaths        = []
+  for (const dirent of dirents) {
+    absolutePaths.push(Path.join(path, dirent))
+  }
+  return absolutePaths
+}