@lvce-editor/ipc 5.1.0 → 7.0.0

package/dist/browser.js

@@ -1,7 +1,28 @@
-const getData$2 = event => {
+const getData$1 = event => {
   return event.data;
 };
 
+const attachEvent = (rawIpc, getData, that) => {
+  const wrapped = event => {
+    const data = getData(event);
+    that.dispatchEvent(new MessageEvent('message', {
+      data
+    }));
+  };
+  if ('onmessage' in rawIpc) {
+    rawIpc.onmessage = wrapped;
+  } else if ('on' in rawIpc) {
+    rawIpc.on('message', wrapped);
+  }
+};
+class Ipc extends EventTarget {
+  constructor(rawIpc) {
+    super();
+    attachEvent(rawIpc, this.getData, this);
+    this._rawIpc = rawIpc;
+  }
+}
+
 const readyMessage = 'ready';
 
 const listen$2 = () => {
@@ -14,43 +35,27 @@ const listen$2 = () => {
 const signal$1 = global => {
   global.postMessage(readyMessage);
 };
+class IpcChildWithModuleWorker extends Ipc {
+  getData(event) {
+    return getData$1(event);
+  }
+  send(message) {
+    // @ts-ignore
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message, transfer) {
+    // @ts-ignore
+    this._rawIpc.postMessage(message, transfer);
+  }
+  dispose() {
+    // ignore
+  }
+}
 const wrap$4 = global => {
-  return {
-    global,
-    /**
-     * @type {any}
-     */
-    listener: undefined,
-    send(message) {
-      this.global.postMessage(message);
-    },
-    sendAndTransfer(message, transferables) {
-      this.global.postMessage(message, transferables);
-    },
-    get onmessage() {
-      return this.listener;
-    },
-    set onmessage(listener) {
-      const wrappedListener = event => {
-        const data = getData$2(event);
-        // @ts-expect-error
-        listener({
-          data,
-          target: this
-        });
-      };
-      this.listener = listener;
-      this.global.onmessage = wrappedListener;
-    },
-    dispose() {
-      // @ts-ignore
-      this.listener = null;
-      this.global.onmessage = null;
-    }
-  };
+  return new IpcChildWithModuleWorker(global);
 };
 
-const IpcChildWithModuleWorker = {
+const IpcChildWithModuleWorker$1 = {
   __proto__: null,
   listen: listen$2,
   signal: signal$1,
@@ -303,94 +308,58 @@ const listen$1 = async () => {
   }
   return globalThis;
 };
-const wrap$3 = port => {
-  return {
-    port,
-    /**
-     * @type {any}
-     */
-    wrappedListener: undefined,
-    send(message) {
-      this.port.postMessage(message);
-    },
-    sendAndTransfer(message, transferables) {
-      this.port.postMessage(message, transferables);
-    },
-    get onmessage() {
-      return this.wrappedListener;
-    },
-    set onmessage(listener) {
-      if (listener) {
-        // @ts-expect-error
-        this.wrappedListener = event => {
-          const data = getData$2(event);
-          // @ts-expect-error
-          listener({
-            data,
-            target: this
-          });
-        };
-      } else {
-        this.wrappedListener = undefined;
-      }
-      this.port.onmessage = this.wrappedListener;
+class IpcChildWithModuleWorkerAndMessagePort extends Ipc {
+  getData(event) {
+    return getData$1(event);
+  }
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message, transfer) {
+    this._rawIpc.postMessage(message, transfer);
+  }
+  dispose() {
+    if (this._rawIpc.close) {
+      this._rawIpc.close();
     }
-  };
+  }
+}
+const wrap$3 = port => {
+  return new IpcChildWithModuleWorkerAndMessagePort(port);
 };
 
-const IpcChildWithModuleWorkerAndMessagePort = {
+const IpcChildWithModuleWorkerAndMessagePort$1 = {
   __proto__: null,
   listen: listen$1,
   wrap: wrap$3
 };
 
 const listen = () => {
-  // @ts-ignore
   return window;
 };
 const signal = global => {
   global.postMessage(readyMessage);
 };
+class IpcChildWithWindow extends Ipc {
+  getData(event) {
+    return getData$1(event);
+  }
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message, transfer) {
+    // TODO set diffrent origin
+    this._rawIpc.postMessage(message, '*', transfer);
+  }
+  dispose() {
+    // ignore
+  }
+}
 const wrap$2 = window => {
-  return {
-    window,
-    /**
-     * @type {any}
-     */
-    listener: undefined,
-    get onmessage() {
-      return this.listener;
-    },
-    set onmessage(listener) {
-      this.listener = listener;
-      const wrappedListener = event => {
-        const data = event.data;
-        if ('method' in data) {
-          return;
-        }
-        // @ts-ignore
-        listener({
-          data,
-          target: this
-        });
-      };
-      this.window.onmessage = wrappedListener;
-    },
-    send(message) {
-      this.window.postMessage(message);
-    },
-    sendAndTransfer(message, transfer) {
-      this.window.postMessage(message, '*', transfer);
-    },
-    dispose() {
-      this.window.onmessage = null;
-      this.window = undefined;
-      this.listener = undefined;
-    }
-  };
+  return new IpcChildWithWindow(window);
 };
 
-const IpcChildWithWindow = {
+const IpcChildWithWindow$1 = {
   __proto__: null,
   listen,
   signal,
@@ -510,43 +479,32 @@ const create$1 = async ({
   }
   return worker;
 };
-const getData$1 = event => {
+const getData = event => {
   // TODO why are some events not instance of message event?
   if (event instanceof MessageEvent) {
     return event.data;
   }
   return event;
 };
+class IpcParentWithModuleWorker extends Ipc {
+  getData(event) {
+    return getData(event);
+  }
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message, transfer) {
+    this._rawIpc.postMessage(message, transfer);
+  }
+  dispose() {
+    // igore
+  }
+}
 const wrap$1 = worker => {
-  let handleMessage;
-  return {
-    get onmessage() {
-      return handleMessage;
-    },
-    set onmessage(listener) {
-      if (listener) {
-        handleMessage = event => {
-          const data = getData$1(event);
-          listener({
-            data,
-            target: this
-          });
-        };
-      } else {
-        handleMessage = null;
-      }
-      worker.onmessage = handleMessage;
-    },
-    send(message) {
-      worker.postMessage(message);
-    },
-    sendAndTransfer(message, transfer) {
-      worker.postMessage(message, transfer);
-    }
-  };
+  return new IpcParentWithModuleWorker(worker);
 };
 
-const IpcParentWithModuleWorker = {
+const IpcParentWithModuleWorker$1 = {
   __proto__: null,
   create: create$1,
   wrap: wrap$1
@@ -586,43 +544,28 @@ const create = async ({
   }
   return webSocket;
 };
-const getData = event => {
-  return parse(event.data);
-};
+class IpcParentWithWebSocket extends Ipc {
+  getData(event) {
+    return parse(event.data);
+  }
+  send(message) {
+    this._rawIpc.send(stringifyCompact(message));
+  }
+  sendAndTransfer(message, transfer) {
+    throw new Error('sendAndTransfer not supported');
+  }
+  dispose() {
+    this._rawIpc.close();
+  }
+}
 const wrap = webSocket => {
-  return {
-    webSocket,
-    /**
-     * @type {any}
-     */
-    listener: undefined,
-    get onmessage() {
-      return this.listener;
-    },
-    set onmessage(listener) {
-      this.listener = listener;
-      const wrappedListener = event => {
-        const data = getData(event);
-        const syntheticEvent = {
-          data,
-          target: this
-        };
-        // @ts-ignore
-        listener(syntheticEvent);
-      };
-      this.webSocket.onmessage = wrappedListener;
-    },
-    send(message) {
-      const stringifiedMessage = stringifyCompact(message);
-      this.webSocket.send(stringifiedMessage);
-    }
-  };
+  return new IpcParentWithWebSocket(webSocket);
 };
 
-const IpcParentWithWebSocket = {
+const IpcParentWithWebSocket$1 = {
   __proto__: null,
   create,
   wrap
 };
 
-export { IpcChildWithModuleWorker, IpcChildWithModuleWorkerAndMessagePort, IpcChildWithWindow, IpcParentWithModuleWorker, IpcParentWithWebSocket };
+export { IpcChildWithModuleWorker$1 as IpcChildWithModuleWorker, IpcChildWithModuleWorkerAndMessagePort$1 as IpcChildWithModuleWorkerAndMessagePort, IpcChildWithWindow$1 as IpcChildWithWindow, IpcParentWithModuleWorker$1 as IpcParentWithModuleWorker, IpcParentWithWebSocket$1 as IpcParentWithWebSocket };

package/dist/index.js

@@ -1,6 +1,27 @@
 import { VError } from '@lvce-editor/verror';
 import { string, array } from '@lvce-editor/assert';
 
+const attachEvent = (rawIpc, getData, that) => {
+  const wrapped = event => {
+    const data = getData(event);
+    that.dispatchEvent(new MessageEvent('message', {
+      data
+    }));
+  };
+  if ('onmessage' in rawIpc) {
+    rawIpc.onmessage = wrapped;
+  } else if ('on' in rawIpc) {
+    rawIpc.on('message', wrapped);
+  }
+};
+class Ipc extends EventTarget {
+  constructor(rawIpc) {
+    super();
+    attachEvent(rawIpc, this.getData, this);
+    this._rawIpc = rawIpc;
+  }
+}
+
 const E_INCOMPATIBLE_NATIVE_MODULE = 'E_INCOMPATIBLE_NATIVE_MODULE';
 const E_MODULES_NOT_SUPPORTED_IN_ELECTRON = 'E_MODULES_NOT_SUPPORTED_IN_ELECTRON';
 const ERR_MODULE_NOT_FOUND = 'ERR_MODULE_NOT_FOUND';
@@ -174,46 +195,28 @@ const getActualData$1 = event => {
     params: [...ports, ...data.params]
   };
 };
+class IpcChildWithElectronMessagePort extends Ipc {
+  constructor(port) {
+    super(port);
+  }
+  getData(event) {
+    return getActualData$1(event);
+  }
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message, transfer) {
+    this._rawIpc.postMessage(message, transfer);
+  }
+  dispose() {
+    this._rawIpc.close();
+  }
+}
 const wrap$a = messagePort => {
-  return {
-    messagePort,
-    on(event, listener) {
-      if (event === 'message') {
-        // @ts-ignore
-        const wrappedListener = event => {
-          const actualData = getActualData$1(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');
-      }
-    },
-    off(event, listener) {
-      this.messagePort.off(event, listener);
-    },
-    send(message) {
-      this.messagePort.postMessage(message);
-    },
-    sendAndTransfer(message, transfer) {
-      this.messagePort.postMessage(message, transfer);
-    },
-    dispose() {
-      this.messagePort.close();
-    },
-    start() {
-      throw new Error('start method is deprecated');
-    }
-  };
+  return new IpcChildWithElectronMessagePort(messagePort);
 };
 
-const IpcChildWithElectronMessagePort = {
+const IpcChildWithElectronMessagePort$1 = {
   __proto__: null,
   listen: listen$7,
   signal: signal$6,
@@ -247,54 +250,28 @@ const listen$6 = () => {
   }
   return parentPort;
 };
-
-// @ts-ignore
 const signal$5 = parentPort => {
   parentPort.postMessage(readyMessage);
 };
-
-// @ts-ignore
+class IpcChildWithElectronUtilityProcess extends Ipc {
+  getData(event) {
+    return getUtilityProcessPortData(event);
+  }
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message, transfer) {
+    this._rawIpc.postMessage(message, transfer);
+  }
+  dispose() {
+    this._rawIpc.close();
+  }
+}
 const wrap$9 = parentPort => {
-  return {
-    parentPort,
-    // @ts-ignore
-    on(event, listener) {
-      if (event === 'message') {
-        // @ts-ignore
-        const wrappedListener = event => {
-          const actualData = getUtilityProcessPortData(event);
-          const syntheticEvent = {
-            data: actualData,
-            target: this
-          };
-          listener(syntheticEvent);
-        };
-        this.parentPort.on(event, wrappedListener);
-      } else if (event === 'close') {
-        this.parentPort.on('close', listener);
-      } else {
-        throw new Error('unsupported event type');
-      }
-    },
-    // @ts-ignore
-    off(event, listener) {
-      this.parentPort.off(event, listener);
-    },
-    // @ts-ignore
-    send(message) {
-      this.parentPort.postMessage(message);
-    },
-    // @ts-ignore
-    sendAndTransfer(message, transfer) {
-      this.parentPort.postMessage(message, transfer);
-    },
-    dispose() {
-      this.parentPort.close();
-    }
-  };
+  return new IpcChildWithElectronUtilityProcess(parentPort);
 };
 
-const IpcChildWithElectronUtilityProcess = {
+const IpcChildWithElectronUtilityProcess$1 = {
   __proto__: null,
   listen: listen$6,
   signal: signal$5,
@@ -315,43 +292,27 @@ const listen$5 = () => {
 const signal$4 = global => {
   global.postMessage(readyMessage);
 };
+class IpcChildWithModuleWorker extends Ipc {
+  getData(event) {
+    return getData(event);
+  }
+  send(message) {
+    // @ts-ignore
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message, transfer) {
+    // @ts-ignore
+    this._rawIpc.postMessage(message, transfer);
+  }
+  dispose() {
+    // ignore
+  }
+}
 const wrap$8 = global => {
-  return {
-    global,
-    /**
-     * @type {any}
-     */
-    listener: undefined,
-    send(message) {
-      this.global.postMessage(message);
-    },
-    sendAndTransfer(message, transferables) {
-      this.global.postMessage(message, transferables);
-    },
-    get onmessage() {
-      return this.listener;
-    },
-    set onmessage(listener) {
-      const wrappedListener = event => {
-        const data = getData(event);
-        // @ts-expect-error
-        listener({
-          data,
-          target: this
-        });
-      };
-      this.listener = listener;
-      this.global.onmessage = wrappedListener;
-    },
-    dispose() {
-      // @ts-ignore
-      this.listener = null;
-      this.global.onmessage = null;
-    }
-  };
+  return new IpcChildWithModuleWorker(global);
 };
 
-const IpcChildWithModuleWorker = {
+const IpcChildWithModuleWorker$1 = {
   __proto__: null,
   listen: listen$5,
   signal: signal$4,
@@ -403,42 +364,27 @@ const listen$4 = async () => {
   }
   return globalThis;
 };
-const wrap$7 = port => {
-  return {
-    port,
-    /**
-     * @type {any}
-     */
-    wrappedListener: undefined,
-    send(message) {
-      this.port.postMessage(message);
-    },
-    sendAndTransfer(message, transferables) {
-      this.port.postMessage(message, transferables);
-    },
-    get onmessage() {
-      return this.wrappedListener;
-    },
-    set onmessage(listener) {
-      if (listener) {
-        // @ts-expect-error
-        this.wrappedListener = event => {
-          const data = getData(event);
-          // @ts-expect-error
-          listener({
-            data,
-            target: this
-          });
-        };
-      } else {
-        this.wrappedListener = undefined;
-      }
-      this.port.onmessage = this.wrappedListener;
+class IpcChildWithModuleWorkerAndMessagePort extends Ipc {
+  getData(event) {
+    return getData(event);
+  }
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message, transfer) {
+    this._rawIpc.postMessage(message, transfer);
+  }
+  dispose() {
+    if (this._rawIpc.close) {
+      this._rawIpc.close();
     }
-  };
+  }
+}
+const wrap$7 = port => {
+  return new IpcChildWithModuleWorkerAndMessagePort(port);
 };
 
-const IpcChildWithModuleWorkerAndMessagePort = {
+const IpcChildWithModuleWorkerAndMessagePort$1 = {
   __proto__: null,
   listen: listen$4,
   wrap: wrap$7
@@ -863,7 +809,6 @@ const create$2 = async ({
 }) => {
   string(path);
   const actualArgv = ['--ipc-type=electron-utility-process', ...argv];
-  // @ts-ignore
   const {
     utilityProcess
   } = await import('electron');
@@ -887,38 +832,25 @@ const create$2 = async ({
   childProcess.stderr.pipe(process.stderr);
   return childProcess;
 };
-
-// @ts-ignore
+class IpcParentWithElectronUtilityProcess extends Ipc {
+  getData(data) {
+    return data;
+  }
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message, transfer) {
+    this._rawIpc.postMessage(message, transfer);
+  }
+  dispose() {
+    this._rawIpc.kill();
+  }
+}
 const wrap$2 = process => {
-  return {
-    process,
-    // @ts-ignore
-    on(event, listener) {
-      const wrappedListener = message => {
-        const syntheticEvent = {
-          data: message,
-          target: this
-        };
-        listener(syntheticEvent);
-      };
-      this.process.on(event, wrappedListener);
-    },
-    // @ts-ignore
-    send(message) {
-      this.process.postMessage(message);
-    },
-    // @ts-ignore
-    sendAndTransfer(message, transfer) {
-      array(transfer);
-      this.process.postMessage(message, transfer);
-    },
-    dispose() {
-      this.process.kill();
-    }
-  };
+  return new IpcParentWithElectronUtilityProcess(process);
 };
 
-const IpcParentWithElectronUtilityProcess = {
+const IpcParentWithElectronUtilityProcess$1 = {
   __proto__: null,
   create: create$2,
   wrap: wrap$2
@@ -1188,4 +1120,4 @@ const IpcParentWithNodeWorker = {
   wrap
 };
 
-export { IpcChildWithElectronMessagePort, IpcChildWithElectronUtilityProcess, IpcChildWithModuleWorker, IpcChildWithModuleWorkerAndMessagePort, IpcChildWithNodeForkedProcess, IpcChildWithNodeMessagePort, IpcChildWithNodeWorker, IpcChildWithWebSocket, IpcParentWithElectronUtilityProcess, IpcParentWithNodeForkedProcess, IpcParentWithNodeWorker };
+export { IpcChildWithElectronMessagePort$1 as IpcChildWithElectronMessagePort, IpcChildWithElectronUtilityProcess$1 as IpcChildWithElectronUtilityProcess, IpcChildWithModuleWorker$1 as IpcChildWithModuleWorker, IpcChildWithModuleWorkerAndMessagePort$1 as IpcChildWithModuleWorkerAndMessagePort, IpcChildWithNodeForkedProcess, IpcChildWithNodeMessagePort, IpcChildWithNodeWorker, IpcChildWithWebSocket, IpcParentWithElectronUtilityProcess$1 as IpcParentWithElectronUtilityProcess, IpcParentWithNodeForkedProcess, IpcParentWithNodeWorker };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/ipc",
-  "version": "5.1.0",
+  "version": "7.0.0",
   "description": "Inter Process Communication for Lvce Editor",
   "main": "dist/index.js",
   "type": "module",