emr-bridge 1.6.2 → 1.7.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/cjs/errors.d.ts +28 -0
- package/cjs/errors.js +39 -0
- package/cjs/exp.d.ts +4 -4
- package/cjs/exp.js +16 -16
- package/cjs/index.d.ts +4 -4
- package/cjs/index.js +15 -15
- package/cjs/main.d.ts +4 -4
- package/cjs/main.js +15 -15
- package/cjs/preload.d.ts +3 -3
- package/cjs/preload.js +4 -4
- package/cjs/renderer.d.ts +2 -2
- package/cjs/renderer.js +2 -2
- package/cjs/scripts/{Bridge.d.ts → bridge.d.ts} +2 -2
- package/cjs/scripts/bridge.js +57 -0
- package/{esm/scripts/Main.d.ts → cjs/scripts/main.d.ts} +2 -2
- package/cjs/scripts/main.js +72 -0
- package/cjs/scripts/{newDecorators.d.ts → new-decorators.d.ts} +5 -5
- package/cjs/scripts/{newDecorators.js → new-decorators.js} +14 -14
- package/cjs/scripts/{oldDecorators.d.ts → old-decorators.d.ts} +7 -7
- package/cjs/scripts/{oldDecorators.js → old-decorators.js} +10 -10
- package/cjs/scripts/preload-provider.js +96 -0
- package/cjs/scripts/provider.d.ts +25 -3
- package/cjs/scripts/provider.js +97 -93
- package/cjs/scripts/publish.d.ts +2 -2
- package/cjs/scripts/publish.js +36 -33
- package/cjs/scripts/renderer-tunnels.d.ts +47 -0
- package/cjs/scripts/renderer-tunnels.js +115 -0
- package/cjs/types.d.ts +32 -39
- package/esm/errors.d.ts +28 -0
- package/esm/errors.js +27 -0
- package/esm/exp.d.ts +4 -4
- package/esm/exp.js +3 -3
- package/esm/index.d.ts +4 -4
- package/esm/index.js +3 -3
- package/esm/main.d.ts +4 -4
- package/esm/main.js +3 -3
- package/esm/preload.d.ts +3 -3
- package/esm/preload.js +2 -2
- package/esm/renderer.d.ts +2 -2
- package/esm/renderer.js +1 -1
- package/esm/scripts/{Bridge.d.ts → bridge.d.ts} +2 -2
- package/esm/scripts/bridge.js +52 -0
- package/{cjs/scripts/Main.d.ts → esm/scripts/main.d.ts} +2 -2
- package/esm/scripts/main.js +67 -0
- package/esm/scripts/{newDecorators.d.ts → new-decorators.d.ts} +5 -5
- package/esm/scripts/{newDecorators.js → new-decorators.js} +1 -1
- package/esm/scripts/{oldDecorators.d.ts → old-decorators.d.ts} +7 -7
- package/esm/scripts/{oldDecorators.js → old-decorators.js} +1 -1
- package/esm/scripts/preload-provider.js +91 -0
- package/esm/scripts/provider.d.ts +25 -3
- package/esm/scripts/provider.js +96 -93
- package/esm/scripts/publish.d.ts +2 -2
- package/esm/scripts/publish.js +19 -16
- package/esm/scripts/renderer-tunnels.d.ts +47 -0
- package/esm/scripts/renderer-tunnels.js +109 -0
- package/esm/types.d.ts +32 -39
- package/package.json +2 -1
- package/cjs/scripts/Bridge.js +0 -58
- package/cjs/scripts/Main.js +0 -85
- package/cjs/scripts/preloadProvider.js +0 -92
- package/esm/scripts/Bridge.js +0 -53
- package/esm/scripts/Main.js +0 -80
- package/esm/scripts/preloadProvider.js +0 -87
- /package/cjs/scripts/{preloadProvider.d.ts → preload-provider.d.ts} +0 -0
- /package/esm/scripts/{preloadProvider.d.ts → preload-provider.d.ts} +0 -0
package/esm/types.d.ts
CHANGED
|
@@ -1,81 +1,74 @@
|
|
|
1
1
|
import type { Scope } from './enums';
|
|
2
2
|
import { Access } from './enums';
|
|
3
|
-
export interface
|
|
3
|
+
export interface Target {
|
|
4
4
|
as<T>(): T;
|
|
5
5
|
}
|
|
6
6
|
export type ClassMethodDecorator = <This, Args extends any[], Return>(method: (this: This, ...args: Args) => Return, context: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Return>) => void;
|
|
7
|
-
export type ClassPropertyDecorator = <This,
|
|
8
|
-
export type ClassGetterDecorator = <This,
|
|
9
|
-
export type ClassSetterDecorator = <This,
|
|
10
|
-
export type PublishSetterArgs = Omit<
|
|
11
|
-
export type PublishGetterArgs = Omit<
|
|
12
|
-
export interface
|
|
7
|
+
export type ClassPropertyDecorator = <This, Value>(target: undefined, context: ClassFieldDecoratorContext<This, Value>) => void;
|
|
8
|
+
export type ClassGetterDecorator = <This, Value>(getter: () => Value, context: ClassGetterDecoratorContext<This, Value>) => void;
|
|
9
|
+
export type ClassSetterDecorator = <This, Value>(setter: (value: Value) => void, context: ClassSetterDecoratorContext<This, Value>) => void;
|
|
10
|
+
export type PublishSetterArgs = Omit<PublishPropertyArgs, 'access'>;
|
|
11
|
+
export type PublishGetterArgs = Omit<PublishPropertyArgs, 'access'>;
|
|
12
|
+
export interface IPCResult {
|
|
13
13
|
value?: any;
|
|
14
14
|
error?: string;
|
|
15
15
|
promiseChannel?: string;
|
|
16
|
+
secret?: number;
|
|
16
17
|
}
|
|
17
|
-
export interface
|
|
18
|
+
export interface IPCRequest {
|
|
19
|
+
args: any[];
|
|
20
|
+
secret?: number;
|
|
21
|
+
}
|
|
22
|
+
export interface PublishMethodArgs {
|
|
18
23
|
name?: string;
|
|
19
24
|
scope?: Scope;
|
|
20
25
|
}
|
|
21
|
-
export interface
|
|
26
|
+
export interface PublishMainEventArgs {
|
|
22
27
|
name?: string;
|
|
23
28
|
scope?: Scope;
|
|
24
29
|
}
|
|
25
|
-
export interface
|
|
30
|
+
export interface PublishRendererEventArgs {
|
|
26
31
|
name?: string;
|
|
27
32
|
scope?: Scope;
|
|
28
33
|
procFn?: EventReceiver;
|
|
29
34
|
}
|
|
30
|
-
export interface
|
|
35
|
+
export interface PublishPropertyArgs {
|
|
31
36
|
name?: string;
|
|
32
37
|
scope?: Scope;
|
|
33
38
|
access?: Access;
|
|
34
39
|
}
|
|
35
|
-
export interface ICreateProviderArgs {
|
|
36
|
-
info: IInfo;
|
|
37
|
-
scope: Scope;
|
|
38
|
-
handleMainEvent(name: string, type: 'on' | 'once', handler: EventHandler<IIPCResult>): EventUnsubscriber;
|
|
39
|
-
emitRendererEvent(name: string, arg: any): void;
|
|
40
|
-
callFunction(name: string, ...args: any[]): IIPCResult;
|
|
41
|
-
getVariable(name: string): IIPCResult;
|
|
42
|
-
setVariable(name: string, value: any): IIPCResult | undefined;
|
|
43
|
-
waitPromise(channel: string): Promise<any>;
|
|
44
|
-
}
|
|
45
|
-
export type Scopes = Map<string, Set<Scope>>;
|
|
46
|
-
export type Accesses = Map<string, Set<Access>>;
|
|
47
40
|
export type RendererEvent<T = void> = (handler: EventHandler<T>, isOnce?: boolean) => EventUnsubscriber;
|
|
48
41
|
export type MainEvent<T = void> = (handler: EventHandler<T>) => EventUnsubscriber;
|
|
49
42
|
export type EventEmitter = (...args: any[]) => any;
|
|
50
43
|
export type EventReceiver<I = void, O = I> = (input: I) => O;
|
|
51
44
|
export type EventUnsubscriber = () => void;
|
|
52
45
|
export type EventHandler<T = void> = (result: T) => void;
|
|
53
|
-
export
|
|
46
|
+
export type PublicFunction = (...args: any[]) => any;
|
|
47
|
+
export interface PublicProperty<T> {
|
|
48
|
+
get?(): T;
|
|
49
|
+
set?(value: T): void;
|
|
50
|
+
}
|
|
51
|
+
export interface RendererPublic {
|
|
54
52
|
__register__?(instance: any): void;
|
|
55
53
|
}
|
|
56
|
-
export interface
|
|
57
|
-
getInfo():
|
|
58
|
-
waitPromise(name: string, resolve: (value: any) => void, reject?: (reason?: any) => void): void;
|
|
54
|
+
export interface GlobalProvider {
|
|
55
|
+
getInfo(): Info;
|
|
56
|
+
waitPromise(name: string, resolve: (value: any) => void, reject?: (reason?: any) => void, secret?: number): void;
|
|
59
57
|
provided: {
|
|
60
|
-
functions: Record<string, (
|
|
61
|
-
mainEvents: Record<string, (type: 'on' | 'once', handler: EventHandler<
|
|
58
|
+
functions: Record<string, (secret: number, args: any[]) => IPCResult>;
|
|
59
|
+
mainEvents: Record<string, (type: 'on' | 'once', handler: EventHandler<IPCResult>) => EventUnsubscriber>;
|
|
62
60
|
rendererEvents: Record<string, (arg: any) => void>;
|
|
63
61
|
properties: Record<string, {
|
|
64
|
-
get():
|
|
65
|
-
set(val: any):
|
|
62
|
+
get(): IPCResult;
|
|
63
|
+
set(val: any): IPCResult;
|
|
66
64
|
}>;
|
|
67
65
|
};
|
|
68
66
|
}
|
|
69
|
-
export
|
|
70
|
-
export type PublicProperty<T> = {
|
|
71
|
-
get?(): T;
|
|
72
|
-
set?(value: T): void;
|
|
73
|
-
};
|
|
74
|
-
export interface IInfo {
|
|
67
|
+
export interface Info {
|
|
75
68
|
properties: Set<string>;
|
|
76
69
|
functions: Set<string>;
|
|
77
70
|
mainEvents: Set<string>;
|
|
78
71
|
rendererEvents: Set<string>;
|
|
79
|
-
scopes:
|
|
80
|
-
accesses:
|
|
72
|
+
scopes: Map<string, Set<Scope>>;
|
|
73
|
+
accesses: Map<string, Set<Access>>;
|
|
81
74
|
}
|
package/package.json
CHANGED
|
@@ -1,8 +1,9 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "emr-bridge",
|
|
3
|
-
"version": "1.
|
|
3
|
+
"version": "1.7.1",
|
|
4
4
|
"description": "Allows you to easily give access to main methods from the renderer process",
|
|
5
5
|
"main": "esm/index.js",
|
|
6
|
+
"type": "module",
|
|
6
7
|
"scripts": {
|
|
7
8
|
"compile": "tsc --project ./tsconfig.json && tsc --project ./tsconfig.cjs.json"
|
|
8
9
|
},
|
package/cjs/scripts/Bridge.js
DELETED
|
@@ -1,58 +0,0 @@
|
|
|
1
|
-
"use strict";
|
|
2
|
-
var __importDefault = (this && this.__importDefault) || function (mod) {
|
|
3
|
-
return (mod && mod.__esModule) ? mod : { "default": mod };
|
|
4
|
-
};
|
|
5
|
-
Object.defineProperty(exports, "__esModule", { value: true });
|
|
6
|
-
const enums_1 = require("../enums");
|
|
7
|
-
const provider_1 = __importDefault(require("./provider"));
|
|
8
|
-
/**
|
|
9
|
-
* Bridge between `renderer` and `main` processes.
|
|
10
|
-
*
|
|
11
|
-
* _only for renderer process_
|
|
12
|
-
*/
|
|
13
|
-
let Bridge = new Proxy({ as() { throwError(); } }, {
|
|
14
|
-
get() { throwError(); },
|
|
15
|
-
set() { throwError(); },
|
|
16
|
-
apply() { throwError(); }
|
|
17
|
-
});
|
|
18
|
-
/** Выбрасывает ошибку если используется не в том процессе */
|
|
19
|
-
let throwError;
|
|
20
|
-
if (typeof window === 'undefined') {
|
|
21
|
-
throwError = () => { throw new Error('"Bridge" is unavailable in main process. In preload use "Main" instead.'); };
|
|
22
|
-
}
|
|
23
|
-
else if (!window.__provider__) {
|
|
24
|
-
throwError = () => { throw new Error('Required methods not provided. Call "provideFromMain" in preload process.'); };
|
|
25
|
-
}
|
|
26
|
-
else {
|
|
27
|
-
initInWeb();
|
|
28
|
-
}
|
|
29
|
-
/** Выполняется только в web */
|
|
30
|
-
function initInWeb() {
|
|
31
|
-
const provider = window.__provider__;
|
|
32
|
-
const info = provider.getInfo();
|
|
33
|
-
Bridge = (0, provider_1.default)({
|
|
34
|
-
info, scope: enums_1.Scope.renderer,
|
|
35
|
-
callFunction(name, ...args) {
|
|
36
|
-
return provider.provided.functions[name](...args);
|
|
37
|
-
},
|
|
38
|
-
emitRendererEvent(name, arg) {
|
|
39
|
-
provider.provided.rendererEvents[name](arg);
|
|
40
|
-
},
|
|
41
|
-
handleMainEvent(name, type, handler) {
|
|
42
|
-
return provider.provided.mainEvents[name](type, handler);
|
|
43
|
-
},
|
|
44
|
-
getVariable(name) {
|
|
45
|
-
return provider.provided.properties[name].get();
|
|
46
|
-
},
|
|
47
|
-
setVariable(name, value) {
|
|
48
|
-
provider.provided.properties[name].set(value);
|
|
49
|
-
return undefined;
|
|
50
|
-
},
|
|
51
|
-
waitPromise(channel) {
|
|
52
|
-
return new Promise((resolve, reject) => {
|
|
53
|
-
provider.waitPromise(channel, resolve, reject);
|
|
54
|
-
});
|
|
55
|
-
}
|
|
56
|
-
});
|
|
57
|
-
}
|
|
58
|
-
exports.default = Bridge;
|
package/cjs/scripts/Main.js
DELETED
|
@@ -1,85 +0,0 @@
|
|
|
1
|
-
"use strict";
|
|
2
|
-
var __importDefault = (this && this.__importDefault) || function (mod) {
|
|
3
|
-
return (mod && mod.__esModule) ? mod : { "default": mod };
|
|
4
|
-
};
|
|
5
|
-
Object.defineProperty(exports, "__esModule", { value: true });
|
|
6
|
-
const electron_1 = __importDefault(require("electron"));
|
|
7
|
-
const enums_1 = require("../enums");
|
|
8
|
-
const provider_1 = __importDefault(require("./provider"));
|
|
9
|
-
/**
|
|
10
|
-
* Bridge between `preload` and `main` processes.
|
|
11
|
-
*
|
|
12
|
-
* _only for preload process_
|
|
13
|
-
*/
|
|
14
|
-
let Main = new Proxy({ as() { throwError(); } }, {
|
|
15
|
-
get() { throwError(); },
|
|
16
|
-
set() { throwError(); },
|
|
17
|
-
apply() { throwError(); }
|
|
18
|
-
});
|
|
19
|
-
/** Выбрасывает ошибку если используется не в том процессе */
|
|
20
|
-
let throwError;
|
|
21
|
-
if (typeof window !== 'undefined') {
|
|
22
|
-
throwError = () => { throw new Error('"Main" is unavailable in renderer process. Use "Bridge" instead'); };
|
|
23
|
-
}
|
|
24
|
-
else if (!('ipcRenderer' in electron_1.default)) {
|
|
25
|
-
throwError = () => { throw new Error('"Main" is unavailable in main process.'); };
|
|
26
|
-
}
|
|
27
|
-
else {
|
|
28
|
-
initInNode();
|
|
29
|
-
}
|
|
30
|
-
/** Выполняется только в NodeJS */
|
|
31
|
-
function initInNode() {
|
|
32
|
-
const { ipcRenderer } = electron_1.default;
|
|
33
|
-
const info = ipcRenderer.sendSync(enums_1.IPCChannel.getPublicInfo);
|
|
34
|
-
if (!info)
|
|
35
|
-
throw new Error('Public methods from main is not provided. Call any publish methods to provide it from main process.');
|
|
36
|
-
Main = (0, provider_1.default)({
|
|
37
|
-
info, scope: enums_1.Scope.preload,
|
|
38
|
-
callFunction(name, ...args) {
|
|
39
|
-
return ipcRenderer.sendSync(enums_1.IPCChannel.functionCall + name, ...args);
|
|
40
|
-
},
|
|
41
|
-
handleMainEvent(name, type, handler) {
|
|
42
|
-
const listener = (_, result) => handler(result);
|
|
43
|
-
const emitChannel = enums_1.IPCChannel.mainEventEmit + name;
|
|
44
|
-
if (type === 'on') {
|
|
45
|
-
ipcRenderer.send(enums_1.IPCChannel.mainEventOn + name);
|
|
46
|
-
ipcRenderer.on(emitChannel, listener);
|
|
47
|
-
}
|
|
48
|
-
else {
|
|
49
|
-
ipcRenderer.send(enums_1.IPCChannel.mainEventOnce + name);
|
|
50
|
-
ipcRenderer.once(emitChannel, listener);
|
|
51
|
-
}
|
|
52
|
-
return () => ipcRenderer.removeListener(emitChannel, listener);
|
|
53
|
-
},
|
|
54
|
-
emitRendererEvent(name, arg) {
|
|
55
|
-
const emitChannel = enums_1.IPCChannel.rendererEventEmit + name;
|
|
56
|
-
if (arg instanceof Promise) {
|
|
57
|
-
const promiseChannel = emitChannel + enums_1.IPCChannel.promisePostfix;
|
|
58
|
-
ipcRenderer.sendSync(emitChannel, { promiseChannel });
|
|
59
|
-
arg
|
|
60
|
-
.then(value => ipcRenderer.send(promiseChannel, { value }))
|
|
61
|
-
.catch(reason => ipcRenderer.send(promiseChannel, { error: String(reason?.stack || reason) }));
|
|
62
|
-
}
|
|
63
|
-
else {
|
|
64
|
-
ipcRenderer.send(emitChannel, { value: arg });
|
|
65
|
-
}
|
|
66
|
-
},
|
|
67
|
-
getVariable(name) {
|
|
68
|
-
return ipcRenderer.sendSync(enums_1.IPCChannel.propertyGet + name);
|
|
69
|
-
},
|
|
70
|
-
setVariable(name, value) {
|
|
71
|
-
return ipcRenderer.sendSync(enums_1.IPCChannel.propertySet + name, value);
|
|
72
|
-
},
|
|
73
|
-
waitPromise(channel) {
|
|
74
|
-
return new Promise((resolve, reject) => {
|
|
75
|
-
ipcRenderer.once(channel, (_, result) => {
|
|
76
|
-
if (result.error)
|
|
77
|
-
reject(result.error);
|
|
78
|
-
else
|
|
79
|
-
resolve(result.value);
|
|
80
|
-
});
|
|
81
|
-
});
|
|
82
|
-
}
|
|
83
|
-
});
|
|
84
|
-
}
|
|
85
|
-
exports.default = Main;
|
|
@@ -1,92 +0,0 @@
|
|
|
1
|
-
"use strict";
|
|
2
|
-
var __importDefault = (this && this.__importDefault) || function (mod) {
|
|
3
|
-
return (mod && mod.__esModule) ? mod : { "default": mod };
|
|
4
|
-
};
|
|
5
|
-
Object.defineProperty(exports, "__esModule", { value: true });
|
|
6
|
-
const electron_1 = __importDefault(require("electron"));
|
|
7
|
-
const enums_1 = require("../enums");
|
|
8
|
-
/** Выбрасывает ошибку если используется не в том процессе */
|
|
9
|
-
let mayThrowError = () => { };
|
|
10
|
-
if (typeof window === 'undefined') {
|
|
11
|
-
mayThrowError = () => { throw new Error('"provideFromMain" is unavailable in main process.'); };
|
|
12
|
-
}
|
|
13
|
-
else if (!('contextBridge' in electron_1.default)) {
|
|
14
|
-
mayThrowError = () => { throw new Error('"provideFromMain" is unavailable in renderer process.'); };
|
|
15
|
-
}
|
|
16
|
-
/**
|
|
17
|
-
* Sets access to main from renderer
|
|
18
|
-
*
|
|
19
|
-
* @param contextIsolation - _default_: `true`
|
|
20
|
-
*/
|
|
21
|
-
function provideFromMain(contextIsolation = true) {
|
|
22
|
-
mayThrowError();
|
|
23
|
-
const { contextBridge, ipcRenderer } = electron_1.default;
|
|
24
|
-
const info = ipcRenderer.sendSync(enums_1.IPCChannel.getPublicInfo);
|
|
25
|
-
const provider = {
|
|
26
|
-
getInfo() {
|
|
27
|
-
return info;
|
|
28
|
-
},
|
|
29
|
-
waitPromise(channel, resolve, reject) {
|
|
30
|
-
ipcRenderer.once(channel, (_, result) => {
|
|
31
|
-
if (result.error)
|
|
32
|
-
reject?.(result.error);
|
|
33
|
-
else
|
|
34
|
-
resolve(result.value);
|
|
35
|
-
});
|
|
36
|
-
},
|
|
37
|
-
provided: {
|
|
38
|
-
properties: {},
|
|
39
|
-
functions: {},
|
|
40
|
-
mainEvents: {},
|
|
41
|
-
rendererEvents: {},
|
|
42
|
-
}
|
|
43
|
-
};
|
|
44
|
-
info.functions.forEach(funcName => {
|
|
45
|
-
provider.provided.functions[funcName] = (...args) => {
|
|
46
|
-
return ipcRenderer.sendSync(enums_1.IPCChannel.functionCall + funcName, ...args);
|
|
47
|
-
};
|
|
48
|
-
});
|
|
49
|
-
info.rendererEvents.forEach(eventName => {
|
|
50
|
-
provider.provided.rendererEvents[eventName] = (arg) => {
|
|
51
|
-
const emitChannel = enums_1.IPCChannel.rendererEventEmit + eventName;
|
|
52
|
-
if (arg instanceof Promise) {
|
|
53
|
-
arg
|
|
54
|
-
.then(value => ipcRenderer.send(emitChannel, { value }))
|
|
55
|
-
.catch(reason => ipcRenderer.send(emitChannel, { error: String(reason) }));
|
|
56
|
-
}
|
|
57
|
-
else {
|
|
58
|
-
ipcRenderer.send(emitChannel, { value: arg });
|
|
59
|
-
}
|
|
60
|
-
};
|
|
61
|
-
});
|
|
62
|
-
info.mainEvents.forEach(eventName => {
|
|
63
|
-
provider.provided.mainEvents[eventName] = (type, handler) => {
|
|
64
|
-
const listener = (_, result) => handler(result);
|
|
65
|
-
const emitChannel = enums_1.IPCChannel.mainEventEmit + eventName;
|
|
66
|
-
if (type === 'on') {
|
|
67
|
-
ipcRenderer.on(emitChannel, listener);
|
|
68
|
-
ipcRenderer.send(enums_1.IPCChannel.mainEventOn + eventName);
|
|
69
|
-
}
|
|
70
|
-
else {
|
|
71
|
-
ipcRenderer.once(emitChannel, listener);
|
|
72
|
-
ipcRenderer.send(enums_1.IPCChannel.mainEventOnce + eventName);
|
|
73
|
-
}
|
|
74
|
-
return () => ipcRenderer.removeListener(emitChannel, listener);
|
|
75
|
-
};
|
|
76
|
-
});
|
|
77
|
-
info.properties.forEach(propName => {
|
|
78
|
-
provider.provided.properties[propName] = {
|
|
79
|
-
get() {
|
|
80
|
-
return ipcRenderer.sendSync(enums_1.IPCChannel.propertyGet + propName);
|
|
81
|
-
},
|
|
82
|
-
set(value) {
|
|
83
|
-
ipcRenderer.sendSync(enums_1.IPCChannel.propertySet + propName, value);
|
|
84
|
-
}
|
|
85
|
-
};
|
|
86
|
-
});
|
|
87
|
-
if (contextIsolation)
|
|
88
|
-
contextBridge.exposeInMainWorld('__provider__', provider);
|
|
89
|
-
else
|
|
90
|
-
window.__provider__ = provider;
|
|
91
|
-
}
|
|
92
|
-
exports.default = provideFromMain;
|
package/esm/scripts/Bridge.js
DELETED
|
@@ -1,53 +0,0 @@
|
|
|
1
|
-
import { Scope } from '../enums';
|
|
2
|
-
import createProvider from './provider';
|
|
3
|
-
/**
|
|
4
|
-
* Bridge between `renderer` and `main` processes.
|
|
5
|
-
*
|
|
6
|
-
* _only for renderer process_
|
|
7
|
-
*/
|
|
8
|
-
let Bridge = new Proxy({ as() { throwError(); } }, {
|
|
9
|
-
get() { throwError(); },
|
|
10
|
-
set() { throwError(); },
|
|
11
|
-
apply() { throwError(); }
|
|
12
|
-
});
|
|
13
|
-
/** Выбрасывает ошибку если используется не в том процессе */
|
|
14
|
-
let throwError;
|
|
15
|
-
if (typeof window === 'undefined') {
|
|
16
|
-
throwError = () => { throw new Error('"Bridge" is unavailable in main process. In preload use "Main" instead.'); };
|
|
17
|
-
}
|
|
18
|
-
else if (!window.__provider__) {
|
|
19
|
-
throwError = () => { throw new Error('Required methods not provided. Call "provideFromMain" in preload process.'); };
|
|
20
|
-
}
|
|
21
|
-
else {
|
|
22
|
-
initInWeb();
|
|
23
|
-
}
|
|
24
|
-
/** Выполняется только в web */
|
|
25
|
-
function initInWeb() {
|
|
26
|
-
const provider = window.__provider__;
|
|
27
|
-
const info = provider.getInfo();
|
|
28
|
-
Bridge = createProvider({
|
|
29
|
-
info, scope: Scope.renderer,
|
|
30
|
-
callFunction(name, ...args) {
|
|
31
|
-
return provider.provided.functions[name](...args);
|
|
32
|
-
},
|
|
33
|
-
emitRendererEvent(name, arg) {
|
|
34
|
-
provider.provided.rendererEvents[name](arg);
|
|
35
|
-
},
|
|
36
|
-
handleMainEvent(name, type, handler) {
|
|
37
|
-
return provider.provided.mainEvents[name](type, handler);
|
|
38
|
-
},
|
|
39
|
-
getVariable(name) {
|
|
40
|
-
return provider.provided.properties[name].get();
|
|
41
|
-
},
|
|
42
|
-
setVariable(name, value) {
|
|
43
|
-
provider.provided.properties[name].set(value);
|
|
44
|
-
return undefined;
|
|
45
|
-
},
|
|
46
|
-
waitPromise(channel) {
|
|
47
|
-
return new Promise((resolve, reject) => {
|
|
48
|
-
provider.waitPromise(channel, resolve, reject);
|
|
49
|
-
});
|
|
50
|
-
}
|
|
51
|
-
});
|
|
52
|
-
}
|
|
53
|
-
export default Bridge;
|
package/esm/scripts/Main.js
DELETED
|
@@ -1,80 +0,0 @@
|
|
|
1
|
-
import electron from 'electron';
|
|
2
|
-
import { IPCChannel, Scope } from '../enums';
|
|
3
|
-
import createProvider from './provider';
|
|
4
|
-
/**
|
|
5
|
-
* Bridge between `preload` and `main` processes.
|
|
6
|
-
*
|
|
7
|
-
* _only for preload process_
|
|
8
|
-
*/
|
|
9
|
-
let Main = new Proxy({ as() { throwError(); } }, {
|
|
10
|
-
get() { throwError(); },
|
|
11
|
-
set() { throwError(); },
|
|
12
|
-
apply() { throwError(); }
|
|
13
|
-
});
|
|
14
|
-
/** Выбрасывает ошибку если используется не в том процессе */
|
|
15
|
-
let throwError;
|
|
16
|
-
if (typeof window !== 'undefined') {
|
|
17
|
-
throwError = () => { throw new Error('"Main" is unavailable in renderer process. Use "Bridge" instead'); };
|
|
18
|
-
}
|
|
19
|
-
else if (!('ipcRenderer' in electron)) {
|
|
20
|
-
throwError = () => { throw new Error('"Main" is unavailable in main process.'); };
|
|
21
|
-
}
|
|
22
|
-
else {
|
|
23
|
-
initInNode();
|
|
24
|
-
}
|
|
25
|
-
/** Выполняется только в NodeJS */
|
|
26
|
-
function initInNode() {
|
|
27
|
-
const { ipcRenderer } = electron;
|
|
28
|
-
const info = ipcRenderer.sendSync(IPCChannel.getPublicInfo);
|
|
29
|
-
if (!info)
|
|
30
|
-
throw new Error('Public methods from main is not provided. Call any publish methods to provide it from main process.');
|
|
31
|
-
Main = createProvider({
|
|
32
|
-
info, scope: Scope.preload,
|
|
33
|
-
callFunction(name, ...args) {
|
|
34
|
-
return ipcRenderer.sendSync(IPCChannel.functionCall + name, ...args);
|
|
35
|
-
},
|
|
36
|
-
handleMainEvent(name, type, handler) {
|
|
37
|
-
const listener = (_, result) => handler(result);
|
|
38
|
-
const emitChannel = IPCChannel.mainEventEmit + name;
|
|
39
|
-
if (type === 'on') {
|
|
40
|
-
ipcRenderer.send(IPCChannel.mainEventOn + name);
|
|
41
|
-
ipcRenderer.on(emitChannel, listener);
|
|
42
|
-
}
|
|
43
|
-
else {
|
|
44
|
-
ipcRenderer.send(IPCChannel.mainEventOnce + name);
|
|
45
|
-
ipcRenderer.once(emitChannel, listener);
|
|
46
|
-
}
|
|
47
|
-
return () => ipcRenderer.removeListener(emitChannel, listener);
|
|
48
|
-
},
|
|
49
|
-
emitRendererEvent(name, arg) {
|
|
50
|
-
const emitChannel = IPCChannel.rendererEventEmit + name;
|
|
51
|
-
if (arg instanceof Promise) {
|
|
52
|
-
const promiseChannel = emitChannel + IPCChannel.promisePostfix;
|
|
53
|
-
ipcRenderer.sendSync(emitChannel, { promiseChannel });
|
|
54
|
-
arg
|
|
55
|
-
.then(value => ipcRenderer.send(promiseChannel, { value }))
|
|
56
|
-
.catch(reason => ipcRenderer.send(promiseChannel, { error: String(reason?.stack || reason) }));
|
|
57
|
-
}
|
|
58
|
-
else {
|
|
59
|
-
ipcRenderer.send(emitChannel, { value: arg });
|
|
60
|
-
}
|
|
61
|
-
},
|
|
62
|
-
getVariable(name) {
|
|
63
|
-
return ipcRenderer.sendSync(IPCChannel.propertyGet + name);
|
|
64
|
-
},
|
|
65
|
-
setVariable(name, value) {
|
|
66
|
-
return ipcRenderer.sendSync(IPCChannel.propertySet + name, value);
|
|
67
|
-
},
|
|
68
|
-
waitPromise(channel) {
|
|
69
|
-
return new Promise((resolve, reject) => {
|
|
70
|
-
ipcRenderer.once(channel, (_, result) => {
|
|
71
|
-
if (result.error)
|
|
72
|
-
reject(result.error);
|
|
73
|
-
else
|
|
74
|
-
resolve(result.value);
|
|
75
|
-
});
|
|
76
|
-
});
|
|
77
|
-
}
|
|
78
|
-
});
|
|
79
|
-
}
|
|
80
|
-
export default Main;
|
|
@@ -1,87 +0,0 @@
|
|
|
1
|
-
import electron from 'electron';
|
|
2
|
-
import { IPCChannel } from '../enums';
|
|
3
|
-
/** Выбрасывает ошибку если используется не в том процессе */
|
|
4
|
-
let mayThrowError = () => { };
|
|
5
|
-
if (typeof window === 'undefined') {
|
|
6
|
-
mayThrowError = () => { throw new Error('"provideFromMain" is unavailable in main process.'); };
|
|
7
|
-
}
|
|
8
|
-
else if (!('contextBridge' in electron)) {
|
|
9
|
-
mayThrowError = () => { throw new Error('"provideFromMain" is unavailable in renderer process.'); };
|
|
10
|
-
}
|
|
11
|
-
/**
|
|
12
|
-
* Sets access to main from renderer
|
|
13
|
-
*
|
|
14
|
-
* @param contextIsolation - _default_: `true`
|
|
15
|
-
*/
|
|
16
|
-
function provideFromMain(contextIsolation = true) {
|
|
17
|
-
mayThrowError();
|
|
18
|
-
const { contextBridge, ipcRenderer } = electron;
|
|
19
|
-
const info = ipcRenderer.sendSync(IPCChannel.getPublicInfo);
|
|
20
|
-
const provider = {
|
|
21
|
-
getInfo() {
|
|
22
|
-
return info;
|
|
23
|
-
},
|
|
24
|
-
waitPromise(channel, resolve, reject) {
|
|
25
|
-
ipcRenderer.once(channel, (_, result) => {
|
|
26
|
-
if (result.error)
|
|
27
|
-
reject?.(result.error);
|
|
28
|
-
else
|
|
29
|
-
resolve(result.value);
|
|
30
|
-
});
|
|
31
|
-
},
|
|
32
|
-
provided: {
|
|
33
|
-
properties: {},
|
|
34
|
-
functions: {},
|
|
35
|
-
mainEvents: {},
|
|
36
|
-
rendererEvents: {},
|
|
37
|
-
}
|
|
38
|
-
};
|
|
39
|
-
info.functions.forEach(funcName => {
|
|
40
|
-
provider.provided.functions[funcName] = (...args) => {
|
|
41
|
-
return ipcRenderer.sendSync(IPCChannel.functionCall + funcName, ...args);
|
|
42
|
-
};
|
|
43
|
-
});
|
|
44
|
-
info.rendererEvents.forEach(eventName => {
|
|
45
|
-
provider.provided.rendererEvents[eventName] = (arg) => {
|
|
46
|
-
const emitChannel = IPCChannel.rendererEventEmit + eventName;
|
|
47
|
-
if (arg instanceof Promise) {
|
|
48
|
-
arg
|
|
49
|
-
.then(value => ipcRenderer.send(emitChannel, { value }))
|
|
50
|
-
.catch(reason => ipcRenderer.send(emitChannel, { error: String(reason) }));
|
|
51
|
-
}
|
|
52
|
-
else {
|
|
53
|
-
ipcRenderer.send(emitChannel, { value: arg });
|
|
54
|
-
}
|
|
55
|
-
};
|
|
56
|
-
});
|
|
57
|
-
info.mainEvents.forEach(eventName => {
|
|
58
|
-
provider.provided.mainEvents[eventName] = (type, handler) => {
|
|
59
|
-
const listener = (_, result) => handler(result);
|
|
60
|
-
const emitChannel = IPCChannel.mainEventEmit + eventName;
|
|
61
|
-
if (type === 'on') {
|
|
62
|
-
ipcRenderer.on(emitChannel, listener);
|
|
63
|
-
ipcRenderer.send(IPCChannel.mainEventOn + eventName);
|
|
64
|
-
}
|
|
65
|
-
else {
|
|
66
|
-
ipcRenderer.once(emitChannel, listener);
|
|
67
|
-
ipcRenderer.send(IPCChannel.mainEventOnce + eventName);
|
|
68
|
-
}
|
|
69
|
-
return () => ipcRenderer.removeListener(emitChannel, listener);
|
|
70
|
-
};
|
|
71
|
-
});
|
|
72
|
-
info.properties.forEach(propName => {
|
|
73
|
-
provider.provided.properties[propName] = {
|
|
74
|
-
get() {
|
|
75
|
-
return ipcRenderer.sendSync(IPCChannel.propertyGet + propName);
|
|
76
|
-
},
|
|
77
|
-
set(value) {
|
|
78
|
-
ipcRenderer.sendSync(IPCChannel.propertySet + propName, value);
|
|
79
|
-
}
|
|
80
|
-
};
|
|
81
|
-
});
|
|
82
|
-
if (contextIsolation)
|
|
83
|
-
contextBridge.exposeInMainWorld('__provider__', provider);
|
|
84
|
-
else
|
|
85
|
-
window.__provider__ = provider;
|
|
86
|
-
}
|
|
87
|
-
export default provideFromMain;
|
|
File without changes
|
|
File without changes
|