feat: add typescript-webpack template

packages/api/core/package.json

@@ -39,6 +39,7 @@
  "@electron-forge/shared-types": "6.0.0-beta.46",
  "@electron-forge/template-webpack": "6.0.0-beta.46",
  "@electron-forge/template-typescript": "6.0.0-beta.46",
+ "@electron-forge/template-typescript-webpack": "6.0.0-beta.46",
  "@electron/get": "^1.6.0",
  "colors": "^1.4.0",
  "cross-spawn-promise": "^0.10.1",

packages/api/core/test/slow/api_spec_slow.ts

@@ -179,16 +179,60 @@ describe(`electron-forge API (with installer=${nodeInstaller})`, () => {
  const expectedFiles = [
  'tsconfig.json',
  'tslint.json',
+ path.join('src', 'index.ts'),
  ];
+
  for (const filename of expectedFiles) {
  await expectProjectPathExists(filename, 'file');
  }
  });
 
- it('should convert the main process file to typescript', async () => {
- await expectProjectPathNotExists(path.join('src', 'index.js'), 'file');
- await expectProjectPathExists(path.join('src', 'index.ts'), 'file');
- expect((await fs.readFile(path.join(dir, 'src', 'index.ts'))).toString()).to.match(/Electron.BrowserWindow/);
+ describe('lint', () => {
+ it('should initially pass the linting process', async () => {
+ try {
+ await forge.lint({ dir });
+ } catch (err) {
+ if (err.stdout) {
+ // eslint-disable-next-line no-console
+ console.error('STDOUT:', err.stdout.toString());
+ // eslint-disable-next-line no-console
+ console.error('STDERR:', err.stderr.toString());
+ }
+ throw err;
+ }
+ });
+ });
+
+ after(async () => {
+ await fs.remove(dir);
+ });
+ });
+
+ describe('init (with typescript-webpack templater)', () => {
+ before(ensureTestDirIsNonexistent);
+
+ it('should succeed in initializing the typescript template', async () => {
+ await forge.init({
+ dir,
+ template: 'typescript-webpack',
+ });
+ });
+
+ it('should copy the appropriate template files', async () => {
+ const expectedFiles = [
+ 'tsconfig.json',
+ 'tslint.json',
+ 'webpack.main.config.js',
+ 'webpack.renderer.config.js',
+ 'webpack.rules.js',
+ 'webpack.plugins.js',
+ path.join('src', 'index.ts'),
+ path.join('src', 'renderer.ts'),
+ ];
+
+ for (const filename of expectedFiles) {
+ await expectProjectPathExists(filename, 'file');
+ }
  });
 
  describe('lint', () => {

packages/template/typescript-webpack/package.json

@@ -0,0 +1,21 @@
+{
+ "name": "@electron-forge/template-typescript-webpack",
+ "version": "6.0.0-beta.46",
+ "description": "Typescript-Webpack template for Electron Forge",
+ "repository": "https://github.com/electron-userland/electron-forge",
+ "author": "Shelley Vohr <shelley.vohr@gmail.com>",
+ "license": "MIT",
+ "main": "dist/TypeScriptWebpackTemplate.js",
+ "typings": "dist/TypeScriptWebpackTemplate.d.ts",
+ "scripts": {
+ "test": "echo No Tests"
+ },
+ "engines": {
+ "node": ">= 8.0"
+ },
+ "dependencies": {
+ "@electron-forge/async-ora": "6.0.0-beta.46",
+ "@electron-forge/shared-types": "6.0.0-beta.46",
+ "fs-extra": "^8.1.0"
+ }
+}

packages/template/typescript-webpack/src/TypeScriptWebpackTemplate.ts

@@ -0,0 +1,96 @@
+import { ForgeTemplate } from '@electron-forge/shared-types';
+import { asyncOra } from '@electron-forge/async-ora';
+
+import fs from 'fs-extra';
+import path from 'path';
+
+const currentVersion = require('../package').version;
+
+const copyTemplateFile = async (destDir: string, basename: string) => {
+ const templateDir = path.resolve(__dirname, '..', 'tmpl');
+ await fs.copy(path.join(templateDir, basename), path.resolve(destDir, basename));
+};
+
+const updateFileByLine = async (
+ inputPath: string,
+ lineHandler: (line: string) => string,
+ outputPath: string | undefined = undefined,
+) => {
+ const fileContents = (await fs.readFile(inputPath, 'utf8')).split('\n').map(lineHandler).join('\n');
+ await fs.writeFile(outputPath || inputPath, fileContents);
+ if (outputPath !== undefined) {
+ await fs.remove(inputPath);
+ }
+};
+
+class TypeScriptWebpackTemplate implements ForgeTemplate {
+ public devDependencies = [
+ `@electron-forge/plugin-webpack@${currentVersion}`,
+ '@marshallofsound/webpack-asset-relocator-loader@^0.5.0',
+ 'css-loader@^3.0.0',
+ 'node-loader@^0.6.0',
+ 'ts-loader@^6.2.1',
+ 'style-loader@^0.23.1',
+ 'typescript@^3.7.0',
+ 'tslint@^5.20.0',
+ 'fork-ts-checker-webpack-plugin@^3.1.1',
+ ];
+
+ public initializeTemplate = async (directory: string) => {
+ await asyncOra('Setting up Forge configuration', async () => {
+ const packageJSONPath = path.resolve(directory, 'package.json');
+ const packageJSON = await fs.readJson(packageJSONPath);
+
+ packageJSON.main = '.webpack/main';
+ packageJSON.config.forge.plugins = packageJSON.config.forge.plugins || [];
+ packageJSON.config.forge.plugins.push([
+ '@electron-forge/plugin-webpack',
+ {
+ mainConfig: './webpack.main.config.js',
+ renderer: {
+ config: './webpack.renderer.config.js',
+ entryPoints: [{
+ html: './src/index.html',
+ js: './src/renderer.ts',
+ name: 'main_window',
+ }],
+ },
+ },
+ ]);
+
+ // Configure scripts for TS template
+ packageJSON.scripts.lint = 'tslint -c tslint.json -p tsconfig.json';
+
+ await fs.writeJson(packageJSONPath, packageJSON, { spaces: 2 });
+ });
+
+ await asyncOra('Setting up TypeScript configuration', async () => {
+ const filePath = (fileName: string) => path.join(directory, 'src', fileName);
+
+ // Copy Webpack files
+ await copyTemplateFile(directory, 'webpack.main.config.js');
+ await copyTemplateFile(directory, 'webpack.renderer.config.js');
+ await copyTemplateFile(directory, 'webpack.rules.js');
+ await copyTemplateFile(directory, 'webpack.plugins.js');
+
+ await updateFileByLine(path.resolve(directory, 'src', 'index.html'), (line) => {
+ if (line.includes('link rel="stylesheet"')) return '';
+ return line;
+ });
+
+ // Copy tsconfig with a small set of presets
+ await copyTemplateFile(directory, 'tsconfig.json');
+
+ // Copy tslint config with recommended settings
+ await copyTemplateFile(directory, 'tslint.json');
+
+ // Remove index.js and replace with index.ts
+ await fs.remove(filePath('index.js'));
+ await copyTemplateFile(path.join(directory, 'src'), 'index.ts');
+
+ await copyTemplateFile(path.join(directory, 'src'), 'renderer.ts');
+ });
+ }
+}
+
+export default new TypeScriptWebpackTemplate();

packages/template/typescript-webpack/tmpl/index.ts

@@ -0,0 +1,58 @@
+import { app, BrowserWindow } from 'electron';
+declare const MAIN_WINDOW_WEBPACK_ENTRY: any;
+
+// Handle creating/removing shortcuts on Windows when installing/uninstalling.
+if (require('electron-squirrel-startup')) { // eslint-disable-line global-require
+ app.quit();
+}
+
+// Keep a global reference of the window object, if you don't, the window will
+// be closed automatically when the JavaScript object is garbage collected.
+let mainWindow: Electron.BrowserWindow;
+
+const createWindow = () => {
+ // Create the browser window.
+ mainWindow = new BrowserWindow({
+ height: 600,
+ width: 800,
+ });
+
+ // and load the index.html of the app.
+ mainWindow.loadURL(MAIN_WINDOW_WEBPACK_ENTRY);
+
+ // Open the DevTools.
+ mainWindow.webContents.openDevTools();
+
+ // Emitted when the window is closed.
+ mainWindow.on('closed', () => {
+ // Dereference the window object, usually you would store windows
+ // in an array if your app supports multi windows, this is the time
+ // when you should delete the corresponding element.
+ mainWindow = null;
+ });
+};
+
+// This method will be called when Electron has finished
+// initialization and is ready to create browser windows.
+// Some APIs can only be used after this event occurs.
+app.on('ready', createWindow);
+
+// Quit when all windows are closed.
+app.on('window-all-closed', () => {
+ // On OS X it is common for applications and their menu bar
+ // to stay active until the user quits explicitly with Cmd + Q
+ if (process.platform !== 'darwin') {
+ app.quit();
+ }
+});
+
+app.on('activate', () => {
+ // On OS X it's common to re-create a window in the app when the
+ // dock icon is clicked and there are no other windows open.
+ if (mainWindow === null) {
+ createWindow();
+ }
+});
+
+// In this file you can include the rest of your app's specific main process
+// code. You can also put them in separate files and import them here.

packages/template/typescript-webpack/tmpl/renderer.ts

@@ -0,0 +1,31 @@
+/**
+ * This file will automatically be loaded by webpack and run in the "renderer" context.
+ * To learn more about the differences between the "main" and the "renderer" context in
+ * Electron, visit:
+ *
+ * https://electronjs.org/docs/tutorial/application-architecture#main-and-renderer-processes
+ *
+ * By default, Node.js integration in this file is disabled. When enabling Node.js integration
+ * in a renderer process, please be aware of potential security implications. You can read
+ * more about security risks here:
+ *
+ * https://electronjs.org/docs/tutorial/security
+ *
+ * To enable Node.js integration in this file, open up `main.js` and enable the `nodeIntegration`
+ * flag:
+ *
+ * ```
+ * // Create the browser window.
+ * mainWindow = new BrowserWindow({
+ * width: 800,
+ * height: 600,
+ * webPreferences: {
+ * nodeIntegration: true
+ * }
+ * });
+ * ```
+ */
+
+import './index.css';
+
+console.log('👋 This message is being logged by "renderer.js", included via webpack');

packages/template/typescript-webpack/tmpl/tsconfig.json

@@ -0,0 +1,20 @@
+{
+ "compilerOptions": {
+ "allowJs": true,
+ "module": "commonjs",
+ "skipLibCheck": true,
+ "esModuleInterop": true,
+ "noImplicitAny": true,
+ "sourceMap": true,
+ "baseUrl": ".",
+ "outDir": "dist",
+ "moduleResolution": "node",
+ "resolveJsonModule": true,
+ "paths": {
+ "*": ["node_modules/*"]
+ }
+ },
+ "include": [
+ "src/**/*"
+ ]
+}

packages/template/typescript-webpack/tmpl/tslint.json

@@ -0,0 +1,14 @@
+{
+ "defaultSeverity": "error",
+ "extends": [
+ "tslint:latest"
+ ],
+ "jsRules": {},
+ "rules": {
+ "no-implicit-dependencies": [true, "dev"],
+ "no-var-requires": false,
+ "quotemark": [true, "single"],
+ "no-console": false
+ },
+ "rulesDirectory": []
+}

packages/template/typescript-webpack/tmpl/webpack.main.config.js

@@ -0,0 +1,14 @@
+module.exports = {
+ /**
+ * This is the main entry point for your application, it's the first file
+ * that runs in the main process.
+ */
+ entry: './src/index.ts',
+ // Put your normal webpack config below here
+ module: {
+ rules: require('./webpack.rules'),
+ },
+ resolve: {
+ extensions: ['.js', '.ts', '.jsx', '.tsx', '.css', '.json']
+ },
+};

packages/template/typescript-webpack/tmpl/webpack.plugins.js

@@ -0,0 +1,7 @@
+const ForkTsCheckerWebpackPlugin = require('fork-ts-checker-webpack-plugin');
+
+module.exports = [
+ new ForkTsCheckerWebpackPlugin({
+ async: false
+ })
+];

packages/template/typescript-webpack/tmpl/webpack.renderer.config.js

@@ -0,0 +1,17 @@
+const rules = require('./webpack.rules');
+const plugins = require('./webpack.plugins');
+
+rules.push({
+ test: /\.css$/,
+ use: [{ loader: 'style-loader' }, { loader: 'css-loader' }],
+});
+
+module.exports = {
+ module: {
+ rules,
+ },
+ plugins: plugins,
+ resolve: {
+ extensions: ['.js', '.ts', '.jsx', '.tsx', '.css']
+ },
+};

packages/template/typescript-webpack/tmpl/webpack.rules.js

@@ -0,0 +1,27 @@
+module.exports = [
+ // Add support for native node modules
+ {
+ test: /\.node$/,
+ use: 'node-loader',
+ },
+ {
+ test: /\.(m?js|node)$/,
+ parser: { amd: false },
+ use: {
+ loader: '@marshallofsound/webpack-asset-relocator-loader',
+ options: {
+ outputAssetBase: 'native_modules',
+ },
+ },
+ },
+ {
+ test: /\.tsx?$/,
+ exclude: /(node_modules|.webpack)/,
+ loaders: [{
+ loader: 'ts-loader',
+ options: {
+ transpileOnly: true
+ }
+ }]
+ },
+];