emr-bridge 1.2.1 → 1.3.0

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.
Files changed (57) hide show
  1. package/LICENCE +1 -1
  2. package/README.md +22 -22
  3. package/{lib → cjs}/enums.d.ts +3 -0
  4. package/cjs/enums.js +24 -0
  5. package/cjs/exp.d.ts +4 -0
  6. package/cjs/exp.js +18 -0
  7. package/cjs/index.d.ts +4 -0
  8. package/cjs/index.js +16 -0
  9. package/cjs/preload.js +10 -0
  10. package/cjs/renderer.js +8 -0
  11. package/cjs/scripts/Bridge.js +39 -0
  12. package/cjs/scripts/Main.js +53 -0
  13. package/{lib → cjs}/scripts/newDecorators.d.ts +21 -1
  14. package/cjs/scripts/newDecorators.js +116 -0
  15. package/{lib → cjs}/scripts/oldDecorators.d.ts +59 -1
  16. package/cjs/scripts/oldDecorators.js +111 -0
  17. package/cjs/scripts/preloadProvider.js +72 -0
  18. package/cjs/scripts/provider.js +146 -0
  19. package/{lib → cjs}/scripts/publish.d.ts +10 -1
  20. package/cjs/scripts/publish.js +167 -0
  21. package/{lib → cjs}/types.d.ts +11 -0
  22. package/cjs/types.js +2 -0
  23. package/esm/enums.d.ts +18 -0
  24. package/{lib → esm}/enums.js +3 -0
  25. package/esm/exp.d.ts +4 -0
  26. package/esm/exp.js +3 -0
  27. package/esm/index.d.ts +4 -0
  28. package/esm/index.js +3 -0
  29. package/esm/preload.js +2 -0
  30. package/esm/renderer.js +1 -0
  31. package/esm/scripts/Bridge.d.ts +7 -0
  32. package/{lib → esm}/scripts/Bridge.js +3 -0
  33. package/esm/scripts/Main.d.ts +7 -0
  34. package/{lib → esm}/scripts/Main.js +13 -0
  35. package/esm/scripts/newDecorators.d.ts +101 -0
  36. package/{lib → esm}/scripts/newDecorators.js +20 -1
  37. package/esm/scripts/oldDecorators.d.ts +181 -0
  38. package/{lib → esm}/scripts/oldDecorators.js +27 -1
  39. package/esm/scripts/preloadProvider.d.ts +7 -0
  40. package/{lib → esm}/scripts/preloadProvider.js +20 -1
  41. package/esm/scripts/provider.d.ts +3 -0
  42. package/{lib → esm}/scripts/provider.js +45 -1
  43. package/esm/scripts/publish.d.ts +31 -0
  44. package/{lib → esm}/scripts/publish.js +58 -0
  45. package/esm/types.d.ts +68 -0
  46. package/package.json +48 -16
  47. package/lib/index.d.ts +0 -5
  48. package/lib/index.js +0 -4
  49. /package/{lib → cjs}/preload.d.ts +0 -0
  50. /package/{lib → cjs}/renderer.d.ts +0 -0
  51. /package/{lib → cjs}/scripts/Bridge.d.ts +0 -0
  52. /package/{lib → cjs}/scripts/Main.d.ts +0 -0
  53. /package/{lib → cjs}/scripts/preloadProvider.d.ts +0 -0
  54. /package/{lib → cjs}/scripts/provider.d.ts +0 -0
  55. /package/{lib/preload.js → esm/preload.d.ts} +0 -0
  56. /package/{lib/renderer.js → esm/renderer.d.ts} +0 -0
  57. /package/{lib → esm}/types.js +0 -0
@@ -0,0 +1,111 @@
1
+ "use strict";
2
+ Object.defineProperty(exports, "__esModule", { value: true });
3
+ exports.providePublic = exports.publicProperty = exports.publicStaticProperty = exports.publicClassEvent = exports.publicStaticEvent = exports.publicMethod = exports.publicStaticMethod = void 0;
4
+ const publish_1 = require("./publish");
5
+ function publicStaticMethod(arg) {
6
+ return (target, key) => {
7
+ let name = String(key);
8
+ if (arg) {
9
+ if (typeof arg === 'string') {
10
+ name = arg;
11
+ }
12
+ else {
13
+ name = arg.name ?? String(key);
14
+ if (arg.scope)
15
+ (0, publish_1.addScope)(name, arg.scope);
16
+ }
17
+ }
18
+ (0, publish_1.publicFunction)(name, (...args) => target[key](...args));
19
+ };
20
+ }
21
+ exports.publicStaticMethod = publicStaticMethod;
22
+ function publicMethod(arg) {
23
+ return (tgt, key, _) => {
24
+ const target = tgt;
25
+ const prevRegister = target.__register__ ?? (() => { });
26
+ target.__register__ = instance => {
27
+ prevRegister(instance);
28
+ publicStaticMethod(arg)(instance, key, _);
29
+ };
30
+ };
31
+ }
32
+ exports.publicMethod = publicMethod;
33
+ function publicStaticEvent(arg) {
34
+ return (target, key) => {
35
+ let name = String(key);
36
+ if (arg) {
37
+ if (typeof arg === 'string') {
38
+ name = arg;
39
+ }
40
+ else {
41
+ name = arg.name ?? String(key);
42
+ if (arg.scope)
43
+ (0, publish_1.addScope)(name, arg.scope);
44
+ }
45
+ }
46
+ target[key] = (0, publish_1.publicEvent)(name, target[key].bind(target));
47
+ };
48
+ }
49
+ exports.publicStaticEvent = publicStaticEvent;
50
+ function publicClassEvent(arg) {
51
+ return (tgt, key, _) => {
52
+ const target = tgt;
53
+ const prevRegister = target.__register__ ?? (() => { });
54
+ target.__register__ = instance => {
55
+ prevRegister(instance);
56
+ publicStaticEvent(arg)(instance, key, _);
57
+ };
58
+ };
59
+ }
60
+ exports.publicClassEvent = publicClassEvent;
61
+ function publicStaticProperty(arg) {
62
+ return (target, key) => {
63
+ let name = String(key);
64
+ if (arg) {
65
+ if (typeof arg === 'string') {
66
+ name = arg;
67
+ }
68
+ else {
69
+ name = arg.name ?? String(key);
70
+ if (arg.scope)
71
+ (0, publish_1.addScope)(name, arg.scope);
72
+ if (arg.access)
73
+ (0, publish_1.addAccess)(name, arg.access);
74
+ }
75
+ }
76
+ (0, publish_1.publicVariable)(name, {
77
+ get() {
78
+ return target[key];
79
+ },
80
+ set(value) {
81
+ target[key] = value;
82
+ }
83
+ });
84
+ };
85
+ }
86
+ exports.publicStaticProperty = publicStaticProperty;
87
+ function publicProperty(arg) {
88
+ return (tgt, key) => {
89
+ const target = tgt;
90
+ const prevRegister = target.__register__ ?? (() => { });
91
+ target.__register__ = instance => {
92
+ prevRegister(instance);
93
+ publicStaticProperty(arg)(instance, key);
94
+ };
95
+ };
96
+ }
97
+ exports.publicProperty = publicProperty;
98
+ /**
99
+ * Binds all public entities of a class to a specific instance.
100
+ *
101
+ * _only for class instance_
102
+ */
103
+ function providePublic(instance) {
104
+ const target = instance;
105
+ if (!target.__register__)
106
+ throw new Error('Public methods not defined');
107
+ target.__register__(instance);
108
+ target.__register__ = undefined;
109
+ return instance;
110
+ }
111
+ exports.providePublic = providePublic;
@@ -0,0 +1,72 @@
1
+ "use strict";
2
+ Object.defineProperty(exports, "__esModule", { value: true });
3
+ const electron_1 = require("electron");
4
+ const enums_1 = require("../enums");
5
+ const info = electron_1.ipcRenderer.sendSync(enums_1.IPCChannel.getPublicInfo);
6
+ /**
7
+ * Sets access to main from renderer
8
+ *
9
+ * @param contextIsolation - _default_: `true`
10
+ */
11
+ function provideFromMain(contextIsolation = true) {
12
+ const provider = {
13
+ getInfo() {
14
+ return info;
15
+ },
16
+ waitPromise(channel, resolve, reject) {
17
+ electron_1.ipcRenderer.once(channel, (_, result) => {
18
+ if (result.error)
19
+ reject?.(result.error);
20
+ else
21
+ resolve(result.value);
22
+ });
23
+ },
24
+ provided: {
25
+ properties: {},
26
+ functions: {},
27
+ events: {}
28
+ }
29
+ };
30
+ info.functions.forEach(funcName => {
31
+ Object.defineProperty(provider.provided.functions, funcName, {
32
+ value(...args) {
33
+ return electron_1.ipcRenderer.sendSync(enums_1.IPCChannel.functionCall + funcName, ...args);
34
+ },
35
+ enumerable: true
36
+ });
37
+ });
38
+ info.events.forEach(eventName => {
39
+ Object.defineProperty(provider.provided.events, eventName, {
40
+ value(type, handler) {
41
+ const listener = (_, result) => handler(result);
42
+ const emitChannel = enums_1.IPCChannel.eventEmit + eventName;
43
+ if (type === 'on') {
44
+ electron_1.ipcRenderer.send(enums_1.IPCChannel.eventHandleOn + eventName);
45
+ electron_1.ipcRenderer.on(emitChannel, listener);
46
+ }
47
+ else {
48
+ electron_1.ipcRenderer.send(enums_1.IPCChannel.eventHandleOnce + eventName);
49
+ electron_1.ipcRenderer.once(emitChannel, listener);
50
+ }
51
+ return () => electron_1.ipcRenderer.removeListener(emitChannel, listener);
52
+ },
53
+ enumerable: true
54
+ });
55
+ });
56
+ info.properties.forEach(propName => {
57
+ Object.defineProperty(provider.provided.properties, propName, {
58
+ get() {
59
+ return electron_1.ipcRenderer.sendSync(enums_1.IPCChannel.propertyGet + propName);
60
+ },
61
+ set(value) {
62
+ electron_1.ipcRenderer.sendSync(enums_1.IPCChannel.propertySet + propName, value);
63
+ },
64
+ enumerable: true
65
+ });
66
+ });
67
+ if (contextIsolation)
68
+ electron_1.contextBridge.exposeInMainWorld('__provider__', provider);
69
+ else
70
+ window.__provider__ = provider;
71
+ }
72
+ exports.default = provideFromMain;
@@ -0,0 +1,146 @@
1
+ "use strict";
2
+ Object.defineProperty(exports, "__esModule", { value: true });
3
+ const enums_1 = require("../enums");
4
+ function errorHandler(error, channel) {
5
+ console.error(`Error on ${channel}.\n${error}`.replace('Error: ', ''));
6
+ }
7
+ function createProvider(args) {
8
+ const { info, scope, getVariable, setVariable, callFunction, handleEvent, waitPromise } = args;
9
+ const target = {
10
+ as: () => proxy
11
+ };
12
+ info.functions.forEach(funcName => {
13
+ if (!info.scopes[funcName].has(scope))
14
+ return;
15
+ Object.defineProperty(target, funcName, {
16
+ get() {
17
+ return (...args) => {
18
+ const result = callFunction(funcName, ...args);
19
+ if (result.error) {
20
+ errorHandler(result.error, funcName);
21
+ return;
22
+ }
23
+ if (result.promiseChannel)
24
+ return waitPromise(result.promiseChannel);
25
+ return result.value;
26
+ };
27
+ },
28
+ set() {
29
+ throw new Error(`Function '${funcName}' is readonly`);
30
+ },
31
+ enumerable: true
32
+ });
33
+ });
34
+ info.events.forEach(eventName => {
35
+ if (!info.scopes[eventName].has(scope))
36
+ return;
37
+ const eventNameOn = `on${eventName[0].toUpperCase()}${eventName.slice(1)}`;
38
+ const eventNameOnce = `once${eventName[0].toUpperCase()}${eventName.slice(1)}`;
39
+ Object.defineProperty(target, eventNameOn, {
40
+ get() {
41
+ return (handler) => {
42
+ return handleEvent(eventName, 'on', (result) => {
43
+ if (result.error) {
44
+ errorHandler(result.error, eventName);
45
+ return;
46
+ }
47
+ if (result.promiseChannel)
48
+ waitPromise(result.promiseChannel).then(handler);
49
+ handler(result.value);
50
+ });
51
+ };
52
+ },
53
+ set() {
54
+ throw new Error(`Function '${eventNameOn}' is readonly`);
55
+ },
56
+ enumerable: true
57
+ });
58
+ Object.defineProperty(target, eventNameOnce, {
59
+ get() {
60
+ return (handler) => {
61
+ return handleEvent(eventName, 'once', (result) => {
62
+ if (result.error) {
63
+ errorHandler(result.error, eventName);
64
+ return;
65
+ }
66
+ if (result.promiseChannel)
67
+ waitPromise(result.promiseChannel).then(handler);
68
+ handler(result.value);
69
+ });
70
+ };
71
+ },
72
+ set() {
73
+ throw new Error(`Function '${eventNameOnce}' is readonly`);
74
+ },
75
+ enumerable: true
76
+ });
77
+ });
78
+ info.properties.forEach(propName => {
79
+ if (!info.scopes[propName].has(scope))
80
+ return;
81
+ let getter = () => {
82
+ const result = getVariable(propName);
83
+ if (result.error) {
84
+ errorHandler(result.error, propName);
85
+ return;
86
+ }
87
+ return result.value;
88
+ };
89
+ let setter = (value) => {
90
+ const result = setVariable(propName, value);
91
+ if (result?.error) {
92
+ errorHandler(result.error, propName);
93
+ return;
94
+ }
95
+ };
96
+ if (!info.accesses[propName].has(enums_1.Access.get))
97
+ getter = () => { throw new Error(`No access to getting the '${propName}' property`); };
98
+ if (!info.accesses[propName].has(enums_1.Access.set))
99
+ setter = () => { throw new Error(`No access to setting the '${propName}' property`); };
100
+ Object.defineProperty(target, propName, {
101
+ get: getter,
102
+ set: setter,
103
+ enumerable: true
104
+ });
105
+ });
106
+ const proxy = new Proxy(target, {
107
+ get(target, key) {
108
+ if (key in target)
109
+ return target[key];
110
+ const isFunction = info.functions.has(key);
111
+ const isProperty = info.properties.has(key);
112
+ if (!isFunction && !isProperty)
113
+ throw new Error(`'${key}' is not provided from main`);
114
+ if (!info.scopes[key].has(enums_1.Scope.renderer))
115
+ throw new Error(`'${key}' is not provided into renderer scope`);
116
+ if (isProperty && !info.accesses[key].has(enums_1.Access.get))
117
+ throw new Error(`No access to getting the '${key}' property`);
118
+ throw new Error(`Unknown error on get '${key}'`);
119
+ },
120
+ set(target, key, newValue) {
121
+ if (key in target) {
122
+ target[key] = newValue;
123
+ return true;
124
+ }
125
+ const isFunction = info.functions.has(key);
126
+ const isProperty = info.properties.has(key);
127
+ if (isFunction)
128
+ throw new Error(`Function '${key}' is readonly`);
129
+ if (!isProperty)
130
+ throw new Error(`Property '${key}' is not provided from main`);
131
+ if (!info.scopes[key].has(enums_1.Scope.renderer))
132
+ throw new Error(`'${key}' is not provided into renderer scope`);
133
+ if (!info.accesses[key].has(enums_1.Access.set))
134
+ throw new Error(`No access to setting the '${key}' property`);
135
+ throw new Error(`Unknown error on set '${key}'`);
136
+ },
137
+ ownKeys(target) {
138
+ return Object.keys(target);
139
+ },
140
+ has(target, key) {
141
+ return key in target;
142
+ }
143
+ });
144
+ return proxy;
145
+ }
146
+ exports.default = createProvider;
@@ -1,5 +1,14 @@
1
1
  import { Access, Scope } from '../enums';
2
- import type { PublicFunction, PublicProperty } from '../types';
2
+ import type { EventEmitter, PublicFunction, PublicProperty } from '../types';
3
+ /**
4
+ * Makes the event available for **renderer** and **preload** processes.
5
+ *
6
+ * _only for event_
7
+ * @param name - name by which the event will be accessed
8
+ * @param func - linked emitter
9
+ * @param scopes - event scopes
10
+ */
11
+ export declare function publicEvent<Emitter extends EventEmitter>(name: string, func?: Emitter, scopes?: Scope[]): (...args: Parameters<Emitter>) => void;
3
12
  /**
4
13
  * Makes the function available for **renderer** and **preload** processes.
5
14
  *
@@ -0,0 +1,167 @@
1
+ "use strict";
2
+ Object.defineProperty(exports, "__esModule", { value: true });
3
+ exports.addAccess = exports.addScope = exports.publicVariable = exports.publicFunction = exports.publicEvent = void 0;
4
+ const electron_1 = require("electron");
5
+ const enums_1 = require("../enums");
6
+ const publicInfo = {
7
+ properties: new Set(),
8
+ functions: new Set(),
9
+ events: new Set(),
10
+ accesses: {},
11
+ scopes: {}
12
+ };
13
+ electron_1.ipcMain.on(enums_1.IPCChannel.getPublicInfo, e => e.returnValue = publicInfo);
14
+ /**
15
+ * Makes the event available for **renderer** and **preload** processes.
16
+ *
17
+ * _only for event_
18
+ * @param name - name by which the event will be accessed
19
+ * @param func - linked emitter
20
+ * @param scopes - event scopes
21
+ */
22
+ function publicEvent(name, func = (() => { }), scopes = [enums_1.Scope.preload, enums_1.Scope.renderer]) {
23
+ const { events } = publicInfo;
24
+ const emitChannel = enums_1.IPCChannel.eventEmit + name;
25
+ const handleChannel = enums_1.IPCChannel.eventHandleOn + name;
26
+ const handleChannelOnce = enums_1.IPCChannel.eventHandleOnce + name;
27
+ let senders = [];
28
+ let sendersOnce = [];
29
+ events.add(name);
30
+ if (!publicInfo.scopes[name])
31
+ publicInfo.scopes[name] = new Set(scopes);
32
+ electron_1.ipcMain.removeAllListeners(handleChannel);
33
+ electron_1.ipcMain.removeAllListeners(handleChannelOnce);
34
+ electron_1.ipcMain.on(handleChannel, ({ sender }) => !senders.includes(sender) && senders.push(sender));
35
+ electron_1.ipcMain.on(handleChannelOnce, ({ sender }) => !sendersOnce.includes(sender) && sendersOnce.push(sender));
36
+ return (...args) => {
37
+ function filterSenders() {
38
+ senders = senders.filter(sender => !sender.isDestroyed());
39
+ sendersOnce = sendersOnce.filter(sender => !sender.isDestroyed());
40
+ }
41
+ filterSenders();
42
+ const allSenders = [...senders, ...sendersOnce];
43
+ try {
44
+ const result = func(...args);
45
+ if (result instanceof Promise) {
46
+ const promiseChannel = emitChannel + enums_1.IPCChannel.promisePostfix;
47
+ result
48
+ .then(value => {
49
+ filterSenders();
50
+ [...senders, ...sendersOnce].forEach(sender => sender.send(promiseChannel, { value }));
51
+ sendersOnce = [];
52
+ })
53
+ .catch(reason => {
54
+ filterSenders();
55
+ [...senders, ...sendersOnce].forEach(sender => sender.send(promiseChannel, { error: String(reason) }));
56
+ sendersOnce = [];
57
+ });
58
+ allSenders.forEach(sender => sender.send(promiseChannel, { promiseChannel }));
59
+ }
60
+ else {
61
+ allSenders.forEach(sender => sender.send(emitChannel, { value: result }));
62
+ sendersOnce = [];
63
+ }
64
+ }
65
+ catch (error) {
66
+ allSenders.forEach(sender => sender.send(emitChannel, { error: String(error) }));
67
+ sendersOnce = [];
68
+ }
69
+ };
70
+ }
71
+ exports.publicEvent = publicEvent;
72
+ /**
73
+ * Makes the function available for **renderer** and **preload** processes.
74
+ *
75
+ * _only for function_
76
+ * @param name - name by which the function will be accessed
77
+ * @param func - linked function
78
+ * @param scopes - function scopes
79
+ */
80
+ function publicFunction(name, func, scopes = [enums_1.Scope.preload, enums_1.Scope.renderer]) {
81
+ const { functions } = publicInfo;
82
+ const channel = enums_1.IPCChannel.functionCall + name;
83
+ functions.add(name);
84
+ if (!publicInfo.scopes[name])
85
+ publicInfo.scopes[name] = new Set(scopes);
86
+ electron_1.ipcMain.removeAllListeners(channel);
87
+ electron_1.ipcMain.on(channel, (e, ...args) => {
88
+ try {
89
+ const result = func(...args);
90
+ if (result instanceof Promise) {
91
+ const promiseChannel = channel + enums_1.IPCChannel.promisePostfix;
92
+ result
93
+ .then(value => e.sender.send(promiseChannel, { value }))
94
+ .catch(reason => e.sender.send(promiseChannel, { error: String(reason) }));
95
+ e.returnValue = { promiseChannel };
96
+ }
97
+ else {
98
+ e.returnValue = { value: result };
99
+ }
100
+ }
101
+ catch (error) {
102
+ e.returnValue = { error: String(error) };
103
+ }
104
+ });
105
+ }
106
+ exports.publicFunction = publicFunction;
107
+ /**
108
+ * Makes the function available for **renderer** and **preload** processes.
109
+ *
110
+ * _only for variables_
111
+ * @param name - name by which the variable will be accessed
112
+ * @param value - variable getter/setter
113
+ * @param scopes - variable scopes
114
+ */
115
+ function publicVariable(name, value, scopes = [enums_1.Scope.renderer, enums_1.Scope.preload]) {
116
+ const { properties } = publicInfo;
117
+ const getChannel = enums_1.IPCChannel.propertyGet + name;
118
+ const setChannel = enums_1.IPCChannel.propertySet + name;
119
+ const { get: getter, set: setter } = value;
120
+ properties.add(name);
121
+ if (!publicInfo.scopes[name])
122
+ publicInfo.scopes[name] = new Set(scopes);
123
+ if (!publicInfo.accesses[name]) {
124
+ const accesses = [];
125
+ getter && accesses.push(enums_1.Access.get);
126
+ setter && accesses.push(enums_1.Access.set);
127
+ publicInfo.accesses[name] = new Set(accesses);
128
+ }
129
+ else {
130
+ const accesses = publicInfo.accesses[name];
131
+ getter && accesses.add(enums_1.Access.get);
132
+ setter && accesses.add(enums_1.Access.set);
133
+ }
134
+ if (getter) {
135
+ electron_1.ipcMain.removeAllListeners(getChannel);
136
+ electron_1.ipcMain.on(getChannel, event => {
137
+ try {
138
+ const result = getter();
139
+ event.returnValue = { value: result };
140
+ }
141
+ catch (error) {
142
+ event.returnValue = { error };
143
+ }
144
+ });
145
+ }
146
+ if (setter) {
147
+ electron_1.ipcMain.removeAllListeners(setChannel);
148
+ electron_1.ipcMain.on(setChannel, (event, ...args) => {
149
+ try {
150
+ setter(args[0]);
151
+ event.returnValue = { value: null };
152
+ }
153
+ catch (error) {
154
+ event.returnValue = { error };
155
+ }
156
+ });
157
+ }
158
+ }
159
+ exports.publicVariable = publicVariable;
160
+ function addScope(key, scope) {
161
+ publicInfo.scopes[key] = new Set([scope]);
162
+ }
163
+ exports.addScope = addScope;
164
+ function addAccess(key, access) {
165
+ publicInfo.accesses[key] = new Set([access]);
166
+ }
167
+ exports.addAccess = addAccess;
@@ -18,6 +18,10 @@ export interface IPublishMethodArgs {
18
18
  name?: string;
19
19
  scope?: Scope;
20
20
  }
21
+ export interface IPublishEventArgs {
22
+ name?: string;
23
+ scope?: Scope;
24
+ }
21
25
  export interface IPublishPropertyArgs {
22
26
  name?: string;
23
27
  scope?: Scope;
@@ -26,6 +30,7 @@ export interface IPublishPropertyArgs {
26
30
  export interface ICreateProviderArgs {
27
31
  info: IInfo;
28
32
  scope: Scope;
33
+ handleEvent(name: string, type: 'on' | 'once', handler: EventHandler<IIPCResult>): EventUnsubscriber;
29
34
  callFunction(name: string, ...args: any[]): IIPCResult;
30
35
  getVariable(name: string): IIPCResult;
31
36
  setVariable(name: string, value: any): IIPCResult | undefined;
@@ -33,6 +38,10 @@ export interface ICreateProviderArgs {
33
38
  }
34
39
  export type Scopes = Record<string, Set<Scope>>;
35
40
  export type Accesses = Record<string, Set<Access>>;
41
+ export type MainEvent<T = undefined> = (handler: EventHandler<T>) => EventUnsubscriber;
42
+ export type EventEmitter = (...args: any[]) => any;
43
+ export type EventUnsubscriber = () => void;
44
+ export type EventHandler<T> = (result: T) => void;
36
45
  export interface IRendererPublic {
37
46
  __register__?(instance: any): void;
38
47
  }
@@ -41,6 +50,7 @@ export interface IProvider {
41
50
  waitPromise(name: string, resolve: (value: any) => void, reject?: (reason?: any) => void): void;
42
51
  provided: {
43
52
  functions: Record<string, (...args: any[]) => IIPCResult>;
53
+ events: Record<string, (type: 'on' | 'once', handler: EventHandler<IIPCResult>) => EventUnsubscriber>;
44
54
  properties: Record<string, IIPCResult>;
45
55
  };
46
56
  }
@@ -52,6 +62,7 @@ export type PublicProperty = {
52
62
  export interface IInfo {
53
63
  properties: Set<string>;
54
64
  functions: Set<string>;
65
+ events: Set<string>;
55
66
  scopes: Scopes;
56
67
  accesses: Accesses;
57
68
  }
package/cjs/types.js ADDED
@@ -0,0 +1,2 @@
1
+ "use strict";
2
+ Object.defineProperty(exports, "__esModule", { value: true });
package/esm/enums.d.ts ADDED
@@ -0,0 +1,18 @@
1
+ export declare enum Access {
2
+ get = "get",
3
+ set = "set"
4
+ }
5
+ export declare enum Scope {
6
+ renderer = "renderer",
7
+ preload = "preload"
8
+ }
9
+ export declare enum IPCChannel {
10
+ getPublicInfo = "GET_PUBLIC_INFO",
11
+ functionCall = "FUNCTION_CALL_",
12
+ eventHandleOn = "EVENT_HANDLE_ON_",
13
+ eventHandleOnce = "EVENT_HANDLE_ONCE_",
14
+ eventEmit = "EVENT_EMIT_",
15
+ propertyGet = "PROPERTY_GET_",
16
+ propertySet = "PROPERTY_SET_",
17
+ promisePostfix = "_PROMISE"
18
+ }
@@ -12,6 +12,9 @@ export var IPCChannel;
12
12
  (function (IPCChannel) {
13
13
  IPCChannel["getPublicInfo"] = "GET_PUBLIC_INFO";
14
14
  IPCChannel["functionCall"] = "FUNCTION_CALL_";
15
+ IPCChannel["eventHandleOn"] = "EVENT_HANDLE_ON_";
16
+ IPCChannel["eventHandleOnce"] = "EVENT_HANDLE_ONCE_";
17
+ IPCChannel["eventEmit"] = "EVENT_EMIT_";
15
18
  IPCChannel["propertyGet"] = "PROPERTY_GET_";
16
19
  IPCChannel["propertySet"] = "PROPERTY_SET_";
17
20
  IPCChannel["promisePostfix"] = "_PROMISE";
package/esm/exp.d.ts ADDED
@@ -0,0 +1,4 @@
1
+ export { Access, Scope } from './enums';
2
+ export { providePublic, publicClassEvent, publicMethod, publicProperty, publicStaticEvent, publicStaticMethod, publicStaticProperty } from './scripts/oldDecorators';
3
+ export { publicEvent, publicFunction, publicVariable } from './scripts/publish';
4
+ export type { EventEmitter, EventHandler, EventUnsubscriber, IPublishEventArgs, IPublishMethodArgs, IPublishPropertyArgs, MainEvent, PublicFunction, PublicProperty } from './types';
package/esm/exp.js ADDED
@@ -0,0 +1,3 @@
1
+ export { Access, Scope } from './enums';
2
+ export { providePublic, publicClassEvent, publicMethod, publicProperty, publicStaticEvent, publicStaticMethod, publicStaticProperty } from './scripts/oldDecorators';
3
+ export { publicEvent, publicFunction, publicVariable } from './scripts/publish';
package/esm/index.d.ts ADDED
@@ -0,0 +1,4 @@
1
+ export { Access, Scope } from './enums';
2
+ export { publicClassEvent, publicGetter, publicMethod, publicProperty, publicSetter } from './scripts/newDecorators';
3
+ export { publicEvent, publicFunction, publicVariable } from './scripts/publish';
4
+ export type { EventEmitter, EventHandler, EventUnsubscriber, IPublishEventArgs, IPublishMethodArgs, IPublishPropertyArgs, MainEvent, PublicFunction, PublicProperty } from './types';
package/esm/index.js ADDED
@@ -0,0 +1,3 @@
1
+ export { Access, Scope } from './enums';
2
+ export { publicClassEvent, publicGetter, publicMethod, publicProperty, publicSetter } from './scripts/newDecorators';
3
+ export { publicEvent, publicFunction, publicVariable } from './scripts/publish';
package/esm/preload.js ADDED
@@ -0,0 +1,2 @@
1
+ export { default as Main } from './scripts/Main';
2
+ export { default as provideFromMain } from './scripts/preloadProvider';
@@ -0,0 +1 @@
1
+ export { default as Bridge } from './scripts/Bridge';
@@ -0,0 +1,7 @@
1
+ /**
2
+ * Bridge between `renderer` and `main` processes.
3
+ *
4
+ * _only for renderer process_
5
+ */
6
+ declare const Bridge: import("../types").ITarget;
7
+ export default Bridge;
@@ -15,6 +15,9 @@ const Bridge = createProvider({
15
15
  callFunction(name, ...args) {
16
16
  return provider.provided.functions[name](...args);
17
17
  },
18
+ handleEvent(name, type, handler) {
19
+ return provider.provided.events[name](type, handler);
20
+ },
18
21
  getVariable(name) {
19
22
  return provider.provided.properties[name];
20
23
  },
@@ -0,0 +1,7 @@
1
+ /**
2
+ * Bridge between `preload` and `main` processes.
3
+ *
4
+ * _only for preload process_
5
+ */
6
+ declare const Main: import("../types").ITarget;
7
+ export default Main;
@@ -15,6 +15,19 @@ const Main = createProvider({
15
15
  callFunction(name, ...args) {
16
16
  return ipcRenderer.sendSync(IPCChannel.functionCall + name, ...args);
17
17
  },
18
+ handleEvent(name, type, handler) {
19
+ const listener = (_, result) => handler(result);
20
+ const emitChannel = IPCChannel.eventEmit + name;
21
+ if (type === 'on') {
22
+ ipcRenderer.send(IPCChannel.eventHandleOn + name);
23
+ ipcRenderer.on(emitChannel, listener);
24
+ }
25
+ else {
26
+ ipcRenderer.send(IPCChannel.eventHandleOnce + name);
27
+ ipcRenderer.once(emitChannel, listener);
28
+ }
29
+ return () => ipcRenderer.removeListener(emitChannel, listener);
30
+ },
18
31
  getVariable(name) {
19
32
  return ipcRenderer.sendSync(IPCChannel.propertyGet + name);
20
33
  },