added nextjs base code

Author: jambulud

.gitignore

@@ -0,0 +1,56 @@
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+
+# dependencies
+/node_modules
+/.pnp
+.pnp.js
+
+# testing
+/coverage
+
+# next.js
+/.next/
+/out/
+/renderer/.next/
+/renderer/out/
+/main/out/
+/dist/
+
+# production
+/build
+
+# misc
+.DS_Store
+.env*
+
+# debug
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+### react ###
+.DS_*
+*.log
+logs
+**/*.backup.*
+**/*.back.*
+
+node_modules
+bower_componets
+
+*.sublime*
+
+psd
+thumb
+sketch
+
+### VisualStudioCode ###
+.vscode/*
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+
+### VisualStudioCode Patch ###
+# Ignore all local history of files
+.history

README.md

@@ -0,0 +1,14 @@
+# Nextjs + Electron + Typescript application example
+
+## How to use
+
+* Download or clone this project
+* run `npm install` in the root folder of the project
+
+## Start
+
+* run `npm run start`
+
+## Build executable file
+
+* run `npm run dist`

main/decorators/process.ts

@@ -0,0 +1,33 @@
+import { ipcMain, IpcMainEvent } from 'electron';
+
+function Process(path: string) { // this is the decorator factory
+    return function (
+        target: Object,
+        propertyName: string,
+        propertyDescriptor: PropertyDescriptor): PropertyDescriptor {
+        const method = propertyDescriptor.value;
+        
+        propertyDescriptor.value = function (...args: any[]) {
+            let result: any;
+            const eventHandler = (event: IpcMainEvent, ...eventArgs: any[]) => {
+                Promise.resolve(method.apply(this, eventArgs)).then(result => {
+                    const r = JSON.stringify(result);
+
+                    const params = eventArgs.map(a => JSON.stringify(a)).join();
+                    console.log(`Path: ${path}\t---> Call: ${propertyName}(${params}) => ${r}`)
+                    event.sender.send(path, result)
+                });
+            }
+
+            // invoke foo() and get its return value
+            ipcMain.removeListener(path, eventHandler);
+            ipcMain.on(path, eventHandler);
+
+            // return the result of invoking the method
+            return result;
+        }
+        return propertyDescriptor;
+    };
+}
+
+export default Process;

main/global.d.ts

@@ -0,0 +1,5 @@
+declare module NodeJS  {
+    interface Global {
+        ipcRenderer: any;
+    }
+}

main/index.ts

@@ -0,0 +1,82 @@
+// Native
+import { join } from 'path';
+import { format } from 'url';
+import { IpcMainEvent } from 'electron';
+import { spawn, exec, StdioOptions, SpawnOptions } from 'child_process';
+
+// Packages
+import { BrowserWindow, app, ipcMain } from 'electron';
+import isDev from 'electron-is-dev';
+import prepareNext from 'electron-next';
+
+// Other dependencies
+import { TerminalService } from './services/terminal.service';
+
+const terminalService = new TerminalService();
+
+// Prepare the renderer once the app is ready
+app.on('ready', async () => {
+  await prepareNext('./renderer')
+
+  const mainWindow = new BrowserWindow({
+    width: 1000,
+    height: 600,
+    webPreferences: {
+      nodeIntegration: false,
+      preload: join(__dirname, 'preload.js'),
+    },
+  })
+
+  if (isDev) {
+    mainWindow.webContents.openDevTools();
+  }
+
+  const url = isDev
+    ? 'http://localhost:8000/start'
+    : format({
+      pathname: join(__dirname, '../../renderer/start.html'),
+      protocol: 'file:',
+      slashes: true,
+    })
+
+  mainWindow.loadURL(url)
+})
+
+// Quit the app once all windows are closed
+app.on('window-all-closed', app.quit);
+
+terminalService.ls();
+terminalService.mkdir(null);
+terminalService.rmdir(null);
+terminalService.pwd();
+terminalService.openDialog();
+terminalService.mvnInstall();
+terminalService.allCommands(null, null);
+
+/*  */
+
+const eventHandler = (event: IpcMainEvent, ...eventArgs: any[]) => {
+  const command = eventArgs[0];
+  const cwd = eventArgs[1];
+  console.log('received message:' + command)
+
+  if (!command) event.sender.send('terminal/powershell', '');
+  const stdioOptions: StdioOptions = ['pipe', 'pipe', 'pipe'];
+
+  let options: SpawnOptions = { stdio: stdioOptions };
+  options = cwd ? { ...options, cwd } : options
+  const terminal = spawn(`powershell.exe`, [], options);
+
+  terminal.stdout.on('data', data => {
+    console.log('sending data: ' + data.toString())
+    event.sender.send('terminal/powershell', data.toString())
+  });
+  terminal.stderr.on('data', data => console.error(data.toString()));
+  terminal.on('close', () => {
+    console.log('closed stream')
+  });
+
+  terminal.stdin.write(command + "\n")
+}
+
+ipcMain.on('terminal/powershell', eventHandler);

main/preload.ts

@@ -0,0 +1,8 @@
+import { ipcRenderer } from 'electron'
+
+
+// Since we disabled nodeIntegration we can reintroduce
+// needed node functionality here
+process.once('loaded', () => {
+  global.ipcRenderer = ipcRenderer;
+})

main/services/terminal.service.ts

@@ -0,0 +1,132 @@
+import { spawn, exec, ChildProcessWithoutNullStreams } from 'child_process';
+import Process from '../decorators/process';
+import { dialog } from 'electron';
+
+interface Command {
+    command: string,
+    arguments: string[],
+}
+
+export const CMD_LS: Command = { command: 'ls', arguments: ['-lh'] };
+
+export const CMD_MKDIR: Command = { command: 'mkdir', arguments: [] };
+
+export const CMD_RMDIR: Command = { command: 'rmdir', arguments: [] };
+
+export const CMD_PWD: Command = { command: 'pwd', arguments: [] };
+
+export const POWERSHELL: Command = { command: 'cmd.exe', arguments: ['mvn', '--help'] };
+
+const MAX_BUFFER = 1024 * 500; /* 500 KB */
+
+export class TerminalService {
+
+    private standardHandler(spawn: ChildProcessWithoutNullStreams): Promise<{}> {
+        return new Promise((resolve, reject) => {
+            let result = '';
+            let error = ''
+            spawn.stdout.on('data', data => { result += data });
+            spawn.stderr.on('data', data => { error += data });
+            spawn.on('close', () => {
+                if (error) {
+                    reject(result + error)
+                } else {
+                    resolve(result + error)
+                }
+            });
+            spawn.stdin.end()
+        });
+    }
+
+    @Process('terminal/ls')
+    async ls() {
+        const ls = spawn(CMD_LS.command, CMD_LS.arguments)
+        const result = await this.standardHandler(ls);
+
+        return result;
+    }
+
+    @Process('terminal/mkdir')
+    async mkdir(dirname: string) {
+        const mkdir = spawn(CMD_MKDIR.command, [dirname]);
+        try {
+            const result = await this.standardHandler(mkdir);
+
+            return result;
+        } catch (error) {
+            return error;
+        }
+    }
+
+    @Process('terminal/rmdir')
+    async rmdir(dirname: string) {
+        const rmdir = spawn(CMD_RMDIR.command, [dirname]);
+        try {
+            const result = await this.standardHandler(rmdir);
+            return result;
+
+        } catch (error) {
+            return error;
+        }
+    }
+
+    @Process('terminal/pwd')
+    async pwd() {
+        const pwd = spawn(CMD_PWD.command, CMD_PWD.arguments);
+
+        try {
+            const result = await this.standardHandler(pwd);
+            return result;
+
+        } catch (error) {
+            return error;
+        }
+    }
+
+    @Process('terminal/open-dialog')
+    async openDialog() {
+        const res = await dialog.showOpenDialog({ properties: ['openDirectory'] });
+        return res;
+    }
+
+
+    @Process('terminal/mvn-install')
+    async mvnInstall(cwd?: string) {
+        const options = cwd ? { cwd, maxBuffer: MAX_BUFFER } : undefined
+        let mvn = exec('mvn --help', options);
+
+        try {
+            const result = await this.standardHandler(mvn);
+            return result;
+
+        } catch (error) {
+            return error;
+        }
+    }
+
+    @Process('terminal/all-commands')
+    async allCommands(command: string, cwd?: string) {
+        if (!command) return '';
+
+        const options = cwd ? { cwd, maxBuffer: MAX_BUFFER } : undefined
+        let mvn = exec(command, options);
+
+        try {
+            const result = await this.standardHandler(mvn);
+            return new ReturnMessage(false, result);
+
+        } catch (error) {
+            return new ReturnMessage(true, error);
+        }
+    }
+}
+
+class ReturnMessage {
+    error: boolean;
+    body: any;
+
+    constructor(error: boolean, body: any) {
+        this.error = error;
+        this.body = body;
+    }
+}

main/tsconfig.json

@@ -0,0 +1,19 @@
+{
+    "compilerOptions": {
+        "target": "es5",
+        "allowJs": true,
+        "skipLibCheck": true,
+        "strict": false,
+        "esModuleInterop": true,
+        "module": "commonjs",
+        "moduleResolution": "node",
+        "resolveJsonModule": true,
+        "isolatedModules": true,
+        "outDir": "./out",
+        "experimentalDecorators": true,
+    },
+    "exclude": [
+        "node_modules"
+    ],
+    "include": ["./**/*.ts"],
+}