@lvce-editor/shared-process 0.25.9 → 0.25.11

package/src/parts/HeapSnapshot/HeapSnapshot.js

@@ -1,11 +1,8 @@
-import { createWriteStream } from 'node:fs'
-import { getHeapSnapshot } from 'node:v8'
-import { pipeline } from 'node:stream/promises'
-
+import { createWriteStream } from 'node:fs';
+import { getHeapSnapshot } from 'node:v8';
+import { pipeline } from 'node:stream/promises';
 export const createHeapSnapshot = async () => {
-  await pipeline(
-    getHeapSnapshot(),
+    await pipeline(getHeapSnapshot(), 
     // TODO get tmp dir from env
-    createWriteStream(`/tmp/vscode-${Date.now()}.heapsnapshot`),
-  )
-}
+    createWriteStream(`/tmp/vscode-${Date.now()}.heapsnapshot`));
+};

package/src/parts/HttpHeader/HttpHeader.js

@@ -1,7 +1,7 @@
-export const CacheControl = 'Cache-Control'
-export const ContentType = 'Content-Type'
-export const ContentSecurityPolicy = 'Content-Security-Policy'
-export const CrossOriginEmbedderPolicy = 'Cross-Origin-Embedder-Policy'
-export const CrossOriginOpenerPolicy = 'Cross-Origin-Opener-Policy'
-export const Etag = 'Etag'
-export const IfNotMatch = 'if-none-match'
+export const CacheControl = 'Cache-Control';
+export const ContentType = 'Content-Type';
+export const ContentSecurityPolicy = 'Content-Security-Policy';
+export const CrossOriginEmbedderPolicy = 'Cross-Origin-Embedder-Policy';
+export const CrossOriginOpenerPolicy = 'Cross-Origin-Opener-Policy';
+export const Etag = 'Etag';
+export const IfNotMatch = 'if-none-match';

package/src/parts/HttpServerResponse/HttpServerResponse.js

@@ -1,17 +1,16 @@
-import { ServerResponse } from 'node:http'
-import * as Assert from '../Assert/Assert.js'
-import * as SetHeaders from '../SetHeaders/SetHeaders.js'
-
+import { ServerResponse } from 'node:http';
+import * as Assert from '../Assert/Assert.js';
+import * as SetHeaders from '../SetHeaders/SetHeaders.js';
 export const send = (request, socket, result) => {
-  Assert.object(request)
-  Assert.object(socket)
-  Assert.object(result)
-  const response = new ServerResponse(request)
-  response.assignSocket(socket)
-  response.statusCode = result.init.status
-  SetHeaders.setHeaders(response, {
-    ...result.init.headers,
-    Connection: 'close',
-  })
-  response.end(result.body)
-}
+    Assert.object(request);
+    Assert.object(socket);
+    Assert.object(result);
+    const response = new ServerResponse(request);
+    response.assignSocket(socket);
+    response.statusCode = result.init.status;
+    SetHeaders.setHeaders(response, {
+        ...result.init.headers,
+        Connection: 'close',
+    });
+    response.end(result.body);
+};

package/src/parts/HttpStatusCode/HttpStatusCode.js

@@ -1,5 +1,5 @@
-export const NotFound = 404
-export const Ok = 200
-export const ServerError = 500
-export const NotModifed = 304
-export const MultipleChoices = 300
+export const NotFound = 404;
+export const Ok = 200;
+export const ServerError = 500;
+export const NotModifed = 304;
+export const MultipleChoices = 300;

package/src/parts/Id/Id.js

@@ -1,7 +1,6 @@
 export const state = {
-  id: 0,
-}
-
+    id: 0,
+};
 export const create = () => {
-  return ++state.id
-}
+    return ++state.id;
+};

package/src/parts/IncrementalTextSearch/IncrementalTextSearch.js

@@ -1,49 +1,46 @@
-import * as RipGrep from '../RipGrep/RipGrep.js'
-
+import * as RipGrep from '../RipGrep/RipGrep.js';
 const connectProcess = (ipc, id, childProcess) => {
-  let count = 0
-  const cleanup = () => {
-    childProcess.kill()
-  }
-  childProcess.stdout.on('data', (data) => {
-    count++
-    if (count > 20) {
-      cleanup()
-      return
-    }
-    // console.log({ data: data.toString() })
-    ipc.send({
-      jsonrpc: '2.0',
-      method: 'IncrementalTextSearch.handleData',
-      params: [id, data.toString()],
-    })
-    // emitter.dispatchEvent(new Event('data', x))
-  })
-
-  childProcess.on('exit', () => {
-    ipc.send({
-      jsonrpc: '2.0',
-      method: 'IncrementalTextSearch.handleExit',
-      params: [id],
-    })
-    // emitter.dispatchEvent(new Event('exit'))
-  })
-  childProcess.on('error', () => {
-    ipc.send({
-      jsonrpc: '2.0',
-      method: 'IncrementalTextSearch.handleError',
-      params: [id],
-    })
-    // emitter.dispatchEvent(new Event('error'))
-  })
-}
-
+    let count = 0;
+    const cleanup = () => {
+        childProcess.kill();
+    };
+    childProcess.stdout.on('data', (data) => {
+        count++;
+        if (count > 20) {
+            cleanup();
+            return;
+        }
+        // console.log({ data: data.toString() })
+        ipc.send({
+            jsonrpc: '2.0',
+            method: 'IncrementalTextSearch.handleData',
+            params: [id, data.toString()],
+        });
+        // emitter.dispatchEvent(new Event('data', x))
+    });
+    childProcess.on('exit', () => {
+        ipc.send({
+            jsonrpc: '2.0',
+            method: 'IncrementalTextSearch.handleExit',
+            params: [id],
+        });
+        // emitter.dispatchEvent(new Event('exit'))
+    });
+    childProcess.on('error', () => {
+        ipc.send({
+            jsonrpc: '2.0',
+            method: 'IncrementalTextSearch.handleError',
+            params: [id],
+        });
+        // emitter.dispatchEvent(new Event('error'))
+    });
+};
 export const start = async (ipc, id, { searchDir = '', maxSearchResults = 20_000, ripGrepArgs = [] } = {}) => {
-  console.log({ ipc })
-  const emitter = new EventTarget()
-  const childProcess = RipGrep.spawn(ripGrepArgs, {
-    cwd: searchDir,
-  })
-  console.log('start', { searchDir, ripGrepArgs, id })
-  connectProcess(ipc, id, childProcess)
-}
+    console.log({ ipc });
+    const emitter = new EventTarget();
+    const childProcess = RipGrep.spawn(ripGrepArgs, {
+        cwd: searchDir,
+    });
+    console.log('start', { searchDir, ripGrepArgs, id });
+    connectProcess(ipc, id, childProcess);
+};

package/src/parts/IncrementalTextSearch/IncremetalTextSearch.ipc.js

@@ -1,7 +1,5 @@
-import * as IncrementalTextSearch from './IncrementalTextSearch.js'
-
-export const name = 'IncrementalTextSearch'
-
+import * as IncrementalTextSearch from './IncrementalTextSearch.js';
+export const name = 'IncrementalTextSearch';
 export const Commands = {
-  start: IncrementalTextSearch.start,
-}
+    start: IncrementalTextSearch.start,
+};

package/src/parts/InferExtensionId/InferExtensionId.js

@@ -1,9 +1,8 @@
-const RE_EXTENSION_FRAGMENT = /.+(\/|\\)(.+)$/
-
+const RE_EXTENSION_FRAGMENT = /.+(\/|\\)(.+)$/;
 export const inferExtensionId = (absolutePath) => {
-  const match = absolutePath.match(RE_EXTENSION_FRAGMENT)
-  if (match) {
-    return match[2]
-  }
-  return ''
-}
+    const match = absolutePath.match(RE_EXTENSION_FRAGMENT);
+    if (match) {
+        return match[2];
+    }
+    return '';
+};

package/src/parts/InstallExtension/InstallExtension.ipc.js

@@ -1,6 +1,5 @@
-import * as InstallExtension from './InstallExtension.js'
-
+import * as InstallExtension from './InstallExtension.js';
 // prettier-ignore
 export const Commands = {
-  'InstallExtension.installExtension': InstallExtension.installExtension,
-}
+    'InstallExtension.installExtension': InstallExtension.installExtension,
+};

package/src/parts/InstallExtension/InstallExtension.js

@@ -1,33 +1,33 @@
-import * as Debug from '../Debug/Debug.js'
-import * as Download from '../Download/Download.js'
-import * as Extract from '../Extract/Extract.js'
-import * as Path from '../Path/Path.js'
-import * as PlatformPaths from '../PlatformPaths/PlatformPaths.js'
-import * as Queue from '../Queue/Queue.js'
-import { VError } from '../VError/VError.js'
-
+import * as Debug from '../Debug/Debug.js';
+import * as Download from '../Download/Download.js';
+import * as Extract from '../Extract/Extract.js';
+import * as Path from '../Path/Path.js';
+import * as PlatformPaths from '../PlatformPaths/PlatformPaths.js';
+import * as Queue from '../Queue/Queue.js';
+import { VError } from '../VError/VError.js';
 export const installExtension = async (id) => {
-  // TODO this should be a stateless function, renderer-worker should have info on marketplace url
-  // TODO use command.execute
-  try {
-    const marketplaceUrl = PlatformPaths.getMarketplaceUrl()
-    Debug.debug(`ExtensionManagement#install ${id}`)
-    const cachedExtensionsPath = PlatformPaths.getCachedExtensionsPath()
-    const extensionsPath = PlatformPaths.getExtensionsPath()
-    // TODO maybe a queue is over engineering here
-    await Queue.add('download', async () => {
-      Debug.debug(`ExtensionManagement#download ${id}`)
-      // TODO use command.execute
-      await Download.download(`${marketplaceUrl}/download/${id}`, Path.join(cachedExtensionsPath, `${id}.tar.br`))
-      Debug.debug(`ExtensionManagement#extract ${id}`)
-      await Extract.extractTarBr(Path.join(cachedExtensionsPath, `${id}.tar.br`), Path.join(extensionsPath, id))
-    })
-    // TODO should this be here? (probably not)
-    // await ExtensionHost.enableExtension({
-    //   id,
-    //   type: 'marketplace',
-    // })
-  } catch (error) {
-    throw new VError(error, `Failed to install extension "${id}"`)
-  }
-}
+    // TODO this should be a stateless function, renderer-worker should have info on marketplace url
+    // TODO use command.execute
+    try {
+        const marketplaceUrl = PlatformPaths.getMarketplaceUrl();
+        Debug.debug(`ExtensionManagement#install ${id}`);
+        const cachedExtensionsPath = PlatformPaths.getCachedExtensionsPath();
+        const extensionsPath = PlatformPaths.getExtensionsPath();
+        // TODO maybe a queue is over engineering here
+        await Queue.add('download', async () => {
+            Debug.debug(`ExtensionManagement#download ${id}`);
+            // TODO use command.execute
+            await Download.download(`${marketplaceUrl}/download/${id}`, Path.join(cachedExtensionsPath, `${id}.tar.br`));
+            Debug.debug(`ExtensionManagement#extract ${id}`);
+            await Extract.extractTarBr(Path.join(cachedExtensionsPath, `${id}.tar.br`), Path.join(extensionsPath, id));
+        });
+        // TODO should this be here? (probably not)
+        // await ExtensionHost.enableExtension({
+        //   id,
+        //   type: 'marketplace',
+        // })
+    }
+    catch (error) {
+        throw new VError(error, `Failed to install extension "${id}"`);
+    }
+};

package/src/parts/IpcChild/IpcChild.js

@@ -1,15 +1,14 @@
-import * as IpcChildModule from '../IpcChildModule/IpcChildModule.js'
-
+import * as IpcChildModule from '../IpcChildModule/IpcChildModule.js';
 export const listen = async ({ method, ...params }) => {
-  const module = await IpcChildModule.getModule(method)
-  // @ts-ignore
-  const rawIpc = await module.listen(params)
-  // @ts-ignore
-  if (module.signal) {
+    const module = await IpcChildModule.getModule(method);
     // @ts-ignore
-    module.signal(rawIpc)
-  }
-  // @ts-ignore
-  const ipc = module.wrap(rawIpc)
-  return ipc
-}
+    const rawIpc = await module.listen(params);
+    // @ts-ignore
+    if (module.signal) {
+        // @ts-ignore
+        module.signal(rawIpc);
+    }
+    // @ts-ignore
+    const ipc = module.wrap(rawIpc);
+    return ipc;
+};

package/src/parts/IpcChildModule/IpcChildModule.js

@@ -1,27 +1,20 @@
-import {
-  IpcChildWithElectronMessagePort,
-  IpcChildWithElectronUtilityProcess,
-  IpcChildWithNodeForkedProcess,
-  IpcChildWithNodeWorker,
-  IpcChildWithWebSocket,
-} from '@lvce-editor/ipc'
-import * as IpcChildType from '../IpcChildType/IpcChildType.js'
-
+import { IpcChildWithElectronMessagePort, IpcChildWithElectronUtilityProcess, IpcChildWithNodeForkedProcess, IpcChildWithNodeWorker, IpcChildWithWebSocket, } from '@lvce-editor/ipc';
+import * as IpcChildType from '../IpcChildType/IpcChildType.js';
 export const getModule = (method) => {
-  switch (method) {
-    case IpcChildType.NodeForkedProcess:
-      return IpcChildWithNodeForkedProcess
-    case IpcChildType.NodeWorker:
-      return IpcChildWithNodeWorker
-    case IpcChildType.ElectronUtilityProcess:
-      return IpcChildWithElectronUtilityProcess
-    case IpcChildType.ElectronMessagePort:
-      return IpcChildWithElectronMessagePort
-    case IpcChildType.NodeMessagePort:
-      return import('../IpcChildWithNodeMessagePort/IpcChildWithNodeMessagePort.js')
-    case IpcChildType.WebSocket:
-      return IpcChildWithWebSocket
-    default:
-      throw new Error('unexpected ipc type')
-  }
-}
+    switch (method) {
+        case IpcChildType.NodeForkedProcess:
+            return IpcChildWithNodeForkedProcess;
+        case IpcChildType.NodeWorker:
+            return IpcChildWithNodeWorker;
+        case IpcChildType.ElectronUtilityProcess:
+            return IpcChildWithElectronUtilityProcess;
+        case IpcChildType.ElectronMessagePort:
+            return IpcChildWithElectronMessagePort;
+        case IpcChildType.NodeMessagePort:
+            return import('../IpcChildWithNodeMessagePort/IpcChildWithNodeMessagePort.js');
+        case IpcChildType.WebSocket:
+            return IpcChildWithWebSocket;
+        default:
+            throw new Error('unexpected ipc type');
+    }
+};

package/src/parts/IpcChildType/IpcChildType.js

@@ -1,20 +1,19 @@
-export const NodeWorker = 1
-export const NodeForkedProcess = 2
-export const ElectronUtilityProcess = 3
-export const ElectronMessagePort = 4
-export const NodeMessagePort = 5
-export const WebSocket = 6
-
+export const NodeWorker = 1;
+export const NodeForkedProcess = 2;
+export const ElectronUtilityProcess = 3;
+export const ElectronMessagePort = 4;
+export const NodeMessagePort = 5;
+export const WebSocket = 6;
 export const Auto = () => {
-  const { argv } = process
-  if (argv.includes('--ipc-type=node-worker')) {
-    return NodeWorker
-  }
-  if (argv.includes('--ipc-type=node-forked-process')) {
-    return NodeForkedProcess
-  }
-  if (argv.includes('--ipc-type=electron-utility-process')) {
-    return ElectronUtilityProcess
-  }
-  throw new Error(`[shared-process] unknown ipc type`)
-}
+    const { argv } = process;
+    if (argv.includes('--ipc-type=node-worker')) {
+        return NodeWorker;
+    }
+    if (argv.includes('--ipc-type=node-forked-process')) {
+        return NodeForkedProcess;
+    }
+    if (argv.includes('--ipc-type=electron-utility-process')) {
+        return ElectronUtilityProcess;
+    }
+    throw new Error(`[shared-process] unknown ipc type`);
+};

package/src/parts/IpcChildWithElectronMessagePort/IpcChildWithElectronMessagePort.js

@@ -1,51 +1,50 @@
-import { IpcError } from '../IpcError/IpcError.js'
-import * as IsMessagePortMain from '../IsMessagePortMain/IsMessagePortMain.js'
-
+import { IpcError } from '../IpcError/IpcError.js';
+import * as IsMessagePortMain from '../IsMessagePortMain/IsMessagePortMain.js';
 export const listen = ({ messagePort }) => {
-  if (!IsMessagePortMain.isMessagePortMain(messagePort)) {
-    throw new IpcError('port must be of type MessagePortMain')
-  }
-  return messagePort
-}
-
+    if (!IsMessagePortMain.isMessagePortMain(messagePort)) {
+        throw new IpcError('port must be of type MessagePortMain');
+    }
+    return messagePort;
+};
 const getActualData = (event) => {
-  const { data, ports } = event
-  if (ports.length === 0) {
-    return data
-  }
-  return {
-    ...data,
-    params: [...ports, ...data.params],
-  }
-}
-
+    const { data, ports } = event;
+    if (ports.length === 0) {
+        return data;
+    }
+    return {
+        ...data,
+        params: [...ports, ...data.params],
+    };
+};
 export const wrap = (messagePort) => {
-  return {
-    messagePort,
-    on(event, listener) {
-      if (event === 'message') {
-        const wrappedListener = (event) => {
-          const actualData = getActualData(event)
-          listener(actualData)
-        }
-        this.messagePort.on(event, wrappedListener)
-      } else if (event === 'close') {
-        this.messagePort.on('close', listener)
-      } else {
-        throw new Error('unsupported event type')
-      }
-    },
-    off(event, listener) {
-      this.messagePort.off(event, listener)
-    },
-    send(message) {
-      this.messagePort.postMessage(message)
-    },
-    dispose() {
-      this.messagePort.close()
-    },
-    start() {
-      this.messagePort.start()
-    },
-  }
-}
+    return {
+        messagePort,
+        on(event, listener) {
+            if (event === 'message') {
+                const wrappedListener = (event) => {
+                    const actualData = getActualData(event);
+                    listener(actualData);
+                };
+                this.messagePort.on(event, wrappedListener);
+            }
+            else if (event === 'close') {
+                this.messagePort.on('close', listener);
+            }
+            else {
+                throw new Error('unsupported event type');
+            }
+        },
+        off(event, listener) {
+            this.messagePort.off(event, listener);
+        },
+        send(message) {
+            this.messagePort.postMessage(message);
+        },
+        dispose() {
+            this.messagePort.close();
+        },
+        start() {
+            this.messagePort.start();
+        },
+    };
+};

package/src/parts/IpcChildWithNodeMessagePort/IpcChildWithNodeMessagePort.js

@@ -1,44 +1,43 @@
-import { IpcError } from '../IpcError/IpcError.js'
-import * as IsMessagePort from '../IsMessagePort/IsMessagePort.js'
-
+import { IpcError } from '../IpcError/IpcError.js';
+import * as IsMessagePort from '../IsMessagePort/IsMessagePort.js';
 export const listen = ({ messagePort }) => {
-  if (!IsMessagePort.isMessagePort(messagePort)) {
-    throw new IpcError('port must be of type MessagePort')
-  }
-  return messagePort
-}
-
+    if (!IsMessagePort.isMessagePort(messagePort)) {
+        throw new IpcError('port must be of type MessagePort');
+    }
+    return messagePort;
+};
 const getActualData = (message) => {
-  return message
-}
-
+    return message;
+};
 export const wrap = (messagePort) => {
-  return {
-    messagePort,
-    on(event, listener) {
-      if (event === 'message') {
-        const wrappedListener = (event) => {
-          const actualData = getActualData(event)
-          listener(actualData)
-        }
-        this.messagePort.on(event, wrappedListener)
-      } else if (event === 'close') {
-        this.messagePort.on('close', listener)
-      } else {
-        throw new Error(`unsupported event type ${event}`)
-      }
-    },
-    off(event, listener) {
-      this.messagePort.off(event, listener)
-    },
-    send(message) {
-      this.messagePort.postMessage(message)
-    },
-    dispose() {
-      this.messagePort.close()
-    },
-    start() {
-      this.messagePort.start()
-    },
-  }
-}
+    return {
+        messagePort,
+        on(event, listener) {
+            if (event === 'message') {
+                const wrappedListener = (event) => {
+                    const actualData = getActualData(event);
+                    listener(actualData);
+                };
+                this.messagePort.on(event, wrappedListener);
+            }
+            else if (event === 'close') {
+                this.messagePort.on('close', listener);
+            }
+            else {
+                throw new Error(`unsupported event type ${event}`);
+            }
+        },
+        off(event, listener) {
+            this.messagePort.off(event, listener);
+        },
+        send(message) {
+            this.messagePort.postMessage(message);
+        },
+        dispose() {
+            this.messagePort.close();
+        },
+        start() {
+            this.messagePort.start();
+        },
+    };
+};

package/src/parts/IpcError/IpcError.js

@@ -1,6 +1,6 @@
 export class IpcError extends Error {
-  constructor(message) {
-    super(message)
-    this.name = 'IpcError'
-  }
+    constructor(message) {
+        super(message);
+        this.name = 'IpcError';
+    }
 }

package/src/parts/IpcParent/IpcParent.js

@@ -1,10 +1,9 @@
-import * as IpcParentModule from '../IpcParentModule/IpcParentModule.js'
-
+import * as IpcParentModule from '../IpcParentModule/IpcParentModule.js';
 export const create = async ({ method, ...options }) => {
-  const module = await IpcParentModule.getModule(method)
-  // @ts-ignore
-  const rawIpc = await module.create(options)
-  // @ts-ignore
-  const ipc = module.wrap(rawIpc)
-  return ipc
-}
+    const module = await IpcParentModule.getModule(method);
+    // @ts-ignore
+    const rawIpc = await module.create(options);
+    // @ts-ignore
+    const ipc = module.wrap(rawIpc);
+    return ipc;
+};