electron#shell TypeScript Examples

ipcMain.on("Open-External-Game", async () => {
    const steamProtocol = "steam://run/";
    const steamProtocolMod = "steam://rungameid/";
    const isMod = mod_manager.currentModData.isMod;
    const game = steamProtocol + mod_manager.currentModData.gameId;
    const gameMod = steamProtocolMod + mod_manager.currentModData.gameId;
    const gameDefault = steamProtocol + "440";

    if (mod_manager.currentModData.gameId != "" && mod_manager.currentModState == "INSTALLED") {
        if (isMod == false) {
            log.log("GAME LAUNCHING: User initiated (non-mod) game: " + game);
            shell.openExternal(game);
        } else {
            log.log("GAME LAUNCHING: User initiated (mod) game: " + gameMod);
            shell.openExternal(gameMod);
        }
    } else if (mod_manager.currentModData.gameId == "" && mod_manager.currentModState == "INSTALLED") {
        log.log("GAME LAUNCHING: Current mod doesn't have a gameId, initiating default game: " + gameDefault);
        shell.openExternal(gameDefault);
    } else {
        log.log("GAME LAUNCHING: Can't initiate the current mod's game. It's either uninstalled or with a pending update.");
    }
});

/**
   * Gets hyperlink items from a LinkDescriptor array
   */
  protected getHyperlinkItems(
    links: LinkDescriptor[]
  ): MenuItemConstructorOptions[] {
    return links.map((li) => ({
      type: li.label ? "normal" : "separator",
      label: li?.label,
      click: async () => {
        if (li.uri) {
          await shell.openExternal(li.uri);
        }
      },
    }));
  }

/*
  Handle IPC requests from the User Interface
 */
ipcMain.on(
  IpcRequest.OpenFileLocation,
  (_, arg: OpenFileLocationRequestBody) => {
    logger.log('received a request to show item in folder', {
      path: arg.path,
    });
    shell.showItemInFolder(arg.path);
  }
);

AboutThisApp: React.FC<AboutThisAppProps> = props => {
    return (
        <Dialog open={props.visible} style={{ userSelect: 'none', textAlign: 'center' }}>
            <DialogContent>
                <AppIcon src={infoIcon} alt="SpaceEye icon" />
                <Typography variant="h6">SpaceEye</Typography>
                <Typography variant="body2" style={{ userSelect: 'text' }}>
                    Version {APP_VERSION}
                </Typography>
                <Typography variant="body2">Copyright &copy; 2020 Michael Galliers</Typography>
                <Typography variant="body2">License: {APP_LICENSE}</Typography>
                <Link
                    component="button"
                    variant="body2"
                    onClick={() => shell.openExternal(APP_BUGS_URL)}
                >
                    Report bugs
                </Link>
                <DialogActions>
                    <Button
                        onClick={() =>
                            shell.openPath(path.join(process.resourcesPath, 'legal_notices.txt'))
                        }
                    >
                        Acknowledgements
                    </Button>
                    <Button onClick={props.onClickDone}>Done</Button>
                </DialogActions>
            </DialogContent>
        </Dialog>
    )
}

constructor() {
    if (this.isElectron) {
      this.ipcRenderer = window.require('electron').ipcRenderer;
      this.webFrame = window.require('electron').webFrame;
      this.shell = window.require('electron').shell;
      this.request = window.require('request-promise');
      this.dialog = window.require('electron').remote.dialog;
      this.childProcess = window.require('child_process');
      this.fs = window.require('fs');
      this.LCUConnector = window.require('lcu-connector');
    }
  }

AlphaLink = () => {
  const styles = useStyles();

  const handleClick = useCallback(() => {
    shell.openExternal(outerWildsAlphaUrl);
  }, []);

  return (
    <ListItem className={styles.root}>
      <Button
        variant="outlined"
        color="secondary"
        onClick={handleClick}
        startIcon={<DownloadIcon />}
      >
        {globalText.alphaWebsite}
      </Button>
    </ListItem>
  );
}

function addWindowDownloadHandler(window) {
    window.webContents.session.on('will-download', (_evt, item, _webContents) => {
        let url = item.getURL();
        let urls = item.getURLChain();
        let name = item.getFilename();
        let etx = path.extname(url.split('?')[0]).toLowerCase();
        let etx2 = urls.length ? path.extname(urls[0].split('?')[0]).toLowerCase() : etx;
        if (~url.indexOf('https://beatsaver.com/cdn')) {
            // beat saber mods /songs
            mainWindow.webContents.send('open-url', 'sidequest://bsaber/#' + url);
        } else if (~url.indexOf('http://songbeater.com/')) {
            // songbeater mods /songs
            mainWindow.webContents.send('open-url', 'sidequest://songbeater/#' + url);
        } else if (~url.indexOf('https://synthriderz.com/')) {
            // synthriderz mods /songs
            mainWindow.webContents.send('open-url', 'sidequest://synthriders/#' + url);
        } else if (etx === '.audica') {
            // audica custom song format
            mainWindow.webContents.send('open-url', 'sidequest://audica/#' + url);
        } else if (etx === '.apk' || etx2 === '.apk') {
            // any file ending with apk.
            mainWindow.webContents.send('pre-open-url', { url, name });
            BrowserWindow.getAllWindows()
                .filter(b => b !== mainWindow)
                .forEach(b => b.close());
        } else if (~url.indexOf('ssl.hwcdn.net/') || ~url.indexOf('patreonusercontent.com/')) {
            //itch.io & patreon
            mainWindow.webContents.send('pre-open-url', { url, name });
            BrowserWindow.getAllWindows()
                .filter(b => b !== mainWindow)
                .forEach(b => b.close());
        } else {
            shell.openExternal(url);
        }
        item.cancel();
    });
}

async openFolder(folderType: FolderTypes) {
    const conf = loadCfg();
    switch (folderType) {
    case 'content':
      shell.openPath(conf.dir.content);
      break;
    case 'config':
      shell.openPath(conf.dir.config);
      break;
    }
  }

/**
 * Public: show documents inside Atom text editor or in external programs
 *
 * @param params The {ShowDocumentParams} received from the language server indicating the document to be displayed as
 *   well as other metadata.
 * @returns {Promise<ShowDocumentResult>} With a `success: boolean` property specifying if the operation was sucessful
 *   {@inheritDoc ShowDocumentParams}
 */
export async function showDocument(params: ShowDocumentParams): Promise<ShowDocumentResult> {
  try {
    if (!params.external) {
      // open using atom.workspace
      const view = await atom.workspace.open(Convert.uriToPath(params.uri), {
        activateItem: params.takeFocus,
        activatePane: params.takeFocus,
        pending: true,
        initialLine: params.selection?.start.line ?? 0,
        initialColumn: params.selection?.start.character ?? 0,
      })
      if (!view) {
        return { success: false }
      }
      if (view instanceof TextEditor && params.selection !== undefined) {
        view.selectToBufferPosition(Convert.positionToPoint(params.selection.end))
      }
    } else {
      // open using Electron
      shell.openExternal(params.uri, { activate: params.takeFocus })
    }
    return { success: true }
  } catch (e) {
    const error = e instanceof Error ? e.message : String(e)
    atom.notifications.addError(error)
    return { success: false }
  }
}

app.on('web-contents-created', (_, contents) => {
  // Angular router is ignored on `will-navigate` event
  contents.on('will-navigate', (event, url) => {
    // allow hot reload to work properly
    if (url !== appUrl) {
      event.preventDefault();
    }
  });

  contents.setWindowOpenHandler(({ url }) => {
    // open all blank href links using the OS default browser
    setImmediate(() => {
      shell.openExternal(url);
    });
    return { action: 'deny' };
  });
});

async function makeThemeMenu(themeService:ThemeService): Promise<MenuItemConstructorOptions> {
	// fetch themes
	let themes = await themeService.getThemes();

	let defaultThemeSubmenu: MenuItemConstructorOptions[] = themes.default.map(theme => ({
		label: theme.title,
		click: () => { themeService.setTheme({ type: "default", id: theme.id }); }
	}));

	let customThemeSubmenu: MenuItemConstructorOptions[] = themes.custom.map(theme => ({
		label: theme.title,
		click: () => { themeService.setTheme({ type: "custom", path: theme.path }); }
	}));

	let submenu: MenuItemConstructorOptions[] = [
		{
			label: "Open Themes Folder...",
			click: () => { shell.openPath(themeService.getThemeFolder()); }
		},
		{
			label: "Refresh Custom Themes",
			click: () => { themeService.refreshCustomThemes(); } },
		{ type: "separator" }
	];

	submenu = submenu.concat(
		defaultThemeSubmenu,
		[ { type: "separator" } ],
		customThemeSubmenu,
	);

	return { 
		label: "Theme",
		submenu
	};
}

createWindow = (): void => {
  // Create the browser window.
  mainWindow = new BrowserWindow({
    width: 1080,
    height: 900,
    icon: path.join(__dirname, 'assets/icon.png'), // Linux app icon
    webPreferences: {
      nodeIntegration: true,
      // May want to use app.getAppPath() instead
      // preload: path.join(__dirname, 'preload.js'), // use a preload script
      // preload: MAIN_WINDOW_PRELOAD_WEBPACK_ENTRY,
      // allowRunningInsecureContent: true,
      // webSecurity: false,
      // sandbox: false,
    }
  });

  // and load the index.html of the app.
  // mainWindow.loadURL(MAIN_WINDOW_WEBPACK_ENTRY);
  mainWindow.loadURL(`http://localhost:${uiPort}`)

  // Open the DevTools for `npm run start`
  if (!app.isPackaged) mainWindow.webContents.openDevTools()

  mainWindow.on('close', function () {
    console.debug('close')
    clearLocalStorage()
  })
  mainWindow.on('closed', function () {
    console.debug('closed')
    mainWindow = null
  })

  // Open links in browser instead of new electron window
  mainWindow.webContents.on('new-window', function(e: NewWindowWebContentsEvent, url: string) {
    e.preventDefault()
    shell.openExternal(url)
  })
}

ipcMain.on('open-data-folder', (event, arg: string) => {

    let userDataPath = getAppDataPath();

    let dataFolder = null;
    if (os.platform() === 'win32') {
        dataFolder = path.join(userDataPath, 'Blockcore', 'exos', arg);
        writeLog(dataFolder);
    } else {
        dataFolder = path.join(userDataPath, '.blockcore', 'exos', arg);
        writeLog(dataFolder);
    }

    shell.openPath(dataFolder);

    event.returnValue = 'OK';
});

export function SiteLauncher({ port, siteHash }: IProps): JSX.Element {
  const openUrl = useCallback((): void => {
    trackEvent(`CLICK_TO_OPEN_SITE_IN_BROWSER`, { siteHash })
    shell.openExternal(`http://localhost:${port}`)
  }, [port, siteHash])
  return (
    <GhostButton onClick={openUrl} size="S">
      localhost:{port}
    </GhostButton>
  )
}

revealPathMenuItem = (path: string) => {
	return new MenuItem({
		label: isMac ? 'Reveal in Finder' : 'Show folder',
		click() {
			shell.showItemInFolder(path)

			/**
			 * Generally, these calls should live in redux reducers, but given that we do not have
			 * reducers for these, this location makes the most sense
			 */
			reportAnalytics(ANALYTIC_EVENT_TYPES.CONTEXTMENU_REVEAL_IN_FINDER);
		}
	});
}

HelpContentTermsAndConditions: React.FC = observer(function HelpContentTermsAndConditions() {
    return (
        <>
            <Title>Terms & Conditions</Title>
            <TermsMeta>
                Version: {termsPackageJson.version} / Last updated: {termsPackageJson.updatedAt ?? ""}
            </TermsMeta>
            <Terms>
                <Small>
                    <ReactMarkdown
                        components={{
                            // eslint-disable-next-line react/display-name,@typescript-eslint/no-unused-vars
                            a: ({ node, ...props }) => (
                                <Anchor onClick={() => shell.openExternal(props.href as string)}>
                                    {props.href as string}
                                </Anchor>
                            ),
                        }}
                    >
                        {TermsEndUser}
                    </ReactMarkdown>
                </Small>
            </Terms>
        </>
    )
})

ngAfterViewInit(): void {
    let allLink = document.querySelectorAll('a');
    allLink.forEach(item => {
      item.addEventListener('click', (e) => {
        e.preventDefault();
        shell.openExternal(item.href);
      })
    })
  }

protected sendMessage(channelData: UpdaterChannelData, useSystemNotification: boolean) {
    if (useSystemNotification) {
      const notification = new Notification({ title: channelData.message, body: channelData.description || '' });
      if (channelData.url) {
        notification.on('click', () => {
          shell.openExternal(channelData.url as string);
        });
      }
      notification.show();
    } else {
      Ipc.sendMessage('app-updater-message', channelData);
    }
  }

SupportLink: React.FC = function () {
	return (
		<Typography align="center">
			Need help?{' '}
			<Link
				href="#"
				color="secondary"
				onClick={() => shell.openExternal('https://discord.gg/fFurRtJsZj')}
			>
				Get support
			</Link>
		</Typography>
	);
}

jest.mock('electron', () => {
  return {
    app: {
      quit: jest.fn(),
    },
    shell: {
      openExternal: jest.fn(),
    },
    Menu: {
      buildFromTemplate: jest.fn().mockReturnValue({
        popup: jest.fn(),
      }),
      setApplicationMenu: jest.fn(),
    },
  };
});

/**
 * Add navigation handlers.
 */
App.on("web-contents-created", (_, contents) => {
    contents.on("will-navigate", (event, navigationUrl) => {
        const parsedUrl = new URL(navigationUrl);

        if (parsedUrl.origin !== getBuildURL()) {
            event.preventDefault();
        }
    });

    contents.setWindowOpenHandler(({ url }) => {
        if (
            url.startsWith("http:") ||
            url.startsWith("https:") ||
            url.startsWith("mailto:")
        ) {
            setImmediate(() => {
                shell.openExternal(url);
            });
        }

        return { action: "deny" };
    });
});

async trash_compiled_contract(s: string): Promise<void> {
        const file = path.join(
            app.getPath('userData'),
            'workspaces',
            this.name,
            'compiled_contracts',
            s
        );
        return shell.trashItem(file);
    }

constructor() {
    // Conditional imports
    if (this.isElectron) {
      this.ipcRenderer = window.require('electron').ipcRenderer;
      this.webFrame = window.require('electron').webFrame;
      this.shell = window.require('electron').shell;

      // If you want to use remote object in renderer process, please set enableRemoteModule to true in main.ts
      this.remote = window.require('@electron/remote');

      this.childProcess = window.require('child_process');
      this.fs = window.require('fs');
    }
  }

createApiWindow: CreateWindowHandler = () => {
  const win = new BrowserWindow(OPTIONS)
  win.loadURL(URL)

  win.webContents.on('will-navigate', (event, url) => {
    if (/^http(s)?:/.test(url)) {
      event.preventDefault()
      shell.openExternal(url)
    }
  })

  registerFileManagerService(win)

  return win
}

private createFailedDialog(message: string, wikiFolderPath: string): void {
    const mainWindow = this.windowService.get(WindowNames.main);
    if (mainWindow !== undefined) {
      void dialog
        .showMessageBox(mainWindow, {
          title: i18n.t('Log.SynchronizationFailed'),
          message,
          buttons: ['OK', 'Github Desktop'],
          cancelId: 0,
          defaultId: 1,
        })
        .then(async ({ response }) => {
          if (response === 1) {
            try {
              const result = await this.nativeService.openInGitGuiApp(wikiFolderPath);
              if (!result) {
                throw new Error('open download site');
              }
            } catch {
              await shell.openExternal(githubDesktopUrl);
            }
          }
        })
        .catch((error) => logger.error('createFailedDialog failed', error));
    }
  }

async run() {
    try {
      const data = (
        await axios.get('https://api.github.com/repos/3Speaknetwork/3Speak-app/releases/latest')
      ).data
      if (data.id) {
        const tag_name = data['tag_name']
        if (compareVersions.compare(tag_name, version, '>')) {
          //Update available
          for (const asset of data.assets) {
            if (asset.name.includes('Setup') && asset.name.includes('exe') && isWin) {
              const tmpDir = tmp.dirSync()
              const filePath = Path.join(tmpDir.name, asset.name)
              const file = fs.createWriteStream(filePath)
              const response = await axios({
                method: 'get',
                url: asset.browser_download_url,
                responseType: 'stream',
              })
              await new Promise((resolve, reject) => {
                response.data.pipe(file)
                let error = null
                file.on('error', (err) => {
                  error = err
                  // type error: writer not declared?
                  //     writer.close();
                  reject(err)
                })
                file.on('close', () => {
                  if (!error) {
                    resolve(true)
                  }
                })
              })

              let dialogResponse = dialog.showMessageBoxSync({
                type: 'question',
                buttons: ['Remind me later', 'View release log', 'Update'],
                title: 'Update available',
                message: `New update available version ${tag_name.slice(
                  1,
                )}\nWould you like to update your local 3Speak installation?`,
              })

              if (dialogResponse === 2) {
                spawn(filePath, [], { detached: true })
                app.exit(1)
                break
              } else if (dialogResponse === 1) {
                void shell.openExternal(data.html_url)
              } else {
                break
              }

              dialogResponse = dialog.showMessageBoxSync({
                type: 'question',
                buttons: ['Remind me later', 'Update'],
                title: 'Update available',
                message: `New update available version ${tag_name.slice(
                  1,
                )}\nWould you like to update your local 3Speak installation?`,
              })
              if (dialogResponse === 1) {
                spawn(filePath, [], { detached: true })
                app.exit(1)
              }
              break
            }
          }
        }
      }
    } catch (ex) {
      //Shouldn't be important if request fails... But still should be logged.
      console.error(`Error in autoupdater`, ex.message)
    }
  }

createWindow = async () => {
    win = new BrowserWindow({
        title: "BlueBubbles Server",
        useContentSize: true,
        width: 1080,
        minWidth: 850,
        height: 750,
        minHeight: 600,
        webPreferences: {
            nodeIntegration: true, // Required in new electron version
            contextIsolation: false // Required or else we get a `global` is not defined error
        }
    });

    if (process.env.NODE_ENV === "development") {
        process.env.ELECTRON_DISABLE_SECURITY_WARNINGS = "1"; // eslint-disable-line require-atomic-updates
        win.loadURL(`http://localhost:3000`);
    } else {
        win.loadURL(`file://${path.join(__dirname, "index.html")}`);
    }

    win.on("closed", () => {
        win = null;
    });

    // Prevent the title from being changed from BlueBubbles
    win.on("page-title-updated", evt => {
        evt.preventDefault();
    });

    // Make links open in the browser
    win.webContents.setWindowOpenHandler((details: HandlerDetails) => {
        shell.openExternal(details.url);
        return { action: 'deny' };
    });

    // Hook onto when we load the UI
    win.webContents.on("dom-ready", async () => {
        win.webContents.send("config-update", Server().repo.config);
    });

    // Set the new window in the Server()
    Server(win);
}

ipcMain.on("Visit-Mod-Social", async (event, arg) => {
    const socialLink = mod_manager.currentModData[arg];
    if (socialLink != null && socialLink != "") {
        shell.openExternal(socialLink);
    }
});

handlerDirectGitHub() {
    shell.openExternal('https://github.com/EdurtIO/dbm');
  }