13755753799

Committed 10 Mar 2025 02:47AM UTC coverage: 87.472%. Remained the same

Build # 13755753799

Build Type

Pull #1689

github

Committed by

web-flow

Commit Message

Merge 2a6771c28 into 72117c806

Pull Request Pull Request #1689: build(deps): bump dsanders11/project-actions from 1.5.2 to 1.7.0

Run Details

983 of 1223 branches covered (80.38%)

Branch coverage included in aggregate %.

3772 of 4213 relevant lines covered (89.53%)

34.68 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

9.59

/src/preload/preload.ts

// Remember to update ambient.d.ts for extending window object
import { IpcRendererEvent, contextBridge, ipcRenderer } from 'electron';

import {
  BlockableAccelerator,
  DownloadVersionParams,
  FiddleEvent,
  FileTransformOperation,
  Files,
  IPackageManager,
  MessageOptions,
  OutputEntry,
  PMOperationOptions,
  PackageJsonOptions,
  RunResult,
  RunnableVersion,
  StartFiddleParams,
} from '../interfaces';
import { IpcEvents, WEBCONTENTS_READY_FOR_IPC_SIGNAL } from '../ipc-events';
import { FiddleTheme } from '../themes-defaults';

const channelMapping: Record<FiddleEvent, IpcEvents> = {
  'before-quit': IpcEvents.BEFORE_QUIT,
  'bisect-task': IpcEvents.TASK_BISECT,
  'clear-console': IpcEvents.CLEAR_CONSOLE,
  'electron-types-changed': IpcEvents.ELECTRON_TYPES_CHANGED,
  'execute-monaco-command': IpcEvents.MONACO_EXECUTE_COMMAND,
  'fiddle-runner-output': IpcEvents.FIDDLE_RUNNER_OUTPUT,
  'fiddle-stopped': IpcEvents.FIDDLE_STOPPED,
  'load-example': IpcEvents.LOAD_ELECTRON_EXAMPLE_REQUEST,
  'load-gist': IpcEvents.LOAD_GIST_REQUEST,
  'make-fiddle': IpcEvents.FIDDLE_MAKE,
  'new-fiddle': IpcEvents.FS_NEW_FIDDLE,
  'new-test': IpcEvents.FS_NEW_TEST,
  'open-fiddle': IpcEvents.FS_OPEN_FIDDLE,
  'open-settings': IpcEvents.OPEN_SETTINGS,
  'open-template': IpcEvents.FS_OPEN_TEMPLATE,
  'package-fiddle': IpcEvents.FIDDLE_PACKAGE,
  'redo-in-editor': IpcEvents.REDO_IN_EDITOR,
  'run-fiddle': IpcEvents.FIDDLE_RUN,
  'saved-local-fiddle': IpcEvents.SAVED_LOCAL_FIDDLE,
  'save-fiddle-gist': IpcEvents.FS_SAVE_FIDDLE_GIST,
  'select-all-in-editor': IpcEvents.SELECT_ALL_IN_EDITOR,
  'set-show-me-template': IpcEvents.SET_SHOW_ME_TEMPLATE,
  'show-welcome-tour': IpcEvents.SHOW_WELCOME_TOUR,
  'test-task': IpcEvents.TASK_TEST,
  'toggle-bisect': IpcEvents.BISECT_COMMANDS_TOGGLE,
  'toggle-monaco-option': IpcEvents.MONACO_TOGGLE_OPTION,
  'undo-in-editor': IpcEvents.UNDO_IN_EDITOR,
  'version-download-progress': IpcEvents.VERSION_DOWNLOAD_PROGRESS,
  'version-state-changed': IpcEvents.VERSION_STATE_CHANGED,
} as const;

async function preload() {
  await setupFiddleGlobal();
}

export async function setupFiddleGlobal() {
  contextBridge.exposeInMainWorld('ElectronFiddle', {
    addEventListener(
      type: FiddleEvent,
      listener: (...args: any[]) => void,
      options?: { signal: AbortSignal },
    ) {
      const channel = channelMapping[type];
      if (channel) {
        const ipcListener = (_event: IpcRendererEvent, ...args: any[]) => {
          listener(...args);
        };
        ipcRenderer.on(channel, ipcListener);
        if (options?.signal) {
          options.signal.addEventListener('abort', () => {
            ipcRenderer.off(channel, ipcListener);
          });
        }
      }
    },
    addModules(
      { dir, packageManager }: PMOperationOptions,
      ...names: Array<string>
    ) {
      return ipcRenderer.invoke(
        IpcEvents.NPM_ADD_MODULES,
        { dir, packageManager },
        ...names,
      );
    },
    arch: process.arch,
    blockAccelerators(acceleratorsToBlock: BlockableAccelerator[]) {
      ipcRenderer.send(IpcEvents.BLOCK_ACCELERATORS, acceleratorsToBlock);
    },
    cleanupDirectory(dir: string) {
      return ipcRenderer.invoke(IpcEvents.CLEANUP_DIRECTORY, dir);
    },
    confirmQuit() {
      ipcRenderer.send(IpcEvents.CONFIRM_QUIT);
    },
    createThemeFile(newTheme: FiddleTheme, name?: string) {
      return ipcRenderer.invoke(IpcEvents.CREATE_THEME_FILE, newTheme, name);
    },
    async deleteUserData(name: string) {
      await ipcRenderer.invoke(IpcEvents.DELETE_USER_DATA, name);
    },
    async downloadVersion(
      version: string,
      opts?: Partial<DownloadVersionParams>,
    ) {
      await ipcRenderer.invoke(IpcEvents.DOWNLOAD_VERSION, version, opts);
    },
    fetchVersions() {
      return ipcRenderer.invoke(IpcEvents.FETCH_VERSIONS);
    },
    getElectronTypes(ver: RunnableVersion) {
      return ipcRenderer.invoke(IpcEvents.GET_ELECTRON_TYPES, ver);
    },
    getLatestStable() {
      return ipcRenderer.sendSync(IpcEvents.GET_LATEST_STABLE);
    },
    getLocalVersionState(ver: RunnableVersion) {
      return ipcRenderer.sendSync(IpcEvents.GET_LOCAL_VERSION_STATE, ver);
    },
    getOldestSupportedMajor() {
      return ipcRenderer.sendSync(IpcEvents.GET_OLDEST_SUPPORTED_MAJOR);
    },
    getReleasedVersions() {
      return ipcRenderer.sendSync(IpcEvents.GET_RELEASED_VERSIONS);
    },
    getReleaseInfo(version: string) {
      return ipcRenderer.invoke(IpcEvents.GET_RELEASE_INFO, version);
    },
    getAvailableThemes() {
      return ipcRenderer.invoke(IpcEvents.GET_AVAILABLE_THEMES);
    },
    getIsPackageManagerInstalled(
      packageManager: IPackageManager,
      ignoreCache?: boolean,
    ) {
      return ipcRenderer.invoke(
        IpcEvents.NPM_IS_PM_INSTALLED,
        packageManager,
        ignoreCache,
      );
    },
    getNodeTypes(version: string) {
      return ipcRenderer.invoke(IpcEvents.GET_NODE_TYPES, version);
    },
    getProjectName(localPath?: string) {
      return ipcRenderer.invoke(IpcEvents.GET_PROJECT_NAME, localPath);
    },
    getTemplate: (version: string) =>
      ipcRenderer.invoke(IpcEvents.GET_TEMPLATE, version),
    getTemplateValues: (name: string) => {
      return ipcRenderer.invoke(IpcEvents.GET_TEMPLATE_VALUES, name);
    },
    isReleasedMajor(major: number) {
      return ipcRenderer.invoke(IpcEvents.IS_RELEASED_MAJOR, major);
    },
    getTestTemplate: () => ipcRenderer.invoke(IpcEvents.GET_TEST_TEMPLATE),
    getUsername: () => ipcRenderer.sendSync(IpcEvents.GET_USERNAME),
    getVersionState: (version: string) =>
      ipcRenderer.sendSync(IpcEvents.GET_VERSION_STATE, version),
    isDevMode: ipcRenderer.sendSync(IpcEvents.IS_DEV_MODE),
    macTitlebarClicked() {
      ipcRenderer.send(IpcEvents.CLICK_TITLEBAR_MAC);
    },
    onGetFiles(
      callback: (
        options: PackageJsonOptions | undefined,
        transforms: Array<FileTransformOperation>,
      ) => Promise<{ localPath?: string; files: Files }>,
    ) {
      ipcRenderer.removeAllListeners(IpcEvents.GET_FILES);
      ipcRenderer.on(
        IpcEvents.GET_FILES,
        async (e, { options, transforms }) => {
          const { localPath, files } = await callback(options, transforms);
          e.ports[0].postMessage({ localPath, files: [...files.entries()] });
        },
      );
    },
    async openThemeFolder() {
      await ipcRenderer.invoke(IpcEvents.OPEN_THEME_FOLDER);
    },
    packageRun({ dir, packageManager }: PMOperationOptions, command: string) {
      return ipcRenderer.invoke(
        IpcEvents.NPM_PACKAGE_RUN,
        { dir, packageManager },
        command,
      );
    },
    pathExists: (path: string) =>
      ipcRenderer.sendSync(IpcEvents.PATH_EXISTS, path),
    platform: process.platform,
    pushOutputEntry(entry: OutputEntry) {
      ipcRenderer.send(IpcEvents.OUTPUT_ENTRY, entry);
    },
    reloadWindows() {
      ipcRenderer.send(IpcEvents.RELOAD_WINDOW);
    },
    readThemeFile(name?: string) {
      return ipcRenderer.invoke(IpcEvents.READ_THEME_FILE, name);
    },
    removeAllListeners(type: FiddleEvent) {
      const channel = channelMapping[type];
      if (channel) {
        ipcRenderer.removeAllListeners(channel);
      }
    },
    async removeVersion(version: string) {
      return ipcRenderer.invoke(IpcEvents.REMOVE_VERSION, version);
    },
    saveFilesToTemp(files: Files) {
      return ipcRenderer.invoke(IpcEvents.SAVE_FILES_TO_TEMP, [
        ...files.entries(),
      ]);
    },
    selectLocalVersion: () => {
      return ipcRenderer.invoke(IpcEvents.LOAD_LOCAL_VERSION_FOLDER);
    },
    sendReady() {
      ipcRenderer.send(WEBCONTENTS_READY_FOR_IPC_SIGNAL);
    },
    setNativeTheme(theme: 'dark' | 'light' | 'system') {
      ipcRenderer.send(IpcEvents.SET_NATIVE_THEME, theme);
    },
    setShowMeTemplate(template?: string) {
      ipcRenderer.send(IpcEvents.SET_SHOW_ME_TEMPLATE, template);
    },
    showWarningDialog(messageOptions: MessageOptions) {
      ipcRenderer.send(IpcEvents.SHOW_WARNING_DIALOG, messageOptions);
    },
    showWindow() {
      ipcRenderer.send(IpcEvents.SHOW_WINDOW);
    },
    async startFiddle(params: StartFiddleParams) {
      await ipcRenderer.invoke(IpcEvents.START_FIDDLE, params);
    },
    stopFiddle() {
      ipcRenderer.send(IpcEvents.STOP_FIDDLE);
    },
    taskDone(result: RunResult) {
      ipcRenderer.send(IpcEvents.TASK_DONE, result);
    },
    themePath: await ipcRenderer.sendSync(IpcEvents.GET_THEME_PATH),
    async uncacheTypes(ver: RunnableVersion) {
      await ipcRenderer.invoke(IpcEvents.UNCACHE_TYPES, ver);
    },
    async unwatchElectronTypes() {
      await ipcRenderer.invoke(IpcEvents.UNWATCH_ELECTRON_TYPES);
    },
  });
}

preload();

1	// Remember to update ambient.d.ts for extending window object
2	import { IpcRendererEvent, contextBridge, ipcRenderer } from 'electron';	1✔
3
4	import {
5	BlockableAccelerator,
6	DownloadVersionParams,
7	FiddleEvent,
8	FileTransformOperation,
9	Files,
10	IPackageManager,
11	MessageOptions,
12	OutputEntry,
13	PMOperationOptions,
14	PackageJsonOptions,
15	RunResult,
16	RunnableVersion,
17	StartFiddleParams,
18	} from '../interfaces';
19	import { IpcEvents, WEBCONTENTS_READY_FOR_IPC_SIGNAL } from '../ipc-events';	1✔
20	import { FiddleTheme } from '../themes-defaults';
21
22	const channelMapping: Record<FiddleEvent, IpcEvents> = {	1✔
23	'before-quit': IpcEvents.BEFORE_QUIT,
24	'bisect-task': IpcEvents.TASK_BISECT,
25	'clear-console': IpcEvents.CLEAR_CONSOLE,
26	'electron-types-changed': IpcEvents.ELECTRON_TYPES_CHANGED,
27	'execute-monaco-command': IpcEvents.MONACO_EXECUTE_COMMAND,
28	'fiddle-runner-output': IpcEvents.FIDDLE_RUNNER_OUTPUT,
29	'fiddle-stopped': IpcEvents.FIDDLE_STOPPED,
30	'load-example': IpcEvents.LOAD_ELECTRON_EXAMPLE_REQUEST,
31	'load-gist': IpcEvents.LOAD_GIST_REQUEST,
32	'make-fiddle': IpcEvents.FIDDLE_MAKE,
33	'new-fiddle': IpcEvents.FS_NEW_FIDDLE,
34	'new-test': IpcEvents.FS_NEW_TEST,
35	'open-fiddle': IpcEvents.FS_OPEN_FIDDLE,
36	'open-settings': IpcEvents.OPEN_SETTINGS,
37	'open-template': IpcEvents.FS_OPEN_TEMPLATE,
38	'package-fiddle': IpcEvents.FIDDLE_PACKAGE,
39	'redo-in-editor': IpcEvents.REDO_IN_EDITOR,
40	'run-fiddle': IpcEvents.FIDDLE_RUN,
41	'saved-local-fiddle': IpcEvents.SAVED_LOCAL_FIDDLE,
42	'save-fiddle-gist': IpcEvents.FS_SAVE_FIDDLE_GIST,
43	'select-all-in-editor': IpcEvents.SELECT_ALL_IN_EDITOR,
44	'set-show-me-template': IpcEvents.SET_SHOW_ME_TEMPLATE,
45	'show-welcome-tour': IpcEvents.SHOW_WELCOME_TOUR,
46	'test-task': IpcEvents.TASK_TEST,
47	'toggle-bisect': IpcEvents.BISECT_COMMANDS_TOGGLE,
48	'toggle-monaco-option': IpcEvents.MONACO_TOGGLE_OPTION,
49	'undo-in-editor': IpcEvents.UNDO_IN_EDITOR,
50	'version-download-progress': IpcEvents.VERSION_DOWNLOAD_PROGRESS,
51	'version-state-changed': IpcEvents.VERSION_STATE_CHANGED,
52	} as const;
53
54	async function preload() {
55	await setupFiddleGlobal();	1✔
56	}
57
58	export async function setupFiddleGlobal() {	1✔
59	contextBridge.exposeInMainWorld('ElectronFiddle', {	2✔
60	addEventListener(
61	type: FiddleEvent,
62	listener: (...args: any[]) => void,
63	options?: { signal: AbortSignal },
64	) {
65	const channel = channelMapping[type];	×
66	if (channel) {	×
67	const ipcListener = (_event: IpcRendererEvent, ...args: any[]) => {	×
68	listener(...args);	×
69	};
70	ipcRenderer.on(channel, ipcListener);	×
71	if (options?.signal) {	×
72	options.signal.addEventListener('abort', () => {	×
73	ipcRenderer.off(channel, ipcListener);	×
74	});
75	}
76	}
77	},
78	addModules(
79	{ dir, packageManager }: PMOperationOptions,
80	...names: Array<string>
81	) {
82	return ipcRenderer.invoke(	×
83	IpcEvents.NPM_ADD_MODULES,
84	{ dir, packageManager },
85	...names,
86	);
87	},
88	arch: process.arch,
89	blockAccelerators(acceleratorsToBlock: BlockableAccelerator[]) {
90	ipcRenderer.send(IpcEvents.BLOCK_ACCELERATORS, acceleratorsToBlock);	×
91	},
92	cleanupDirectory(dir: string) {
93	return ipcRenderer.invoke(IpcEvents.CLEANUP_DIRECTORY, dir);	×
94	},
95	confirmQuit() {
96	ipcRenderer.send(IpcEvents.CONFIRM_QUIT);	×
97	},
98	createThemeFile(newTheme: FiddleTheme, name?: string) {
99	return ipcRenderer.invoke(IpcEvents.CREATE_THEME_FILE, newTheme, name);	×
100	},
101	async deleteUserData(name: string) {
102	await ipcRenderer.invoke(IpcEvents.DELETE_USER_DATA, name);	×
103	},
104	async downloadVersion(
105	version: string,
106	opts?: Partial<DownloadVersionParams>,
107	) {
108	await ipcRenderer.invoke(IpcEvents.DOWNLOAD_VERSION, version, opts);	×
109	},
110	fetchVersions() {
111	return ipcRenderer.invoke(IpcEvents.FETCH_VERSIONS);	×
112	},
113	getElectronTypes(ver: RunnableVersion) {
114	return ipcRenderer.invoke(IpcEvents.GET_ELECTRON_TYPES, ver);	×
115	},
116	getLatestStable() {
117	return ipcRenderer.sendSync(IpcEvents.GET_LATEST_STABLE);	×
118	},
119	getLocalVersionState(ver: RunnableVersion) {
120	return ipcRenderer.sendSync(IpcEvents.GET_LOCAL_VERSION_STATE, ver);	×
121	},
122	getOldestSupportedMajor() {
123	return ipcRenderer.sendSync(IpcEvents.GET_OLDEST_SUPPORTED_MAJOR);	×
124	},
125	getReleasedVersions() {
126	return ipcRenderer.sendSync(IpcEvents.GET_RELEASED_VERSIONS);	×
127	},
128	getReleaseInfo(version: string) {
129	return ipcRenderer.invoke(IpcEvents.GET_RELEASE_INFO, version);	×
130	},
131	getAvailableThemes() {
132	return ipcRenderer.invoke(IpcEvents.GET_AVAILABLE_THEMES);	×
133	},
134	getIsPackageManagerInstalled(
135	packageManager: IPackageManager,
136	ignoreCache?: boolean,
137	) {
138	return ipcRenderer.invoke(	×
139	IpcEvents.NPM_IS_PM_INSTALLED,
140	packageManager,
141	ignoreCache,
142	);
143	},
144	getNodeTypes(version: string) {
145	return ipcRenderer.invoke(IpcEvents.GET_NODE_TYPES, version);	×
146	},
147	getProjectName(localPath?: string) {
148	return ipcRenderer.invoke(IpcEvents.GET_PROJECT_NAME, localPath);	×
149	},
150	getTemplate: (version: string) =>
151	ipcRenderer.invoke(IpcEvents.GET_TEMPLATE, version),	×
152	getTemplateValues: (name: string) => {
153	return ipcRenderer.invoke(IpcEvents.GET_TEMPLATE_VALUES, name);	×
154	},
155	isReleasedMajor(major: number) {
156	return ipcRenderer.invoke(IpcEvents.IS_RELEASED_MAJOR, major);	×
157	},
158	getTestTemplate: () => ipcRenderer.invoke(IpcEvents.GET_TEST_TEMPLATE),	×
159	getUsername: () => ipcRenderer.sendSync(IpcEvents.GET_USERNAME),	×
160	getVersionState: (version: string) =>
161	ipcRenderer.sendSync(IpcEvents.GET_VERSION_STATE, version),	×
162	isDevMode: ipcRenderer.sendSync(IpcEvents.IS_DEV_MODE),
163	macTitlebarClicked() {
164	ipcRenderer.send(IpcEvents.CLICK_TITLEBAR_MAC);	×
165	},
166	onGetFiles(
167	callback: (
168	options: PackageJsonOptions \| undefined,
169	transforms: Array<FileTransformOperation>,
170	) => Promise<{ localPath?: string; files: Files }>,
171	) {
172	ipcRenderer.removeAllListeners(IpcEvents.GET_FILES);	×
173	ipcRenderer.on(	×
174	IpcEvents.GET_FILES,
175	async (e, { options, transforms }) => {
176	const { localPath, files } = await callback(options, transforms);	×
177	e.ports[0].postMessage({ localPath, files: [...files.entries()] });	×
178	},
179	);
180	},
181	async openThemeFolder() {
182	await ipcRenderer.invoke(IpcEvents.OPEN_THEME_FOLDER);	×
183	},
184	packageRun({ dir, packageManager }: PMOperationOptions, command: string) {
185	return ipcRenderer.invoke(	×
186	IpcEvents.NPM_PACKAGE_RUN,
187	{ dir, packageManager },
188	command,
189	);
190	},
191	pathExists: (path: string) =>
192	ipcRenderer.sendSync(IpcEvents.PATH_EXISTS, path),	×
193	platform: process.platform,
194	pushOutputEntry(entry: OutputEntry) {
195	ipcRenderer.send(IpcEvents.OUTPUT_ENTRY, entry);	×
196	},
197	reloadWindows() {
198	ipcRenderer.send(IpcEvents.RELOAD_WINDOW);	×
199	},
200	readThemeFile(name?: string) {
201	return ipcRenderer.invoke(IpcEvents.READ_THEME_FILE, name);	×
202	},
203	removeAllListeners(type: FiddleEvent) {
204	const channel = channelMapping[type];	×
205	if (channel) {	×
206	ipcRenderer.removeAllListeners(channel);	×
207	}
208	},
209	async removeVersion(version: string) {
210	return ipcRenderer.invoke(IpcEvents.REMOVE_VERSION, version);	×
211	},
212	saveFilesToTemp(files: Files) {
213	return ipcRenderer.invoke(IpcEvents.SAVE_FILES_TO_TEMP, [	×
214	...files.entries(),
215	]);
216	},
217	selectLocalVersion: () => {
218	return ipcRenderer.invoke(IpcEvents.LOAD_LOCAL_VERSION_FOLDER);	×
219	},
220	sendReady() {
221	ipcRenderer.send(WEBCONTENTS_READY_FOR_IPC_SIGNAL);	×
222	},
223	setNativeTheme(theme: 'dark' \| 'light' \| 'system') {
224	ipcRenderer.send(IpcEvents.SET_NATIVE_THEME, theme);	×
225	},
226	setShowMeTemplate(template?: string) {
227	ipcRenderer.send(IpcEvents.SET_SHOW_ME_TEMPLATE, template);	×
228	},
229	showWarningDialog(messageOptions: MessageOptions) {
230	ipcRenderer.send(IpcEvents.SHOW_WARNING_DIALOG, messageOptions);	×
231	},
232	showWindow() {
233	ipcRenderer.send(IpcEvents.SHOW_WINDOW);	×
234	},
235	async startFiddle(params: StartFiddleParams) {
236	await ipcRenderer.invoke(IpcEvents.START_FIDDLE, params);	×
237	},
238	stopFiddle() {
239	ipcRenderer.send(IpcEvents.STOP_FIDDLE);	×
240	},
241	taskDone(result: RunResult) {
242	ipcRenderer.send(IpcEvents.TASK_DONE, result);	×
243	},
244	themePath: await ipcRenderer.sendSync(IpcEvents.GET_THEME_PATH),
245	async uncacheTypes(ver: RunnableVersion) {
246	await ipcRenderer.invoke(IpcEvents.UNCACHE_TYPES, ver);	×
247	},
248	async unwatchElectronTypes() {
249	await ipcRenderer.invoke(IpcEvents.UNWATCH_ELECTRON_TYPES);	×
250	},
251	});
252	}
253
254	preload();	1✔

electron / fiddle / 13755753799

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous