@lvce-editor/ipc 11.1.0 → 11.3.0

package/dist/browser.js

@@ -2,6 +2,30 @@ const getData$1 = event => {
   return event.data;
 };
 
+const attachEvents = that => {
+  const handleMessage = (...args) => {
+    const data = that.getData(...args);
+    that.dispatchEvent(new MessageEvent('message', {
+      data
+    }));
+  };
+  that.onMessage(handleMessage);
+  const handleClose = event => {
+    that.dispatchEvent(new Event('close'));
+  };
+  that.onClose(handleClose);
+};
+
+class Ipc extends EventTarget {
+  constructor(rawIpc) {
+    super();
+    this._rawIpc = rawIpc;
+    attachEvents(this);
+  }
+}
+
+const readyMessage = 'ready';
+
 const walkValue = (value, transferrables, isTransferrable) => {
   if (!value) {
     return;
@@ -61,38 +85,146 @@ const getTransferrables = value => {
   return transferrables;
 };
 
-const attachEvents = that => {
-  const handleMessage = (...args) => {
-    const data = that.getData(...args);
-    that.dispatchEvent(new MessageEvent('message', {
-      data
-    }));
-  };
-  that.onMessage(handleMessage);
-  const handleClose = event => {
-    that.dispatchEvent(new Event('close'));
+const removeValues = (value, toRemove) => {
+  if (!value) {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    const newItems = [];
+    for (const item of value) {
+      if (!toRemove.includes(item)) {
+        newItems.push(removeValues(item, toRemove));
+      }
+    }
+    return newItems;
+  }
+  if (typeof value === 'object') {
+    const newObject = Object.create(null);
+    for (const [key, property] of Object.entries(value)) {
+      if (!toRemove.includes(property)) {
+        newObject[key] = removeValues(property, toRemove);
+      }
+    }
+    return newObject;
+  }
+  return value;
+};
+
+// workaround for electron not supporting transferrable objects
+// as parameters. If the transferrable object is a parameter, in electron
+// only an empty objected is received in the main process
+const fixElectronParameters = value => {
+  const transfer = getTransferrables(value);
+  const newValue = removeValues(value, transfer);
+  return {
+    newValue,
+    transfer
   };
-  that.onClose(handleClose);
 };
 
-class Ipc extends EventTarget {
-  constructor(rawIpc) {
-    super();
-    this._rawIpc = rawIpc;
-    attachEvents(this);
+const listen$4 = () => {
+  return window;
+};
+const signal$4 = global => {
+  global.postMessage(readyMessage);
+};
+class IpcChildWithElectronWindow extends Ipc {
+  getData(event) {
+    return getData$1(event);
+  }
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    const {
+      newValue,
+      transfer
+    } = fixElectronParameters(message);
+    this._rawIpc.postMessage(newValue, location.origin, transfer);
+  }
+  dispose() {
+    // ignore
+  }
+  onClose(callback) {
+    // ignore
+  }
+  onMessage(callback) {
+    const wrapped = event => {
+      const {
+        ports
+      } = event;
+      if (ports.length) {
+        return;
+      }
+      callback(event);
+      this._rawIpc.removeEventListener('message', wrapped);
+    };
+    this._rawIpc.addEventListener('message', wrapped);
   }
 }
+const wrap$7 = window => {
+  return new IpcChildWithElectronWindow(window);
+};
 
-const readyMessage = 'ready';
+const IpcChildWithElectronWindow$1 = {
+  __proto__: null,
+  listen: listen$4,
+  signal: signal$4,
+  wrap: wrap$7
+};
 
-const listen$4 = () => {
+const listen$3 = ({
+  port
+}) => {
+  return port;
+};
+const signal$3 = port => {
+  port.postMessage(readyMessage);
+};
+class IpcChildWithMessagePort extends Ipc {
+  constructor(port) {
+    super(port);
+  }
+  getData(event) {
+    return getData$1(event);
+  }
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    const transfer = getTransferrables(message);
+    this._rawIpc.postMessage(message, transfer);
+  }
+  dispose() {
+    // ignore
+  }
+  onClose(callback) {
+    // ignore
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+    this._rawIpc.start();
+  }
+}
+const wrap$6 = port => {
+  return new IpcChildWithMessagePort(port);
+};
+
+const IpcChildWithMessagePort$1 = {
+  __proto__: null,
+  listen: listen$3,
+  signal: signal$3,
+  wrap: wrap$6
+};
+
+const listen$2 = () => {
   // @ts-ignore
   if (typeof WorkerGlobalScope === 'undefined') {
     throw new TypeError('module is not in web worker scope');
   }
   return globalThis;
 };
-const signal$3 = global => {
+const signal$2 = global => {
   global.postMessage(readyMessage);
 };
 class IpcChildWithModuleWorker extends Ipc {
@@ -118,15 +250,15 @@ class IpcChildWithModuleWorker extends Ipc {
     this._rawIpc.addEventListener('message', callback);
   }
 }
-const wrap$6 = global => {
+const wrap$5 = global => {
   return new IpcChildWithModuleWorker(global);
 };
 
 const IpcChildWithModuleWorker$1 = {
   __proto__: null,
-  listen: listen$4,
-  signal: signal$3,
-  wrap: wrap$6
+  listen: listen$2,
+  signal: signal$2,
+  wrap: wrap$5
 };
 
 const E_INCOMPATIBLE_NATIVE_MODULE = 'E_INCOMPATIBLE_NATIVE_MODULE';
@@ -250,10 +382,10 @@ const getHelpfulChildProcessError = (stdout, stderr) => {
 
 const normalizeLine = line => {
   if (line.startsWith('Error: ')) {
-    return line.slice(`Error: `.length);
+    return line.slice('Error: '.length);
   }
   if (line.startsWith('VError: ')) {
-    return line.slice(`VError: `.length);
+    return line.slice('VError: '.length);
   }
   return line;
 };
@@ -355,10 +487,10 @@ const waitForFirstMessage = async port => {
   return event.data;
 };
 
-const listen$3 = async () => {
-  const parentIpcRaw = listen$4();
-  signal$3(parentIpcRaw);
-  const parentIpc = wrap$6(parentIpcRaw);
+const listen$1 = async () => {
+  const parentIpcRaw = listen$2();
+  signal$2(parentIpcRaw);
+  const parentIpc = wrap$5(parentIpcRaw);
   const firstMessage = await waitForFirstMessage(parentIpc);
   if (firstMessage.method !== 'initialize') {
     throw new IpcError('unexpected first message');
@@ -403,20 +535,20 @@ class IpcChildWithModuleWorkerAndMessagePort extends Ipc {
     this._rawIpc.start();
   }
 }
-const wrap$5 = port => {
+const wrap$4 = port => {
   return new IpcChildWithModuleWorkerAndMessagePort(port);
 };
 
 const IpcChildWithModuleWorkerAndMessagePort$1 = {
   __proto__: null,
-  listen: listen$3,
-  wrap: wrap$5
+  listen: listen$1,
+  wrap: wrap$4
 };
 
-const listen$2 = () => {
+const listen = () => {
   return window;
 };
-const signal$2 = global => {
+const signal$1 = global => {
   global.postMessage(readyMessage);
 };
 class IpcChildWithWindow extends Ipc {
@@ -450,151 +582,18 @@ class IpcChildWithWindow extends Ipc {
     this._rawIpc.addEventListener('message', wrapped);
   }
 }
-const wrap$4 = window => {
+const wrap$3 = window => {
   return new IpcChildWithWindow(window);
 };
 
 const IpcChildWithWindow$1 = {
   __proto__: null,
-  listen: listen$2,
-  signal: signal$2,
-  wrap: wrap$4
-};
-
-const removeValues = (value, toRemove) => {
-  if (!value) {
-    return value;
-  }
-  if (Array.isArray(value)) {
-    const newItems = [];
-    for (const item of value) {
-      if (!toRemove.includes(item)) {
-        newItems.push(removeValues(item, toRemove));
-      }
-    }
-    return newItems;
-  }
-  if (typeof value === 'object') {
-    const newObject = Object.create(null);
-    for (const [key, property] of Object.entries(value)) {
-      if (!toRemove.includes(property)) {
-        newObject[key] = removeValues(property, toRemove);
-      }
-    }
-    return newObject;
-  }
-  return value;
-};
-
-// workaround for electron not supporting transferrable objects
-// as parameters. If the transferrable object is a parameter, in electron
-// only an empty objected is received in the main process
-const fixElectronParameters = value => {
-  const transfer = getTransferrables(value);
-  const newValue = removeValues(value, transfer);
-  return {
-    newValue,
-    transfer
-  };
-};
-
-const listen$1 = () => {
-  return window;
-};
-const signal$1 = global => {
-  global.postMessage(readyMessage);
-};
-class IpcChildWithElectronWindow extends Ipc {
-  getData(event) {
-    return getData$1(event);
-  }
-  send(message) {
-    this._rawIpc.postMessage(message);
-  }
-  sendAndTransfer(message) {
-    const {
-      newValue,
-      transfer
-    } = fixElectronParameters(message);
-    this._rawIpc.postMessage(newValue, location.origin, transfer);
-  }
-  dispose() {
-    // ignore
-  }
-  onClose(callback) {
-    // ignore
-  }
-  onMessage(callback) {
-    const wrapped = event => {
-      const {
-        ports
-      } = event;
-      if (ports.length) {
-        return;
-      }
-      callback(event);
-      this._rawIpc.removeEventListener('message', wrapped);
-    };
-    this._rawIpc.addEventListener('message', wrapped);
-  }
-}
-const wrap$3 = window => {
-  return new IpcChildWithElectronWindow(window);
-};
-
-const IpcChildWithElectronWindow$1 = {
-  __proto__: null,
-  listen: listen$1,
+  listen,
   signal: signal$1,
   wrap: wrap$3
 };
 
-const listen = ({
-  port
-}) => {
-  return port;
-};
-const signal = port => {
-  port.postMessage(readyMessage);
-};
-class IpcChildWithMessagePort extends Ipc {
-  constructor(port) {
-    super(port);
-  }
-  getData(event) {
-    return getData$1(event);
-  }
-  send(message) {
-    this._rawIpc.postMessage(message);
-  }
-  sendAndTransfer(message) {
-    const transfer = getTransferrables(message);
-    this._rawIpc.postMessage(message, transfer);
-  }
-  dispose() {
-    // ignore
-  }
-  onClose(callback) {
-    // ignore
-  }
-  onMessage(callback) {
-    this._rawIpc.addEventListener('message', callback);
-    this._rawIpc.start();
-  }
-}
-const wrap$2 = port => {
-  return new IpcChildWithMessagePort(port);
-};
-
-const IpcChildWithMessagePort$1 = {
-  __proto__: null,
-  listen,
-  signal,
-  wrap: wrap$2
-};
-
-const Message = 'message';
-const Error$1 = 'error';
+const Message$1 = 3;
 
 const addListener = (emitter, type, callback) => {
   if ('addEventListener' in emitter) {
@@ -635,6 +634,59 @@ const getFirstEvent = (eventEmitter, eventMap) => {
   return promise;
 };
 
+const create$2 = async ({
+  messagePort
+}) => {
+  if (!isMessagePort(messagePort)) {
+    throw new IpcError('port must be of type MessagePort');
+  }
+  const eventPromise = getFirstEvent(messagePort, {
+    message: Message$1
+  });
+  messagePort.start();
+  const event = await eventPromise;
+  // @ts-ignore
+  if (event.data !== readyMessage) {
+    throw new IpcError('unexpected first message');
+  }
+  return messagePort;
+};
+const signal = messagePort => {
+  messagePort.start();
+};
+class IpcParentWithMessagePort extends Ipc {
+  constructor(port) {
+    super(port);
+  }
+  getData = getData$1;
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    throw new Error('not implemented');
+  }
+  dispose() {
+    this._rawIpc.close();
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+  }
+  onClose(callback) {}
+}
+const wrap$2 = messagePort => {
+  return new IpcParentWithMessagePort(messagePort);
+};
+
+const IpcParentWithMessagePort$1 = {
+  __proto__: null,
+  create: create$2,
+  signal,
+  wrap: wrap$2
+};
+
+const Message = 'message';
+const Error$1 = 'error';
+
 const getFirstWorkerEvent = worker => {
   return getFirstEvent(worker, {
     message: Message,
@@ -808,4 +860,4 @@ const IpcParentWithWebSocket$1 = {
   wrap
 };
 
-export { IpcChildWithElectronWindow$1 as IpcChildWithElectronWindow, IpcChildWithMessagePort$1 as IpcChildWithMessagePort, IpcChildWithModuleWorker$1 as IpcChildWithModuleWorker, IpcChildWithModuleWorkerAndMessagePort$1 as IpcChildWithModuleWorkerAndMessagePort, IpcChildWithWindow$1 as IpcChildWithWindow, IpcParentWithModuleWorker$1 as IpcParentWithModuleWorker, IpcParentWithWebSocket$1 as IpcParentWithWebSocket };
+export { IpcChildWithElectronWindow$1 as IpcChildWithElectronWindow, IpcChildWithMessagePort$1 as IpcChildWithMessagePort, IpcChildWithModuleWorker$1 as IpcChildWithModuleWorker, IpcChildWithModuleWorkerAndMessagePort$1 as IpcChildWithModuleWorkerAndMessagePort, IpcChildWithWindow$1 as IpcChildWithWindow, IpcParentWithMessagePort$1 as IpcParentWithMessagePort, IpcParentWithModuleWorker$1 as IpcParentWithModuleWorker, IpcParentWithWebSocket$1 as IpcParentWithWebSocket };

package/dist/electron.js

@@ -356,10 +356,10 @@ const getHelpfulChildProcessError = (stdout, stderr) => {
 
 const normalizeLine = line => {
   if (line.startsWith('Error: ')) {
-    return line.slice(`Error: `.length);
+    return line.slice('Error: '.length);
   }
   if (line.startsWith('VError: ')) {
-    return line.slice(`VError: `.length);
+    return line.slice('VError: '.length);
   }
   return line;
 };

package/dist/index.d.ts

@@ -26,3 +26,4 @@ export const IpcParentWithElectronUtilityProcess: IpcParent
 export const IpcParentWithNodeForkedProcess: IpcParent
 export const IpcParentWithNodeWorker: IpcParent
 export const IpcParentWithElectronMessagePort: IpcParent
+export const IpcParentWithMessagePort: IpcParent

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@lvce-editor/ipc",
-  "version": "11.1.0",
+  "version": "11.3.0",
   "description": "Inter Process Communication for Lvce Editor",
   "main": "dist/index.js",
   "type": "module",
+  "sideEffects": false,
   "keywords": [
     "ipc"
   ],
@@ -15,8 +16,8 @@
   },
   "dependencies": {
     "@lvce-editor/assert": "^1.3.0",
-    "@lvce-editor/verror": "^1.4.0",
-    "@lvce-editor/web-socket-server": "^1.3.0"
+    "@lvce-editor/verror": "^1.6.0",
+    "@lvce-editor/web-socket-server": "^1.4.0"
   },
   "engines": {
     "node": ">=18"