emr-bridge 1.6.2 → 1.7.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 (63) hide show
  1. package/cjs/errors.d.ts +28 -0
  2. package/cjs/errors.js +39 -0
  3. package/cjs/exp.d.ts +2 -2
  4. package/cjs/exp.js +8 -8
  5. package/cjs/index.d.ts +2 -2
  6. package/cjs/index.js +7 -7
  7. package/cjs/main.d.ts +2 -2
  8. package/cjs/main.js +7 -7
  9. package/cjs/preload.d.ts +3 -3
  10. package/cjs/preload.js +4 -4
  11. package/cjs/renderer.d.ts +2 -2
  12. package/cjs/renderer.js +2 -2
  13. package/cjs/scripts/{Bridge.d.ts → bridge.d.ts} +2 -2
  14. package/cjs/scripts/bridge.js +57 -0
  15. package/{esm/scripts/Main.d.ts → cjs/scripts/main.d.ts} +2 -2
  16. package/cjs/scripts/main.js +72 -0
  17. package/cjs/scripts/{newDecorators.d.ts → new-decorators.d.ts} +5 -5
  18. package/cjs/scripts/{oldDecorators.d.ts → old-decorators.d.ts} +7 -7
  19. package/cjs/scripts/preload-provider.js +96 -0
  20. package/cjs/scripts/provider.d.ts +25 -3
  21. package/cjs/scripts/provider.js +96 -92
  22. package/cjs/scripts/publish.js +18 -15
  23. package/cjs/scripts/renderer-tunnels.d.ts +47 -0
  24. package/cjs/scripts/renderer-tunnels.js +115 -0
  25. package/cjs/types.d.ts +32 -39
  26. package/esm/errors.d.ts +28 -0
  27. package/esm/errors.js +27 -0
  28. package/esm/exp.d.ts +2 -2
  29. package/esm/exp.js +1 -1
  30. package/esm/index.d.ts +2 -2
  31. package/esm/index.js +1 -1
  32. package/esm/main.d.ts +2 -2
  33. package/esm/main.js +1 -1
  34. package/esm/preload.d.ts +3 -3
  35. package/esm/preload.js +2 -2
  36. package/esm/renderer.d.ts +2 -2
  37. package/esm/renderer.js +1 -1
  38. package/esm/scripts/{Bridge.d.ts → bridge.d.ts} +2 -2
  39. package/esm/scripts/bridge.js +52 -0
  40. package/{cjs/scripts/Main.d.ts → esm/scripts/main.d.ts} +2 -2
  41. package/esm/scripts/main.js +67 -0
  42. package/esm/scripts/{newDecorators.d.ts → new-decorators.d.ts} +5 -5
  43. package/esm/scripts/{oldDecorators.d.ts → old-decorators.d.ts} +7 -7
  44. package/esm/scripts/preload-provider.js +91 -0
  45. package/esm/scripts/provider.d.ts +25 -3
  46. package/esm/scripts/provider.js +95 -92
  47. package/esm/scripts/publish.js +18 -15
  48. package/esm/scripts/renderer-tunnels.d.ts +47 -0
  49. package/esm/scripts/renderer-tunnels.js +109 -0
  50. package/esm/types.d.ts +32 -39
  51. package/package.json +1 -1
  52. package/cjs/scripts/Bridge.js +0 -58
  53. package/cjs/scripts/Main.js +0 -85
  54. package/cjs/scripts/preloadProvider.js +0 -92
  55. package/esm/scripts/Bridge.js +0 -53
  56. package/esm/scripts/Main.js +0 -80
  57. package/esm/scripts/preloadProvider.js +0 -87
  58. /package/cjs/scripts/{newDecorators.js → new-decorators.js} +0 -0
  59. /package/cjs/scripts/{oldDecorators.js → old-decorators.js} +0 -0
  60. /package/cjs/scripts/{preloadProvider.d.ts → preload-provider.d.ts} +0 -0
  61. /package/esm/scripts/{newDecorators.js → new-decorators.js} +0 -0
  62. /package/esm/scripts/{oldDecorators.js → old-decorators.js} +0 -0
  63. /package/esm/scripts/{preloadProvider.d.ts → preload-provider.d.ts} +0 -0
@@ -95,13 +95,14 @@ export function publicRendererEvent(name, procFn = ((v) => v), scopes = [Scope.p
95
95
  const handlers = new Set();
96
96
  const handlersOnce = new Set();
97
97
  rendererEvents.add(name);
98
- if (!publicInfo.scopes.has(name))
98
+ if (!publicInfo.scopes.has(name)) {
99
99
  publicInfo.scopes.set(name, new Set(scopes));
100
+ }
100
101
  ipcMain.removeAllListeners(rendererEmitChannel);
101
- ipcMain.on(rendererEmitChannel, (_, result) => {
102
- if (result.error)
103
- throw new Error(result.error);
104
- const converted = procFn(result.value);
102
+ ipcMain.on(rendererEmitChannel, (_, { error, value }) => {
103
+ if (error)
104
+ throw new Error(error);
105
+ const converted = procFn(value);
105
106
  handlers.forEach(handler => handler(converted));
106
107
  handlersOnce.forEach(handler => handler(converted));
107
108
  handlersOnce.clear();
@@ -132,17 +133,18 @@ export function publicFunction(name, func, scopes = [Scope.preload, Scope.render
132
133
  const { functions } = publicInfo;
133
134
  const channel = IPCChannel.functionCall + name;
134
135
  functions.add(name);
135
- if (!publicInfo.scopes.has(name))
136
+ if (!publicInfo.scopes.has(name)) {
136
137
  publicInfo.scopes.set(name, new Set(scopes));
138
+ }
137
139
  ipcMain.removeAllListeners(channel);
138
- ipcMain.on(channel, (e, ...args) => {
140
+ ipcMain.on(channel, (e, { args, secret }) => {
139
141
  try {
140
142
  const result = func(...args);
141
143
  if (result instanceof Promise) {
142
144
  const promiseChannel = channel + IPCChannel.promisePostfix;
143
145
  result
144
- .then(value => e.sender.send(promiseChannel, { value }))
145
- .catch(reason => e.sender.send(promiseChannel, { error: String(reason?.stack || reason) }));
146
+ .then(value => e.sender.send(promiseChannel, { value, secret }))
147
+ .catch(reason => e.sender.send(promiseChannel, { error: String(reason?.stack || reason), secret }));
146
148
  e.returnValue = { promiseChannel };
147
149
  }
148
150
  else {
@@ -171,8 +173,9 @@ export function publicVariable(name, value, scopes = [Scope.renderer, Scope.prel
171
173
  const setChannel = IPCChannel.propertySet + name;
172
174
  const { get: getter, set: setter } = value;
173
175
  properties.add(name);
174
- if (!publicInfo.scopes.has(name))
176
+ if (!publicInfo.scopes.has(name)) {
175
177
  publicInfo.scopes.set(name, new Set(scopes));
178
+ }
176
179
  if (!publicInfo.accesses.has(name)) {
177
180
  const accesses = [];
178
181
  getter && accesses.push(Access.get);
@@ -186,25 +189,25 @@ export function publicVariable(name, value, scopes = [Scope.renderer, Scope.prel
186
189
  }
187
190
  if (getter) {
188
191
  ipcMain.removeAllListeners(getChannel);
189
- ipcMain.on(getChannel, event => {
192
+ ipcMain.on(getChannel, (event) => {
190
193
  try {
191
194
  const result = getter();
192
195
  event.returnValue = { value: result };
193
196
  }
194
197
  catch (error) {
195
- event.returnValue = { error };
198
+ event.returnValue = { error: String(error?.stack || error) };
196
199
  }
197
200
  });
198
201
  }
199
202
  if (setter) {
200
203
  ipcMain.removeAllListeners(setChannel);
201
- ipcMain.on(setChannel, (event, ...args) => {
204
+ ipcMain.on(setChannel, (event, { args }) => {
202
205
  try {
203
- setter(args[0]);
206
+ setter(args.at(0));
204
207
  event.returnValue = { value: null };
205
208
  }
206
209
  catch (error) {
207
- event.returnValue = { error };
210
+ event.returnValue = { error: String(error?.stack || error) };
208
211
  }
209
212
  });
210
213
  }
@@ -0,0 +1,47 @@
1
+ import type { IpcRendererEvent } from 'electron';
2
+ import type { EventHandler, EventUnsubscriber, IPCRequest, IPCResult } from '../types';
3
+ declare class FunctionTunnel {
4
+ #private;
5
+ constructor(name: string);
6
+ call(args?: IPCRequest): IPCResult;
7
+ }
8
+ declare class PropertyTunnel {
9
+ #private;
10
+ constructor(name: string);
11
+ get(): IPCResult;
12
+ set(value: any): IPCResult;
13
+ }
14
+ declare class PromiseTunnel {
15
+ #private;
16
+ constructor(channel: string);
17
+ wait(secret?: number): Promise<any>;
18
+ }
19
+ declare class MainEventTunnel {
20
+ #private;
21
+ constructor(name: string);
22
+ on(handler: EventHandler<IPCResult>): EventUnsubscriber;
23
+ once(handler: EventHandler<IPCResult>): EventUnsubscriber;
24
+ }
25
+ declare class RendererEventTunnel {
26
+ #private;
27
+ constructor(name: string);
28
+ emit(value: any): void;
29
+ error(error: string): void;
30
+ }
31
+ export default class IPCTunnel {
32
+ #private;
33
+ private channel;
34
+ static readonly Function: typeof FunctionTunnel;
35
+ static readonly Property: typeof PropertyTunnel;
36
+ static readonly Promise: typeof PromiseTunnel;
37
+ static readonly MainEvent: typeof MainEventTunnel;
38
+ static readonly RendererEvent: typeof RendererEventTunnel;
39
+ constructor(channel: string);
40
+ request(args?: IPCRequest): IPCResult;
41
+ response(args?: IPCResult): void;
42
+ on(listener: (event: IpcRendererEvent, ...args: any[]) => void): void;
43
+ once(listener: (event: IpcRendererEvent, ...args: any[]) => void): void;
44
+ removeListener(listener: (event: IpcRendererEvent, ...args: any[]) => void): void;
45
+ removeAllListeners(): void;
46
+ }
47
+ export {};
@@ -0,0 +1,109 @@
1
+ import electron from 'electron';
2
+ import { IPCChannel } from '../enums';
3
+ class FunctionTunnel {
4
+ #tunnel;
5
+ constructor(name) {
6
+ this.#tunnel = new IPCTunnel(IPCChannel.functionCall + name);
7
+ }
8
+ call(args = { args: [] }) {
9
+ return this.#tunnel.request(args);
10
+ }
11
+ }
12
+ class PropertyTunnel {
13
+ #getTunnel;
14
+ #setTunnel;
15
+ constructor(name) {
16
+ this.#getTunnel = new IPCTunnel(IPCChannel.propertyGet + name);
17
+ this.#setTunnel = new IPCTunnel(IPCChannel.propertySet + name);
18
+ }
19
+ get() {
20
+ return this.#getTunnel.request();
21
+ }
22
+ set(value) {
23
+ return this.#setTunnel.request({ args: [value] });
24
+ }
25
+ }
26
+ class PromiseTunnel {
27
+ #tunnel;
28
+ constructor(channel) {
29
+ this.#tunnel = new IPCTunnel(channel);
30
+ }
31
+ wait(secret) {
32
+ return new Promise((resolve, reject) => {
33
+ const handler = (_, { error, value, secret: resSecret }) => {
34
+ if (secret !== undefined && resSecret !== secret)
35
+ return;
36
+ if (error)
37
+ reject(error);
38
+ else
39
+ resolve(value);
40
+ this.#tunnel.removeListener(handler);
41
+ };
42
+ this.#tunnel.on(handler);
43
+ });
44
+ }
45
+ }
46
+ class MainEventTunnel {
47
+ #emitTunnel;
48
+ #onTunnel;
49
+ #onceTunnel;
50
+ constructor(name) {
51
+ this.#emitTunnel = new IPCTunnel(IPCChannel.mainEventEmit + name);
52
+ this.#onTunnel = new IPCTunnel(IPCChannel.mainEventOn + name);
53
+ this.#onceTunnel = new IPCTunnel(IPCChannel.mainEventOnce + name);
54
+ }
55
+ on(handler) {
56
+ const listener = (_, result) => handler(result);
57
+ this.#onTunnel.response();
58
+ this.#emitTunnel.on(listener);
59
+ return () => this.#emitTunnel.removeListener(listener);
60
+ }
61
+ once(handler) {
62
+ const listener = (_, result) => handler(result);
63
+ this.#onceTunnel.response();
64
+ this.#emitTunnel.once(listener);
65
+ return () => this.#emitTunnel.removeListener(listener);
66
+ }
67
+ }
68
+ class RendererEventTunnel {
69
+ #emitTunnel;
70
+ constructor(name) {
71
+ this.#emitTunnel = new IPCTunnel(IPCChannel.rendererEventEmit + name);
72
+ }
73
+ emit(value) {
74
+ this.#emitTunnel.response({ value });
75
+ }
76
+ error(error) {
77
+ this.#emitTunnel.response({ error });
78
+ }
79
+ }
80
+ export default class IPCTunnel {
81
+ channel;
82
+ #ipcRenderer = electron.ipcRenderer;
83
+ static Function = FunctionTunnel;
84
+ static Property = PropertyTunnel;
85
+ static Promise = PromiseTunnel;
86
+ static MainEvent = MainEventTunnel;
87
+ static RendererEvent = RendererEventTunnel;
88
+ constructor(channel) {
89
+ this.channel = channel;
90
+ }
91
+ request(args = { args: [] }) {
92
+ return this.#ipcRenderer.sendSync(this.channel, args);
93
+ }
94
+ response(args = {}) {
95
+ this.#ipcRenderer.send(this.channel, args);
96
+ }
97
+ on(listener) {
98
+ this.#ipcRenderer.on(this.channel, listener);
99
+ }
100
+ once(listener) {
101
+ this.#ipcRenderer.once(this.channel, listener);
102
+ }
103
+ removeListener(listener) {
104
+ this.#ipcRenderer.removeListener(this.channel, listener);
105
+ }
106
+ removeAllListeners() {
107
+ this.#ipcRenderer.removeAllListeners(this.channel);
108
+ }
109
+ }
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 ITarget {
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, Type>(target: undefined, context: ClassFieldDecoratorContext<This, Type>) => void;
8
- export type ClassGetterDecorator = <This, Type>(getter: () => Type, context: ClassGetterDecoratorContext<This, Type>) => void;
9
- export type ClassSetterDecorator = <This, Type>(setter: (value: Type) => void, context: ClassSetterDecoratorContext<This, Type>) => void;
10
- export type PublishSetterArgs = Omit<IPublishPropertyArgs, 'access'>;
11
- export type PublishGetterArgs = Omit<IPublishPropertyArgs, 'access'>;
12
- export interface IIPCResult {
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 IPublishMethodArgs {
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 IPublishMainEventArgs {
26
+ export interface PublishMainEventArgs {
22
27
  name?: string;
23
28
  scope?: Scope;
24
29
  }
25
- export interface IPublishRendererEventArgs {
30
+ export interface PublishRendererEventArgs {
26
31
  name?: string;
27
32
  scope?: Scope;
28
33
  procFn?: EventReceiver;
29
34
  }
30
- export interface IPublishPropertyArgs {
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 interface IRendererPublic {
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 IProvider {
57
- getInfo(): IInfo;
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, (...args: any[]) => IIPCResult>;
61
- mainEvents: Record<string, (type: 'on' | 'once', handler: EventHandler<IIPCResult>) => EventUnsubscriber>;
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(): IIPCResult;
65
- set(val: any): void;
62
+ get(): IPCResult;
63
+ set(val: any): IPCResult;
66
64
  }>;
67
65
  };
68
66
  }
69
- export type PublicFunction = (...args: any[]) => any;
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: Scopes;
80
- accesses: Accesses;
72
+ scopes: Map<string, Set<Scope>>;
73
+ accesses: Map<string, Set<Access>>;
81
74
  }
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "emr-bridge",
3
- "version": "1.6.2",
3
+ "version": "1.7.0",
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": {
@@ -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;
@@ -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;
@@ -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;