emr-bridge 1.4.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.
package/README.md CHANGED
@@ -24,11 +24,11 @@ npm i emr-bridge
24
24
 
25
25
  ## Usage
26
26
 
27
- _If you need CommonJS modules, then use `emr-bridge/cjs`_
27
+ *If you need CommonJS modules, then use `emr-bridge/cjs`*
28
28
 
29
29
  There are three ways to use
30
30
 
31
- **IMPORTANT**: In any of the cases, you need to insert this code into preload
31
+ > In any of the cases, you need to insert this code into preload
32
32
 
33
33
  ```js
34
34
  // Preload process
@@ -37,7 +37,7 @@ import { provideFromMain } from 'emr-bridge/preload'
37
37
  provideFromMain(true /* context isolation */)
38
38
  ```
39
39
 
40
- **IMPORTANT**: To use experimental non-static decorators, it is required to wrap the creation of a class instance in the `providePublic` function
40
+ > To use experimental non-static decorators, it is required to wrap the creation of a class instance in the `providePublic` function
41
41
 
42
42
  ```js
43
43
  // Main process
@@ -48,7 +48,7 @@ class MainPublic { /*...*/ }
48
48
  const instance = providePublic(new MainPublic())
49
49
  ```
50
50
 
51
- **NOTE**: All experimental decorators can be found in `emr-bridge/exp`
51
+ > All experimental decorators can be found in `emr-bridge/exp`
52
52
 
53
53
  ### Static methods and properties
54
54
 
@@ -27,11 +27,11 @@ const Bridge = (0, provider_1.default)({
27
27
  return provider.provided.mainEvents[name](type, handler);
28
28
  },
29
29
  getVariable(name) {
30
- return provider.provided.properties[name];
30
+ return provider.provided.properties[name].get();
31
31
  },
32
32
  setVariable(name, value) {
33
- provider.provided.properties[name] = value;
34
- return;
33
+ provider.provided.properties[name].set(value);
34
+ return undefined;
35
35
  },
36
36
  waitPromise(channel) {
37
37
  return new Promise((resolve, reject) => {
@@ -29,57 +29,47 @@ function provideFromMain(contextIsolation = true) {
29
29
  }
30
30
  };
31
31
  info.functions.forEach(funcName => {
32
- Object.defineProperty(provider.provided.functions, funcName, {
33
- value(...args) {
34
- return electron_1.ipcRenderer.sendSync(enums_1.IPCChannel.functionCall + funcName, ...args);
35
- },
36
- enumerable: true
37
- });
32
+ provider.provided.functions[funcName] = (...args) => {
33
+ return electron_1.ipcRenderer.sendSync(enums_1.IPCChannel.functionCall + funcName, ...args);
34
+ };
38
35
  });
39
- info.rendererEvents.forEach(rendererEventName => {
40
- Object.defineProperty(provider.provided.rendererEvents, rendererEventName, {
41
- value(arg) {
42
- const emitChannel = enums_1.IPCChannel.rendererEventEmit + rendererEventName;
43
- if (arg instanceof Promise) {
44
- arg
45
- .then(value => electron_1.ipcRenderer.send(emitChannel, { value }))
46
- .catch(reason => electron_1.ipcRenderer.send(emitChannel, { error: String(reason) }));
47
- }
48
- else {
49
- electron_1.ipcRenderer.send(emitChannel, { value: arg });
50
- }
51
- },
52
- enumerable: true
53
- });
36
+ info.rendererEvents.forEach(eventName => {
37
+ provider.provided.rendererEvents[eventName] = (arg) => {
38
+ const emitChannel = enums_1.IPCChannel.rendererEventEmit + eventName;
39
+ if (arg instanceof Promise) {
40
+ arg
41
+ .then(value => electron_1.ipcRenderer.send(emitChannel, { value }))
42
+ .catch(reason => electron_1.ipcRenderer.send(emitChannel, { error: String(reason) }));
43
+ }
44
+ else {
45
+ electron_1.ipcRenderer.send(emitChannel, { value: arg });
46
+ }
47
+ };
54
48
  });
55
- info.mainEvents.forEach(mainEventName => {
56
- Object.defineProperty(provider.provided.mainEvents, mainEventName, {
57
- value(type, handler) {
58
- const listener = (_, result) => handler(result);
59
- const emitChannel = enums_1.IPCChannel.mainEventEmit + mainEventName;
60
- if (type === 'on') {
61
- electron_1.ipcRenderer.on(emitChannel, listener);
62
- electron_1.ipcRenderer.send(enums_1.IPCChannel.mainEventOn + mainEventName);
63
- }
64
- else {
65
- electron_1.ipcRenderer.once(emitChannel, listener);
66
- electron_1.ipcRenderer.send(enums_1.IPCChannel.mainEventOnce + mainEventName);
67
- }
68
- return () => electron_1.ipcRenderer.removeListener(emitChannel, listener);
69
- },
70
- enumerable: true
71
- });
49
+ info.mainEvents.forEach(eventName => {
50
+ provider.provided.mainEvents[eventName] = (type, handler) => {
51
+ const listener = (_, result) => handler(result);
52
+ const emitChannel = enums_1.IPCChannel.mainEventEmit + eventName;
53
+ if (type === 'on') {
54
+ electron_1.ipcRenderer.on(emitChannel, listener);
55
+ electron_1.ipcRenderer.send(enums_1.IPCChannel.mainEventOn + eventName);
56
+ }
57
+ else {
58
+ electron_1.ipcRenderer.once(emitChannel, listener);
59
+ electron_1.ipcRenderer.send(enums_1.IPCChannel.mainEventOnce + eventName);
60
+ }
61
+ return () => electron_1.ipcRenderer.removeListener(emitChannel, listener);
62
+ };
72
63
  });
73
64
  info.properties.forEach(propName => {
74
- Object.defineProperty(provider.provided.properties, propName, {
65
+ provider.provided.properties[propName] = {
75
66
  get() {
76
67
  return electron_1.ipcRenderer.sendSync(enums_1.IPCChannel.propertyGet + propName);
77
68
  },
78
69
  set(value) {
79
70
  electron_1.ipcRenderer.sendSync(enums_1.IPCChannel.propertySet + propName, value);
80
- },
81
- enumerable: true
82
- });
71
+ }
72
+ };
83
73
  });
84
74
  if (contextIsolation)
85
75
  electron_1.contextBridge.exposeInMainWorld('__provider__', provider);
package/cjs/types.d.ts CHANGED
@@ -60,7 +60,10 @@ export interface IProvider {
60
60
  functions: Record<string, (...args: any[]) => IIPCResult>;
61
61
  mainEvents: Record<string, (type: 'on' | 'once', handler: EventHandler<IIPCResult>) => EventUnsubscriber>;
62
62
  rendererEvents: Record<string, (arg: any) => void>;
63
- properties: Record<string, IIPCResult>;
63
+ properties: Record<string, {
64
+ get(): IIPCResult;
65
+ set(val: any): void;
66
+ }>;
64
67
  };
65
68
  }
66
69
  export type PublicFunction = (...args: any[]) => any;
@@ -22,11 +22,11 @@ const Bridge = createProvider({
22
22
  return provider.provided.mainEvents[name](type, handler);
23
23
  },
24
24
  getVariable(name) {
25
- return provider.provided.properties[name];
25
+ return provider.provided.properties[name].get();
26
26
  },
27
27
  setVariable(name, value) {
28
- provider.provided.properties[name] = value;
29
- return;
28
+ provider.provided.properties[name].set(value);
29
+ return undefined;
30
30
  },
31
31
  waitPromise(channel) {
32
32
  return new Promise((resolve, reject) => {
@@ -27,57 +27,47 @@ function provideFromMain(contextIsolation = true) {
27
27
  }
28
28
  };
29
29
  info.functions.forEach(funcName => {
30
- Object.defineProperty(provider.provided.functions, funcName, {
31
- value(...args) {
32
- return ipcRenderer.sendSync(IPCChannel.functionCall + funcName, ...args);
33
- },
34
- enumerable: true
35
- });
30
+ provider.provided.functions[funcName] = (...args) => {
31
+ return ipcRenderer.sendSync(IPCChannel.functionCall + funcName, ...args);
32
+ };
36
33
  });
37
- info.rendererEvents.forEach(rendererEventName => {
38
- Object.defineProperty(provider.provided.rendererEvents, rendererEventName, {
39
- value(arg) {
40
- const emitChannel = IPCChannel.rendererEventEmit + rendererEventName;
41
- if (arg instanceof Promise) {
42
- arg
43
- .then(value => ipcRenderer.send(emitChannel, { value }))
44
- .catch(reason => ipcRenderer.send(emitChannel, { error: String(reason) }));
45
- }
46
- else {
47
- ipcRenderer.send(emitChannel, { value: arg });
48
- }
49
- },
50
- enumerable: true
51
- });
34
+ info.rendererEvents.forEach(eventName => {
35
+ provider.provided.rendererEvents[eventName] = (arg) => {
36
+ const emitChannel = IPCChannel.rendererEventEmit + eventName;
37
+ if (arg instanceof Promise) {
38
+ arg
39
+ .then(value => ipcRenderer.send(emitChannel, { value }))
40
+ .catch(reason => ipcRenderer.send(emitChannel, { error: String(reason) }));
41
+ }
42
+ else {
43
+ ipcRenderer.send(emitChannel, { value: arg });
44
+ }
45
+ };
52
46
  });
53
- info.mainEvents.forEach(mainEventName => {
54
- Object.defineProperty(provider.provided.mainEvents, mainEventName, {
55
- value(type, handler) {
56
- const listener = (_, result) => handler(result);
57
- const emitChannel = IPCChannel.mainEventEmit + mainEventName;
58
- if (type === 'on') {
59
- ipcRenderer.on(emitChannel, listener);
60
- ipcRenderer.send(IPCChannel.mainEventOn + mainEventName);
61
- }
62
- else {
63
- ipcRenderer.once(emitChannel, listener);
64
- ipcRenderer.send(IPCChannel.mainEventOnce + mainEventName);
65
- }
66
- return () => ipcRenderer.removeListener(emitChannel, listener);
67
- },
68
- enumerable: true
69
- });
47
+ info.mainEvents.forEach(eventName => {
48
+ provider.provided.mainEvents[eventName] = (type, handler) => {
49
+ const listener = (_, result) => handler(result);
50
+ const emitChannel = IPCChannel.mainEventEmit + eventName;
51
+ if (type === 'on') {
52
+ ipcRenderer.on(emitChannel, listener);
53
+ ipcRenderer.send(IPCChannel.mainEventOn + eventName);
54
+ }
55
+ else {
56
+ ipcRenderer.once(emitChannel, listener);
57
+ ipcRenderer.send(IPCChannel.mainEventOnce + eventName);
58
+ }
59
+ return () => ipcRenderer.removeListener(emitChannel, listener);
60
+ };
70
61
  });
71
62
  info.properties.forEach(propName => {
72
- Object.defineProperty(provider.provided.properties, propName, {
63
+ provider.provided.properties[propName] = {
73
64
  get() {
74
65
  return ipcRenderer.sendSync(IPCChannel.propertyGet + propName);
75
66
  },
76
67
  set(value) {
77
68
  ipcRenderer.sendSync(IPCChannel.propertySet + propName, value);
78
- },
79
- enumerable: true
80
- });
69
+ }
70
+ };
81
71
  });
82
72
  if (contextIsolation)
83
73
  contextBridge.exposeInMainWorld('__provider__', provider);
package/esm/types.d.ts CHANGED
@@ -60,7 +60,10 @@ export interface IProvider {
60
60
  functions: Record<string, (...args: any[]) => IIPCResult>;
61
61
  mainEvents: Record<string, (type: 'on' | 'once', handler: EventHandler<IIPCResult>) => EventUnsubscriber>;
62
62
  rendererEvents: Record<string, (arg: any) => void>;
63
- properties: Record<string, IIPCResult>;
63
+ properties: Record<string, {
64
+ get(): IIPCResult;
65
+ set(val: any): void;
66
+ }>;
64
67
  };
65
68
  }
66
69
  export type PublicFunction = (...args: any[]) => any;
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "emr-bridge",
3
- "version": "1.4.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": {