emr-bridge 1.3.0 → 1.4.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -3,7 +3,7 @@ function errorHandler(error, channel) {
3
3
  console.error(`Error on ${channel}.\n${error}`.replace('Error: ', ''));
4
4
  }
5
5
  function createProvider(args) {
6
- const { info, scope, getVariable, setVariable, callFunction, handleEvent, waitPromise } = args;
6
+ const { info, scope, getVariable, setVariable, callFunction, handleMainEvent, waitPromise, emitRendererEvent } = args;
7
7
  const target = {
8
8
  as: () => proxy
9
9
  };
@@ -29,17 +29,30 @@ function createProvider(args) {
29
29
  enumerable: true
30
30
  });
31
31
  });
32
- info.events.forEach(eventName => {
33
- if (!info.scopes[eventName].has(scope))
32
+ info.rendererEvents.forEach(rendererEventName => {
33
+ if (!info.scopes[rendererEventName].has(scope))
34
34
  return;
35
- const eventNameOn = `on${eventName[0].toUpperCase()}${eventName.slice(1)}`;
36
- const eventNameOnce = `once${eventName[0].toUpperCase()}${eventName.slice(1)}`;
35
+ Object.defineProperty(target, rendererEventName, {
36
+ get() {
37
+ return (arg) => emitRendererEvent(rendererEventName, arg);
38
+ },
39
+ set() {
40
+ throw new Error(`Function '${rendererEventName}' is readonly`);
41
+ },
42
+ enumerable: true
43
+ });
44
+ });
45
+ info.mainEvents.forEach(mainEventName => {
46
+ if (!info.scopes[mainEventName].has(scope))
47
+ return;
48
+ const eventNameOn = `on${mainEventName[0].toUpperCase()}${mainEventName.slice(1)}`;
49
+ const eventNameOnce = `once${mainEventName[0].toUpperCase()}${mainEventName.slice(1)}`;
37
50
  Object.defineProperty(target, eventNameOn, {
38
51
  get() {
39
52
  return (handler) => {
40
- return handleEvent(eventName, 'on', (result) => {
53
+ return handleMainEvent(mainEventName, 'on', (result) => {
41
54
  if (result.error) {
42
- errorHandler(result.error, eventName);
55
+ errorHandler(result.error, mainEventName);
43
56
  return;
44
57
  }
45
58
  if (result.promiseChannel)
@@ -56,9 +69,9 @@ function createProvider(args) {
56
69
  Object.defineProperty(target, eventNameOnce, {
57
70
  get() {
58
71
  return (handler) => {
59
- return handleEvent(eventName, 'once', (result) => {
72
+ return handleMainEvent(mainEventName, 'once', (result) => {
60
73
  if (result.error) {
61
- errorHandler(result.error, eventName);
74
+ errorHandler(result.error, mainEventName);
62
75
  return;
63
76
  }
64
77
  if (result.promiseChannel)
@@ -1,14 +1,19 @@
1
1
  import { Access, Scope } from '../enums';
2
- import type { EventEmitter, PublicFunction, PublicProperty } from '../types';
2
+ import type { EventEmitter, PublicFunction, PublicProperty, RendererEvent } from '../types';
3
3
  /**
4
- * Makes the event available for **renderer** and **preload** processes.
4
+ * Makes the event from **main** available for **renderer** and **preload** processes.
5
5
  *
6
- * _only for event_
7
6
  * @param name - name by which the event will be accessed
8
- * @param func - linked emitter
9
7
  * @param scopes - event scopes
10
8
  */
11
- export declare function publicEvent<Emitter extends EventEmitter>(name: string, func?: Emitter, scopes?: Scope[]): (...args: Parameters<Emitter>) => void;
9
+ export declare function publicMainEvent<Emitter extends EventEmitter>(name: string, receiver?: Emitter, scopes?: Scope[]): (...args: Parameters<Emitter>) => void;
10
+ /**
11
+ * Makes the event from **renderer** and **preload** available for **main** process.
12
+ *
13
+ * @param name - name by which the event will be accessed
14
+ * @param scopes - event scopes
15
+ */
16
+ export declare function publicRendererEvent<I = undefined, O = I>(name: string, receiver?: (v?: I) => O, scopes?: Scope[]): RendererEvent<O>;
12
17
  /**
13
18
  * Makes the function available for **renderer** and **preload** processes.
14
19
  *
@@ -3,33 +3,32 @@ import { Access, IPCChannel, Scope } from '../enums';
3
3
  const publicInfo = {
4
4
  properties: new Set(),
5
5
  functions: new Set(),
6
- events: new Set(),
6
+ mainEvents: new Set(),
7
+ rendererEvents: new Set(),
7
8
  accesses: {},
8
9
  scopes: {}
9
10
  };
10
11
  ipcMain.on(IPCChannel.getPublicInfo, e => e.returnValue = publicInfo);
11
12
  /**
12
- * Makes the event available for **renderer** and **preload** processes.
13
+ * Makes the event from **main** available for **renderer** and **preload** processes.
13
14
  *
14
- * _only for event_
15
15
  * @param name - name by which the event will be accessed
16
- * @param func - linked emitter
17
16
  * @param scopes - event scopes
18
17
  */
19
- export function publicEvent(name, func = (() => { }), scopes = [Scope.preload, Scope.renderer]) {
20
- const { events } = publicInfo;
21
- const emitChannel = IPCChannel.eventEmit + name;
22
- const handleChannel = IPCChannel.eventHandleOn + name;
23
- const handleChannelOnce = IPCChannel.eventHandleOnce + name;
18
+ export function publicMainEvent(name, receiver = ((v = undefined) => v), scopes = [Scope.preload, Scope.renderer]) {
19
+ const { mainEvents } = publicInfo;
20
+ const mainEmitChannel = IPCChannel.mainEventEmit + name;
21
+ const mainHandleChannel = IPCChannel.mainEventOn + name;
22
+ const mainHandleChannelOnce = IPCChannel.mainEventOnce + name;
24
23
  let senders = [];
25
24
  let sendersOnce = [];
26
- events.add(name);
25
+ mainEvents.add(name);
27
26
  if (!publicInfo.scopes[name])
28
27
  publicInfo.scopes[name] = new Set(scopes);
29
- ipcMain.removeAllListeners(handleChannel);
30
- ipcMain.removeAllListeners(handleChannelOnce);
31
- ipcMain.on(handleChannel, ({ sender }) => !senders.includes(sender) && senders.push(sender));
32
- ipcMain.on(handleChannelOnce, ({ sender }) => !sendersOnce.includes(sender) && sendersOnce.push(sender));
28
+ ipcMain.removeAllListeners(mainHandleChannel);
29
+ ipcMain.removeAllListeners(mainHandleChannelOnce);
30
+ ipcMain.on(mainHandleChannel, ({ sender }) => !senders.includes(sender) && senders.push(sender));
31
+ ipcMain.on(mainHandleChannelOnce, ({ sender }) => !sendersOnce.includes(sender) && sendersOnce.push(sender));
33
32
  return (...args) => {
34
33
  function filterSenders() {
35
34
  senders = senders.filter(sender => !sender.isDestroyed());
@@ -38,33 +37,69 @@ export function publicEvent(name, func = (() => { }), scopes = [Scope.preload, S
38
37
  filterSenders();
39
38
  const allSenders = [...senders, ...sendersOnce];
40
39
  try {
41
- const result = func(...args);
40
+ const result = receiver(...args);
42
41
  if (result instanceof Promise) {
43
- const promiseChannel = emitChannel + IPCChannel.promisePostfix;
44
42
  result
45
43
  .then(value => {
46
44
  filterSenders();
47
- [...senders, ...sendersOnce].forEach(sender => sender.send(promiseChannel, { value }));
45
+ [...senders, ...sendersOnce].forEach(sender => sender.send(mainEmitChannel, { value }));
48
46
  sendersOnce = [];
49
47
  })
50
48
  .catch(reason => {
51
49
  filterSenders();
52
- [...senders, ...sendersOnce].forEach(sender => sender.send(promiseChannel, { error: String(reason) }));
50
+ [...senders, ...sendersOnce].forEach(sender => sender.send(mainEmitChannel, { error: String(reason) }));
53
51
  sendersOnce = [];
54
52
  });
55
- allSenders.forEach(sender => sender.send(promiseChannel, { promiseChannel }));
56
53
  }
57
54
  else {
58
- allSenders.forEach(sender => sender.send(emitChannel, { value: result }));
55
+ allSenders.forEach(sender => sender.send(mainEmitChannel, { value: result }));
59
56
  sendersOnce = [];
60
57
  }
61
58
  }
62
59
  catch (error) {
63
- allSenders.forEach(sender => sender.send(emitChannel, { error: String(error) }));
60
+ allSenders.forEach(sender => sender.send(mainEmitChannel, { error: String(error) }));
64
61
  sendersOnce = [];
65
62
  }
66
63
  };
67
64
  }
65
+ /**
66
+ * Makes the event from **renderer** and **preload** available for **main** process.
67
+ *
68
+ * @param name - name by which the event will be accessed
69
+ * @param scopes - event scopes
70
+ */
71
+ export function publicRendererEvent(name, receiver = ((v = undefined) => v), scopes = [Scope.preload, Scope.renderer]) {
72
+ if (name.startsWith('on')) {
73
+ name = name.replace('on', '');
74
+ name = `${name[0].toLowerCase()}${name.slice(1)}`;
75
+ }
76
+ const { rendererEvents } = publicInfo;
77
+ const rendererEmitChannel = IPCChannel.rendererEventEmit + name;
78
+ const handlers = new Set();
79
+ const handlersOnce = new Set();
80
+ rendererEvents.add(name);
81
+ if (!publicInfo.scopes[name])
82
+ publicInfo.scopes[name] = new Set(scopes);
83
+ ipcMain.removeAllListeners(rendererEmitChannel);
84
+ ipcMain.on(rendererEmitChannel, (_, result) => {
85
+ if (result.error)
86
+ throw new Error(result.error);
87
+ const converted = receiver(result.value);
88
+ handlers.forEach(handler => handler(converted));
89
+ handlersOnce.forEach(handler => handler(converted));
90
+ handlersOnce.clear();
91
+ });
92
+ return (handler, isOnce = false) => {
93
+ if (isOnce) {
94
+ handlersOnce.add(handler);
95
+ return () => handlersOnce.delete(handler);
96
+ }
97
+ else {
98
+ handlers.add(handler);
99
+ return () => handlers.delete(handler);
100
+ }
101
+ };
102
+ }
68
103
  /**
69
104
  * Makes the function available for **renderer** and **preload** processes.
70
105
  *
package/esm/types.d.ts CHANGED
@@ -18,10 +18,15 @@ export interface IPublishMethodArgs {
18
18
  name?: string;
19
19
  scope?: Scope;
20
20
  }
21
- export interface IPublishEventArgs {
21
+ export interface IPublishMainEventArgs {
22
22
  name?: string;
23
23
  scope?: Scope;
24
24
  }
25
+ export interface IPublishRendererEventArgs {
26
+ name?: string;
27
+ scope?: Scope;
28
+ receiver?: EventReceiver;
29
+ }
25
30
  export interface IPublishPropertyArgs {
26
31
  name?: string;
27
32
  scope?: Scope;
@@ -30,7 +35,8 @@ export interface IPublishPropertyArgs {
30
35
  export interface ICreateProviderArgs {
31
36
  info: IInfo;
32
37
  scope: Scope;
33
- handleEvent(name: string, type: 'on' | 'once', handler: EventHandler<IIPCResult>): EventUnsubscriber;
38
+ handleMainEvent(name: string, type: 'on' | 'once', handler: EventHandler<IIPCResult>): EventUnsubscriber;
39
+ emitRendererEvent(name: string, arg: any): void;
34
40
  callFunction(name: string, ...args: any[]): IIPCResult;
35
41
  getVariable(name: string): IIPCResult;
36
42
  setVariable(name: string, value: any): IIPCResult | undefined;
@@ -38,8 +44,10 @@ export interface ICreateProviderArgs {
38
44
  }
39
45
  export type Scopes = Record<string, Set<Scope>>;
40
46
  export type Accesses = Record<string, Set<Access>>;
47
+ export type RendererEvent<T = undefined> = (handler: EventHandler<T>, isOnce?: boolean) => EventUnsubscriber;
41
48
  export type MainEvent<T = undefined> = (handler: EventHandler<T>) => EventUnsubscriber;
42
49
  export type EventEmitter = (...args: any[]) => any;
50
+ export type EventReceiver<I = any, O = any> = (input: I) => O;
43
51
  export type EventUnsubscriber = () => void;
44
52
  export type EventHandler<T> = (result: T) => void;
45
53
  export interface IRendererPublic {
@@ -50,8 +58,12 @@ export interface IProvider {
50
58
  waitPromise(name: string, resolve: (value: any) => void, reject?: (reason?: any) => void): void;
51
59
  provided: {
52
60
  functions: Record<string, (...args: any[]) => IIPCResult>;
53
- events: Record<string, (type: 'on' | 'once', handler: EventHandler<IIPCResult>) => EventUnsubscriber>;
54
- properties: Record<string, IIPCResult>;
61
+ mainEvents: Record<string, (type: 'on' | 'once', handler: EventHandler<IIPCResult>) => EventUnsubscriber>;
62
+ rendererEvents: Record<string, (arg: any) => void>;
63
+ properties: Record<string, {
64
+ get(): IIPCResult;
65
+ set(val: any): void;
66
+ }>;
55
67
  };
56
68
  }
57
69
  export type PublicFunction = (...args: any[]) => any;
@@ -62,7 +74,8 @@ export type PublicProperty = {
62
74
  export interface IInfo {
63
75
  properties: Set<string>;
64
76
  functions: Set<string>;
65
- events: Set<string>;
77
+ mainEvents: Set<string>;
78
+ rendererEvents: Set<string>;
66
79
  scopes: Scopes;
67
80
  accesses: Accesses;
68
81
  }
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "emr-bridge",
3
- "version": "1.3.0",
3
+ "version": "1.4.1",
4
4
  "description": "Allows you to easily give access to main methods from the renderer process",
5
5
  "main": "esm/index.js",
6
6
  "scripts": {