@lvce-editor/shared-process 0.85.3 → 0.86.0

package/src/parts/Id/Id.js

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

package/src/parts/IndexHtmlPath/IndexHtmlPath.js

@@ -1,3 +1,4 @@
-import * as Path from '../Path/Path.js';
-import * as Root from '../Root/Root.js';
-export const indexHtmlPath = Path.join(Root.root, 'static', 'index.html');
+import * as Path from '../Path/Path.js'
+import * as Root from '../Root/Root.js'
+
+export const indexHtmlPath = Path.join(Root.root, 'static', 'index.html')

package/src/parts/InferExtensionId/InferExtensionId.js

@@ -1,8 +1,9 @@
-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,5 +1,6 @@
-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,29 +1,29 @@
-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 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();
-        const cachedExtensionsPath = PlatformPaths.getCachedExtensionsPath();
-        const extensionsPath = PlatformPaths.getExtensionsPath();
-        // TODO maybe a queue is over engineering here
-        await Queue.add('download', async () => {
-            // TODO use command.execute
-            await Download.download(`${marketplaceUrl}/download/${id}`, Path.join(cachedExtensionsPath, `${id}.tar.br`));
-            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()
+    const cachedExtensionsPath = PlatformPaths.getCachedExtensionsPath()
+    const extensionsPath = PlatformPaths.getExtensionsPath()
+    // TODO maybe a queue is over engineering here
+    await Queue.add('download', async () => {
+      // TODO use command.execute
+      await Download.download(`${marketplaceUrl}/download/${id}`, Path.join(cachedExtensionsPath, `${id}.tar.br`))
+      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,14 +1,15 @@
-import * as IpcChildModule from '../IpcChildModule/IpcChildModule.js';
-export const listen = async ({ method, ...params }) => {
-    const module = await IpcChildModule.getModule(method);
+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) {
     // @ts-ignore
-    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;
-};
+    module.signal(rawIpc)
+  }
+  // @ts-ignore
+  const ipc = module.wrap(rawIpc)
+  return ipc
+}

package/src/parts/IpcChildModule/IpcChildModule.js

@@ -1,20 +1,27 @@
-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,19 +1,20 @@
-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/IpcChildWithNodeMessagePort/IpcChildWithNodeMessagePort.js

@@ -1,47 +1,48 @@
-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;
-};
+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
+}
+
 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);
-                    const syntheticEvent = {
-                        data: actualData,
-                        target: this,
-                    };
-                    listener(syntheticEvent);
-                };
-                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)
+          const syntheticEvent = {
+            data: actualData,
+            target: this,
+          }
+          listener(syntheticEvent)
+        }
+        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/IpcId/IpcId.js

@@ -1,17 +1,18 @@
-import { RpcId } from '@lvce-editor/rpc-registry';
-export const AuthProcess = RpcId.AuthWorker;
-export const EmbedsProcess = RpcId.EmbedsProcess;
-export const EmbedsWorker = RpcId.EmbedsWorker;
-export const ExtensionHostHelperProcess = 3;
-export const MainProcess = RpcId.MainProcess;
-export const ProcessExplorer = 11;
-export const SearchProcess = RpcId.SearchProcess;
-export const SharedProcess = RpcId.SharedProcess;
-export const TerminalProcess = 7;
-export const Unknown = 0;
-export const ProcessExplorerRenderer = 33;
-export const ExtensionHostWorker = RpcId.ExtensionHostWorker;
-export const FileSystemProcess = RpcId.FileSystemProcess;
-export const FileWatcherProcess = 220;
-export const TypescriptCompileProcess = 221;
-export const ClipBoardProcess = RpcId.ClipBoardProcess;
+import { RpcId } from '@lvce-editor/rpc-registry'
+
+export const AuthProcess = RpcId.AuthWorker
+export const EmbedsProcess = RpcId.EmbedsProcess
+export const EmbedsWorker = RpcId.EmbedsWorker
+export const ExtensionHostHelperProcess = 3
+export const MainProcess = RpcId.MainProcess
+export const ProcessExplorer = 11
+export const SearchProcess = RpcId.SearchProcess
+export const SharedProcess = RpcId.SharedProcess
+export const TerminalProcess = 7
+export const Unknown = 0
+export const ProcessExplorerRenderer = 33
+export const ExtensionHostWorker = RpcId.ExtensionHostWorker
+export const FileSystemProcess = RpcId.FileSystemProcess
+export const FileWatcherProcess = 220
+export const TypescriptCompileProcess = 221
+export const ClipBoardProcess = RpcId.ClipBoardProcess

package/src/parts/IpcParent/IpcParent.js

@@ -1,9 +1,10 @@
-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;
-};
+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
+}

package/src/parts/IpcParentModule/IpcParentModule.js

@@ -1,14 +1,15 @@
-import { IpcParentWithNodeForkedProcess, IpcParentWithNodeWorker } from '@lvce-editor/ipc';
-import * as IpcParentType from '../IpcParentType/IpcParentType.js';
+import { IpcParentWithNodeForkedProcess, IpcParentWithNodeWorker } from '@lvce-editor/ipc'
+import * as IpcParentType from '../IpcParentType/IpcParentType.js'
+
 export const getModule = (method) => {
-    switch (method) {
-        case IpcParentType.NodeWorker:
-            return IpcParentWithNodeWorker;
-        case IpcParentType.NodeForkedProcess:
-            return IpcParentWithNodeForkedProcess;
-        case IpcParentType.ElectronUtilityProcess:
-            return import('../IpcParentWithElectronUtilityProcess/IpcParentWithElectronUtilityProcess.js');
-        default:
-            throw new Error('unexpected ipc type');
-    }
-};
+  switch (method) {
+    case IpcParentType.NodeWorker:
+      return IpcParentWithNodeWorker
+    case IpcParentType.NodeForkedProcess:
+      return IpcParentWithNodeForkedProcess
+    case IpcParentType.ElectronUtilityProcess:
+      return import('../IpcParentWithElectronUtilityProcess/IpcParentWithElectronUtilityProcess.js')
+    default:
+      throw new Error('unexpected ipc type')
+  }
+}

package/src/parts/IpcParentType/IpcParentType.js

@@ -1,3 +1,3 @@
-export const NodeWorker = 1;
-export const NodeForkedProcess = 2;
-export const ElectronUtilityProcess = 3;
+export const NodeWorker = 1
+export const NodeForkedProcess = 2
+export const ElectronUtilityProcess = 3

package/src/parts/IpcParentWithElectronUtilityProcess/IpcParentWithElectronUtilityProcess.js

@@ -1,82 +1,87 @@
-import * as CreateUtilityProcessRpc from '../CreateUtilityProcessRpc/CreateUtilityProcessRpc.js';
-import * as FixElectronParameters from '../FixElectronParameters/FixElectronParameters.js';
-import * as GetPortTuple from '../GetPortTuple/GetPortTuple.js';
-import * as ParentIpc from '../MainProcess/MainProcess.js';
-import * as TemporaryMessagePort from '../TemporaryMessagePort/TemporaryMessagePort.js';
+import * as CreateUtilityProcessRpc from '../CreateUtilityProcessRpc/CreateUtilityProcessRpc.js'
+import * as FixElectronParameters from '../FixElectronParameters/FixElectronParameters.js'
+import * as GetPortTuple from '../GetPortTuple/GetPortTuple.js'
+import * as ParentIpc from '../MainProcess/MainProcess.js'
+import * as TemporaryMessagePort from '../TemporaryMessagePort/TemporaryMessagePort.js'
+
 export const create = async (options) => {
-    // TODO how to launch process without race condition?
-    // when promise resolves, process might have already exited
-    if (!options.rpcId && !options.targetRpcId) {
-        // TODO make targetRpcId required
-        options.targetRpcId = Math.random();
-    }
-    await CreateUtilityProcessRpc.createUtilityProcessRpc(options);
-    const { port1, port2 } = await GetPortTuple.getPortTuple();
-    // TODO use uuid instead of name
-    await TemporaryMessagePort.sendTo2(port2, options.targetRpcId, options.ipcId);
-    port1.start();
-    return port1;
-};
+  // TODO how to launch process without race condition?
+  // when promise resolves, process might have already exited
+  if (!options.rpcId && !options.targetRpcId) {
+    // TODO make targetRpcId required
+    options.targetRpcId = Math.random()
+  }
+  await CreateUtilityProcessRpc.createUtilityProcessRpc(options)
+
+  const { port1, port2 } = await GetPortTuple.getPortTuple()
+  // TODO use uuid instead of name
+  await TemporaryMessagePort.sendTo2(port2, options.targetRpcId, options.ipcId)
+  port1.start()
+  return port1
+}
+
 export const signal = (port) => {
-    port.start();
-};
+  port.start()
+}
+
 const getActualData = (event) => {
-    const { data, ports } = event;
-    if (ports.length > 0) {
-        return {
-            ...data,
-            params: [...ports, ...data.params],
-        };
+  const { data, ports } = event
+  if (ports.length > 0) {
+    return {
+      ...data,
+      params: [...ports, ...data.params],
     }
-    return data;
-};
+  }
+  return data
+}
+
 export const wrap = (port) => {
-    return {
-        port,
-        wrappedListener: undefined,
-        send(message) {
-            this.port.postMessage(message);
-        },
-        async sendAndTransfer(message) {
-            const { newValue, transfer } = FixElectronParameters.fixElectronParameters(message);
-            this.port.postMessage(newValue, transfer);
-        },
-        on(event, listener) {
-            switch (event) {
-                case 'close':
-                    this.port.on(event, listener);
-                    break;
-                case 'message':
-                    // @ts-ignore
-                    this.wrappedListener = (event) => {
-                        const syntheticEvent = {
-                            data: getActualData(event),
-                            target: this,
-                        };
-                        listener(syntheticEvent);
-                    };
-                    this.port.on(event, this.wrappedListener);
-                    break;
-                default:
-                    break;
-            }
-        },
-        off(event, listener) {
-            switch (event) {
-                case 'close':
-                    this.port.off(event, listener);
-                    break;
-                case 'message':
-                    this.port.off(event, this.wrappedListener);
-                    this.wrappedListener = undefined;
-                    break;
-                default:
-                    break;
+  return {
+    port,
+    wrappedListener: undefined,
+    send(message)      {
+      this.port.postMessage(message)
+    },
+    async sendAndTransfer(message)               {
+      const { newValue, transfer } = FixElectronParameters.fixElectronParameters(message)
+      this.port.postMessage(newValue, transfer)
+    },
+    on(event, listener)      {
+      switch (event) {
+        case 'close':
+          this.port.on(event, listener)
+          break
+        case 'message':
+          // @ts-ignore
+          this.wrappedListener = (event) => {
+            const syntheticEvent = {
+              data: getActualData(event),
+              target: this,
             }
-        },
-        dispose() {
-            this.port.close();
-            ParentIpc.invoke('TemporaryMessagePort.dispose', this.port.name);
-        },
-    };
-};
+            listener(syntheticEvent)
+          }
+          this.port.on(event, this.wrappedListener)
+          break
+        default:
+          break
+      }
+    },
+    off(event, listener)      {
+      switch (event) {
+        case 'close':
+          this.port.off(event, listener)
+          break
+        case 'message':
+          this.port.off(event, this.wrappedListener)
+          this.wrappedListener = undefined
+          break
+        default:
+          break
+      }
+    },
+    dispose()      {
+      this.port.close()
+      ParentIpc.invoke('TemporaryMessagePort.dispose', this.port.name)
+    },
+  }
+}

package/src/parts/IpcTransferState/IpcTransferState.js

@@ -1,14 +1,17 @@
-const pendingCount = Object.create(null);
+const pendingCount = Object.create(null)
+
 export const add = (ipcId) => {
-    pendingCount[ipcId] ||= 0;
-    pendingCount[ipcId]++;
-};
+  pendingCount[ipcId] ||= 0
+  pendingCount[ipcId]++
+}
+
 export const remove = (ipcId) => {
-    pendingCount[ipcId]--;
-    if (pendingCount[ipcId] === 0) {
-        delete pendingCount[ipcId];
-    }
-};
+  pendingCount[ipcId]--
+  if (pendingCount[ipcId] === 0) {
+    delete pendingCount[ipcId]
+  }
+}
+
 export const has = (ipcId) => {
-    return ipcId in pendingCount;
-};
+  return ipcId in pendingCount
+}

package/src/parts/IsAbsolutePath/IsAbsolutePath.js

@@ -1,4 +1,5 @@
-const RE_ABSOLUTE_URI = /^[a-z]+:\/\//;
+const RE_ABSOLUTE_URI = /^[a-z]+:\/\//
+
 export const isAbsolutePath = (path) => {
-    return RE_ABSOLUTE_URI.test(path);
-};
+  return RE_ABSOLUTE_URI.test(path)
+}