@lvce-editor/shared-process 0.25.10 → 0.25.11

package/src/parts/Preferences/Preferences.js

@@ -1,84 +1,83 @@
-import * as IsEnoentError from '../IsEnoentError/IsEnoentError.js'
-import * as JsoncFile from '../JsoncFile/JsoncFile.js'
-import * as PlatformPaths from '../PlatformPaths/PlatformPaths.js'
-import * as Process from '../Process/Process.js'
-import { VError } from '../VError/VError.js'
+import * as IsEnoentError from '../IsEnoentError/IsEnoentError.js';
+import * as JsoncFile from '../JsoncFile/JsoncFile.js';
+import * as PlatformPaths from '../PlatformPaths/PlatformPaths.js';
+import * as Process from '../Process/Process.js';
+import { VError } from '../VError/VError.js';
 // TODO need jsonc parser for settings with comments
-
 export const getUserPreferences = async () => {
-  try {
-    const userSettingsPath = PlatformPaths.getUserSettingsPath()
-    let json
     try {
-      json = await JsoncFile.readJsonc(userSettingsPath)
-    } catch (error) {
-      if (IsEnoentError.isEnoentError(error)) {
-        return {}
-      }
-      throw error
+        const userSettingsPath = PlatformPaths.getUserSettingsPath();
+        let json;
+        try {
+            json = await JsoncFile.readJsonc(userSettingsPath);
+        }
+        catch (error) {
+            if (IsEnoentError.isEnoentError(error)) {
+                return {};
+            }
+            throw error;
+        }
+        return json;
     }
-    return json
-  } catch (error) {
-    throw new VError(error, 'failed to get user preferences')
-  }
-}
-
+    catch (error) {
+        throw new VError(error, 'failed to get user preferences');
+    }
+};
 // TODO handle error
 export const getDefaultPreferences = async () => {
-  try {
-    const defaultSettingsPath = PlatformPaths.getDefaultSettingsPath()
-    return await JsoncFile.readJsonc(defaultSettingsPath)
-  } catch (error) {
-    throw new VError(error, 'Failed to load default preferences')
-  }
-}
-
+    try {
+        const defaultSettingsPath = PlatformPaths.getDefaultSettingsPath();
+        return await JsoncFile.readJsonc(defaultSettingsPath);
+    }
+    catch (error) {
+        throw new VError(error, 'Failed to load default preferences');
+    }
+};
 // TODO efficiently load preferences -> first load cached preferences
 //                                   -> on idle check preferences
-
 const getOverrides = () => {
-  const argvSliced = Process.argv.slice(2)
-  const overrides = {}
-  for (const argv of argvSliced) {
-    if (argv.startsWith('--theme=')) {
-      overrides['workbench.colorTheme'] = argv.slice('--theme='.length)
+    const argvSliced = Process.argv.slice(2);
+    const overrides = {};
+    for (const argv of argvSliced) {
+        if (argv.startsWith('--theme=')) {
+            overrides['workbench.colorTheme'] = argv.slice('--theme='.length);
+        }
     }
-  }
-  return overrides
-}
+    return overrides;
+};
 // TODO compare with timestamp/hash that preferences are fresh
 export const getAll = async () => {
-  try {
-    // try {
-    //   const cachedPreferences = JSON.parse(
-    //     await readFile(CACHED_SETTINGS_PATH, 'utf-8')
-    //   )
-    //   return cachedPreferences
-    // } catch {
-    //   // ignore
-    // }
-    const defaultPreferences = await getDefaultPreferences()
-    const userPreferences = await getUserPreferences()
-    const overrides = getOverrides()
-    // TODO separate backend and frontend preferences, ui only needs frontend preferences
-    const preferences = {
-      ...defaultPreferences,
-      ...userPreferences,
-      ...overrides,
+    try {
+        // try {
+        //   const cachedPreferences = JSON.parse(
+        //     await readFile(CACHED_SETTINGS_PATH, 'utf-8')
+        //   )
+        //   return cachedPreferences
+        // } catch {
+        //   // ignore
+        // }
+        const defaultPreferences = await getDefaultPreferences();
+        const userPreferences = await getUserPreferences();
+        const overrides = getOverrides();
+        // TODO separate backend and frontend preferences, ui only needs frontend preferences
+        const preferences = {
+            ...defaultPreferences,
+            ...userPreferences,
+            ...overrides,
+        };
+        // try {
+        //   await mkdir(dirname(CACHED_SETTINGS_PATH), { recursive: true })
+        //   await writeFile(
+        //     CACHED_SETTINGS_PATH,
+        //     JSON.stringify(preferences, null, 2) + '\n'
+        //   )
+        // } catch {
+        //   // ignore
+        // }
+        return preferences;
+    }
+    catch (error) {
+        throw new VError(error, 'Failed to get all preferences');
     }
-    // try {
-    //   await mkdir(dirname(CACHED_SETTINGS_PATH), { recursive: true })
-    //   await writeFile(
-    //     CACHED_SETTINGS_PATH,
-    //     JSON.stringify(preferences, null, 2) + '\n'
-    //   )
-    // } catch {
-    //   // ignore
-    // }
-    return preferences
-  } catch (error) {
-    throw new VError(error, 'Failed to get all preferences')
-  }
-}
-
+};
 // TODO when preferences cannot be loaded, ui should show useful error message

package/src/parts/PrettyError/PrettyError.js

@@ -1 +1 @@
-export { prepare, prepareJsonError } from '@lvce-editor/pretty-error'
+export { prepare, prepareJsonError } from '@lvce-editor/pretty-error';

package/src/parts/PrintPrettyError/PrintPrettyError.js

@@ -1,5 +1,4 @@
-import * as Logger from '../Logger/Logger.js'
-
+import * as Logger from '../Logger/Logger.js';
 export const printPrettyError = (prettyError, prefix = '') => {
-  Logger.error(`${prefix}${prettyError.type}: ${prettyError.message}\n\n${prettyError.codeFrame}\n\n${prettyError.stack}\n`)
-}
+    Logger.error(`${prefix}${prettyError.type}: ${prettyError.message}\n\n${prettyError.codeFrame}\n\n${prettyError.stack}\n`);
+};

package/src/parts/Process/Process.ipc.js

@@ -1,13 +1,11 @@
-import * as Process from './Process.js'
-
-export const name = 'Process'
-
+import * as Process from './Process.js';
+export const name = 'Process';
 export const Commands = {
-  crash: Process.crash,
-  crashAsync: Process.crashAsync,
-  getArch: Process.getArch,
-  getNodeVersion: Process.getNodeVersion,
-  getPid: Process.getPid,
-  getV8Version: Process.getV8Version,
-  kill: Process.kill,
-}
+    crash: Process.crash,
+    crashAsync: Process.crashAsync,
+    getArch: Process.getArch,
+    getNodeVersion: Process.getNodeVersion,
+    getPid: Process.getPid,
+    getV8Version: Process.getV8Version,
+    kill: Process.kill,
+};

package/src/parts/Process/Process.js

@@ -1,61 +1,48 @@
-import { VError } from '../VError/VError.js'
-import * as IsEsrchError from '../IsEsrchError/IsEsrchError.js'
-
+import { VError } from '../VError/VError.js';
+import * as IsEsrchError from '../IsEsrchError/IsEsrchError.js';
 export const crash = (message) => {
-  throw new Error(message)
-}
-
+    throw new Error(message);
+};
 export const crashAsync = async (message) => {
-  throw new Error(message)
-}
-
+    throw new Error(message);
+};
 export const exit = (code) => {
-  process.exit(code)
-}
-
+    process.exit(code);
+};
 export const setExitCode = (exitCode) => {
-  process.exitCode = exitCode
-}
-
-export const { argv } = process
-
+    process.exitCode = exitCode;
+};
+export const { argv } = process;
 export const cwd = () => {
-  return process.cwd()
-}
-
+    return process.cwd();
+};
 export const memoryUsage = () => {
-  return process.memoryUsage()
-}
-
+    return process.memoryUsage();
+};
 export const isConnected = () => {
-  return process.connected
-}
-
+    return process.connected;
+};
 export const kill = (pid, signal) => {
-  try {
-    process.kill(pid, signal)
-  } catch (error) {
-    if (IsEsrchError.isEsrchError(error)) {
-      return
+    try {
+        process.kill(pid, signal);
     }
-    throw new VError(error, `Failed to kill process ${pid} with signal ${signal}`)
-  }
-}
-
+    catch (error) {
+        if (IsEsrchError.isEsrchError(error)) {
+            return;
+        }
+        throw new VError(error, `Failed to kill process ${pid} with signal ${signal}`);
+    }
+};
 export const getPid = () => {
-  return process.pid
-}
-
-export const { platform } = process
-
+    return process.pid;
+};
+export const { platform } = process;
 export const getV8Version = () => {
-  return process.versions.v8
-}
-
+    return process.versions.v8;
+};
 export const getNodeVersion = () => {
-  return process.versions.node
-}
-
+    return process.versions.node;
+};
 export const getArch = () => {
-  return process.arch
-}
+    return process.arch;
+};

package/src/parts/ProcessDisplayName/ProcessDisplayName.js

@@ -1 +1 @@
-export const processDisplayName = 'shared process'
+export const processDisplayName = 'shared process';

package/src/parts/ProcessExitEventType/ProcessExitEventType.js

@@ -1,2 +1,2 @@
-export const Error = 1
-export const Exit = 2
+export const Error = 1;
+export const Exit = 2;

package/src/parts/ProcessId/ProcessId.ipc.js

@@ -1,8 +1,6 @@
-import * as ProcessId from './ProcessId.js'
-
-export const name = 'ProcessId'
-
+import * as ProcessId from './ProcessId.js';
+export const name = 'ProcessId';
 export const Commands = {
-  getMainProcessId: ProcessId.getMainProcessId,
-  getSharedProcessId: ProcessId.getSharedProcessId,
-}
+    getMainProcessId: ProcessId.getMainProcessId,
+    getSharedProcessId: ProcessId.getSharedProcessId,
+};

package/src/parts/ProcessId/ProcessId.js

@@ -1,7 +1,6 @@
 export const getSharedProcessId = () => {
-  return process.pid
-}
-
+    return process.pid;
+};
 export const getMainProcessId = () => {
-  return process.ppid
-}
+    return process.ppid;
+};

package/src/parts/ProcessListeners/ProcessListeners.js

@@ -1,17 +1,14 @@
-import * as ErrorHandling from '../ErrorHandling/ErrorHandling.js'
-import * as ExitCode from '../ExitCode/ExitCode.js'
-import * as Process from '../Process/Process.js'
-
+import * as ErrorHandling from '../ErrorHandling/ErrorHandling.js';
+import * as ExitCode from '../ExitCode/ExitCode.js';
+import * as Process from '../Process/Process.js';
 export const handleDisconnect = () => {
-  console.info('[shared process] disconnected')
-  Process.exit(ExitCode.Success)
-}
-
+    console.info('[shared process] disconnected');
+    Process.exit(ExitCode.Success);
+};
 export const handleSigTerm = () => {
-  console.info('[shared-process] sigterm')
-  Process.exit(ExitCode.Success)
-}
-
+    console.info('[shared-process] sigterm');
+    Process.exit(ExitCode.Success);
+};
 export const handleUncaughtExceptionMonitor = (error) => {
-  ErrorHandling.handleUncaughtExceptionMonitor(error)
-}
+    ErrorHandling.handleUncaughtExceptionMonitor(error);
+};

package/src/parts/Promises/Promises.js

@@ -1,19 +1,19 @@
 export const withResolvers = () => {
-  /**
-   * @type {any}
-   */
-  let _resolve
-  /**
-   * @type {any}
-   */
-  let _reject
-  const promise = new Promise((resolve, reject) => {
-    _resolve = resolve
-    _reject = reject
-  })
-  return {
-    resolve: _resolve,
-    reject: _reject,
-    promise,
-  }
-}
+    /**
+     * @type {any}
+     */
+    let _resolve;
+    /**
+     * @type {any}
+     */
+    let _reject;
+    const promise = new Promise((resolve, reject) => {
+        _resolve = resolve;
+        _reject = reject;
+    });
+    return {
+        resolve: _resolve,
+        reject: _reject,
+        promise,
+    };
+};

package/src/parts/ProtocolType/ProtocolType.js

@@ -1,4 +1,4 @@
-export const ExtensionHost = 'extension-host'
-export const ExtensionHostHelperProcess = 'extension-host-helper-process'
-export const SharedProcess = 'shared-process'
-export const TerminalProcess = 'terminal-process'
+export const ExtensionHost = 'extension-host';
+export const ExtensionHostHelperProcess = 'extension-host-helper-process';
+export const SharedProcess = 'shared-process';
+export const TerminalProcess = 'terminal-process';

package/src/parts/PtyHost/PtyHost.js

@@ -1,71 +1,64 @@
-import exitHook from 'exit-hook'
-import * as Debug from '../Debug/Debug.js'
-import * as HandleIpc from '../HandleIpc/HandleIpc.js'
-import * as IpcParent from '../IpcParent/IpcParent.js'
-import * as IpcParentType from '../IpcParentType/IpcParentType.js'
-import * as JsonRpc from '../JsonRpc/JsonRpc.js'
-import * as PtyHostPath from '../PtyHostPath/PtyHostPath.js'
-import * as PtyHostState from '../PtyHostState/PtyHostState.js'
-
+import exitHook from 'exit-hook';
+import * as Debug from '../Debug/Debug.js';
+import * as HandleIpc from '../HandleIpc/HandleIpc.js';
+import * as IpcParent from '../IpcParent/IpcParent.js';
+import * as IpcParentType from '../IpcParentType/IpcParentType.js';
+import * as JsonRpc from '../JsonRpc/JsonRpc.js';
+import * as PtyHostPath from '../PtyHostPath/PtyHostPath.js';
+import * as PtyHostState from '../PtyHostState/PtyHostState.js';
 const cleanUpAll = () => {
-  if (PtyHostState.state.ipc) {
-    PtyHostState.state.ipc.dispose()
-    PtyHostState.state.ipc = undefined
-  }
-}
-
+    if (PtyHostState.state.ipc) {
+        PtyHostState.state.ipc.dispose();
+        PtyHostState.state.ipc = undefined;
+    }
+};
 const handleProcessExit = () => {
-  Debug.debug('shared process exit, clean terminals')
-  cleanUpAll()
-}
-
+    Debug.debug('shared process exit, clean terminals');
+    cleanUpAll();
+};
 const createPtyHost = async (method) => {
-  exitHook(handleProcessExit)
-  const ptyHostPath = await PtyHostPath.getPtyHostPath()
-  const ptyHost = await IpcParent.create({
-    method,
-    path: ptyHostPath,
-    argv: [],
-    stdio: 'inherit',
-    name: 'Terminal Process',
-  })
-  HandleIpc.handleIpc(ptyHost)
-  const handleClose = () => {
-    ptyHost.off('close', handleClose)
-    PtyHostState.state.ipc = undefined
-    PtyHostState.state.ptyHostPromise = undefined
-  }
-  ptyHost.on('close', handleClose)
-  PtyHostState.state.ipc = ptyHost
-  return ptyHost
-}
-
+    exitHook(handleProcessExit);
+    const ptyHostPath = await PtyHostPath.getPtyHostPath();
+    const ptyHost = await IpcParent.create({
+        method,
+        path: ptyHostPath,
+        argv: [],
+        stdio: 'inherit',
+        name: 'Terminal Process',
+    });
+    HandleIpc.handleIpc(ptyHost);
+    const handleClose = () => {
+        ptyHost.off('close', handleClose);
+        PtyHostState.state.ipc = undefined;
+        PtyHostState.state.ptyHostPromise = undefined;
+    };
+    ptyHost.on('close', handleClose);
+    PtyHostState.state.ipc = ptyHost;
+    return ptyHost;
+};
 export const getOrCreate = (method = IpcParentType.NodeForkedProcess) => {
-  Debug.debug('creating pty host')
-  if (!PtyHostState.state.ptyHostPromise) {
-    PtyHostState.state.ptyHostPromise = createPtyHost(method)
-  }
-  return PtyHostState.state.ptyHostPromise
-}
-
+    Debug.debug('creating pty host');
+    if (!PtyHostState.state.ptyHostPromise) {
+        PtyHostState.state.ptyHostPromise = createPtyHost(method);
+    }
+    return PtyHostState.state.ptyHostPromise;
+};
 export const getCurrentInstance = () => {
-  return PtyHostState.state.ipc
-}
-
+    return PtyHostState.state.ipc;
+};
 export const disposeAll = () => {
-  if (PtyHostState.state.ipc) {
-    PtyHostState.state.ipc.removeAllListeners()
     if (PtyHostState.state.ipc) {
-      PtyHostState.state.ipc.dispose()
-      PtyHostState.state.ipc = undefined
-    }
-    PtyHostState.state.ptyHostState = /* None */ 0
-    PtyHostState.state.send = (message) => {
-      PtyHostState.state.pendingMessages.push(message)
+        PtyHostState.state.ipc.removeAllListeners();
+        if (PtyHostState.state.ipc) {
+            PtyHostState.state.ipc.dispose();
+            PtyHostState.state.ipc = undefined;
+        }
+        PtyHostState.state.ptyHostState = /* None */ 0;
+        PtyHostState.state.send = (message) => {
+            PtyHostState.state.pendingMessages.push(message);
+        };
     }
-  }
-}
-
+};
 export const invoke = (method, ...params) => {
-  return JsonRpc.invoke(PtyHostState.state.ipc, method, ...params)
-}
+    return JsonRpc.invoke(PtyHostState.state.ipc, method, ...params);
+};

package/src/parts/PtyHostPath/PtyHostPath.js

@@ -1,11 +1,11 @@
-import * as Root from '../Root/Root.js'
-import * as Path from '../Path/Path.js'
-
+import * as Root from '../Root/Root.js';
+import * as Path from '../Path/Path.js';
 export const getPtyHostPath = async () => {
-  try {
-    const { ptyHostPath } = await import('@lvce-editor/pty-host')
-    return ptyHostPath
-  } catch {
-    return Path.join(Root.root, 'packages', 'pty-host', 'src', 'ptyHostMain.js')
-  }
-}
+    try {
+        const { ptyHostPath } = await import('@lvce-editor/pty-host');
+        return ptyHostPath;
+    }
+    catch {
+        return Path.join(Root.root, 'packages', 'pty-host', 'src', 'ptyHostMain.js');
+    }
+};

package/src/parts/PtyHostState/PtyHostState.js

@@ -1,17 +1,17 @@
 export const state = {
-  /**
-   * @type {any}
-   */
-  ipc: undefined,
-  /**
-   * @type {any}
-   */
-  ptyHostPromise: undefined,
-  /**
-   * @type {any[]}
-   */
-  pendingMessages: [],
-  send(message) {
-    state.pendingMessages.push(message)
-  },
-}
+    /**
+     * @type {any}
+     */
+    ipc: undefined,
+    /**
+     * @type {any}
+     */
+    ptyHostPromise: undefined,
+    /**
+     * @type {any[]}
+     */
+    pendingMessages: [],
+    send(message) {
+        state.pendingMessages.push(message);
+    },
+};

package/src/parts/Queue/Queue.js

@@ -1,35 +1,34 @@
 export const state = {
-  queueMap: Object.create(null),
-}
-
+    queueMap: Object.create(null),
+};
 const run = async (queue) => {
-  if (queue.state === 'running') {
-    return
-  }
-  queue.state = 'running'
-  let item
-  while ((item = queue.items.shift())) {
-    try {
-      await item.fn()
-      item.resolve()
-    } catch (error) {
-      item.reject(error)
+    if (queue.state === 'running') {
+        return;
     }
-  }
-  queue.state = 'idle'
-}
-
+    queue.state = 'running';
+    let item;
+    while ((item = queue.items.shift())) {
+        try {
+            await item.fn();
+            item.resolve();
+        }
+        catch (error) {
+            item.reject(error);
+        }
+    }
+    queue.state = 'idle';
+};
 export const add = async (key, fn) => {
-  const queue = (state.queueMap[key] ||= {
-    state: 'idle',
-    items: [],
-  })
-  await new Promise((resolve, reject) => {
-    queue.items.push({
-      fn,
-      resolve,
-      reject,
-    })
-    run(queue)
-  })
-}
+    const queue = (state.queueMap[key] ||= {
+        state: 'idle',
+        items: [],
+    });
+    await new Promise((resolve, reject) => {
+        queue.items.push({
+            fn,
+            resolve,
+            reject,
+        });
+        run(queue);
+    });
+};