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.
- package/LICENCE +1 -1
- package/README.md +22 -22
- package/{lib → cjs}/enums.d.ts +3 -0
- package/cjs/enums.js +24 -0
- package/cjs/exp.d.ts +4 -0
- package/cjs/exp.js +18 -0
- package/cjs/index.d.ts +4 -0
- package/cjs/index.js +16 -0
- package/cjs/preload.js +10 -0
- package/cjs/renderer.js +8 -0
- package/cjs/scripts/Bridge.js +39 -0
- package/cjs/scripts/Main.js +53 -0
- package/{lib → cjs}/scripts/newDecorators.d.ts +21 -1
- package/cjs/scripts/newDecorators.js +116 -0
- package/{lib → cjs}/scripts/oldDecorators.d.ts +59 -1
- package/cjs/scripts/oldDecorators.js +111 -0
- package/cjs/scripts/preloadProvider.js +72 -0
- package/cjs/scripts/provider.js +146 -0
- package/{lib → cjs}/scripts/publish.d.ts +10 -1
- package/cjs/scripts/publish.js +167 -0
- package/{lib → cjs}/types.d.ts +11 -0
- package/cjs/types.js +2 -0
- package/esm/enums.d.ts +18 -0
- package/{lib → esm}/enums.js +3 -0
- package/esm/exp.d.ts +4 -0
- package/esm/exp.js +3 -0
- package/esm/index.d.ts +4 -0
- package/esm/index.js +3 -0
- package/esm/preload.js +2 -0
- package/esm/renderer.js +1 -0
- package/esm/scripts/Bridge.d.ts +7 -0
- package/{lib → esm}/scripts/Bridge.js +3 -0
- package/esm/scripts/Main.d.ts +7 -0
- package/{lib → esm}/scripts/Main.js +13 -0
- package/esm/scripts/newDecorators.d.ts +101 -0
- package/{lib → esm}/scripts/newDecorators.js +20 -1
- package/esm/scripts/oldDecorators.d.ts +181 -0
- package/{lib → esm}/scripts/oldDecorators.js +27 -1
- package/esm/scripts/preloadProvider.d.ts +7 -0
- package/{lib → esm}/scripts/preloadProvider.js +20 -1
- package/esm/scripts/provider.d.ts +3 -0
- package/{lib → esm}/scripts/provider.js +45 -1
- package/esm/scripts/publish.d.ts +31 -0
- package/{lib → esm}/scripts/publish.js +58 -0
- package/esm/types.d.ts +68 -0
- package/package.json +48 -16
- package/lib/index.d.ts +0 -5
- package/lib/index.js +0 -4
- /package/{lib → cjs}/preload.d.ts +0 -0
- /package/{lib → cjs}/renderer.d.ts +0 -0
- /package/{lib → cjs}/scripts/Bridge.d.ts +0 -0
- /package/{lib → cjs}/scripts/Main.d.ts +0 -0
- /package/{lib → cjs}/scripts/preloadProvider.d.ts +0 -0
- /package/{lib → cjs}/scripts/provider.d.ts +0 -0
- /package/{lib/preload.js → esm/preload.d.ts} +0 -0
- /package/{lib/renderer.js → esm/renderer.d.ts} +0 -0
- /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;
|
package/{lib → cjs}/types.d.ts
RENAMED
|
@@ -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
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
|
+
}
|
package/{lib → esm}/enums.js
RENAMED
|
@@ -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
package/esm/preload.js
ADDED
package/esm/renderer.js
ADDED
|
@@ -0,0 +1 @@
|
|
|
1
|
+
export { default as Bridge } from './scripts/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
|
},
|
|
@@ -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
|
},
|