Table of Contents for

Electron in Action

Table of Contents

Copyright

Brief Table of Contents

Table of Contents

Preface

Acknowledgments

About this book

About the cover illustration

1. Getting started with Electron

Chapter 1. Introducing Electron

1.1. What is Electron?

1.1.1. What is the Chromium Content Module?

1.1.2. What is Node.js?

1.2. Who’s using Electron?

1.3. What do I need to know?

1.4. Why should I use Electron?

1.4.1. Building on your existing skill set

1.4.2. Access to native operating system APIs

1.4.3. Enhanced privileges and looser restrictions

1.4.4. Accessing Node from the browser context

1.4.5. Offline first

1.5. How does Electron work?

1.5.1. The main process

1.5.2. Renderer processes

1.6. Electron vs. NW.js

Summary

Chapter 2. Your first Electron application

2.1. Building a bookmark list application

2.1.1. Structuring the Electron application

2.1.2. package.json

2.1.3. Downloading and installing Electron in our project

2.2. Working with the main process

2.3. Creating a renderer process

2.3.1. Loading code from the renderer process

2.3.2. Requiring files in the renderer process

2.3.3. Adding styles in the renderer process

2.4. Implementing the UI

2.4.1. Making cross-origin requests in Electron

2.4.2. Parsing responses

2.4.3. Storing responses with web storage APIs

2.4.4. Displaying request results

2.4.5. The unhappy path

2.4.6. An unexpected bug

Summary

2. Building cross-platform applications with Electron

Chapter 3. Building a notes application

3.1. Defining our application

3.2. Laying the foundation

3.3. Bootstrapping the application

3.3.1. Implementing the UI

3.3.2. Gracefully displaying the browser window

3.4. Implementing the base functionality

3.5. Debugging an Electron application

3.5.1. Debugging renderer processes

3.5.2. Debugging the main process

3.5.3. Debugging the main process with Visual Studio Code

Summary

Chapter 4. Using native file dialog boxes and facilitating interprocess communication

4.1. Triggering native file dialog boxes

4.2. Reading files using Node

4.2.1. Scoping the Open File dialog

4.2.2. Implementing dialog sheets in macOS

4.3. Facilitating interprocess communication

4.3.1. Introducing the remote module

4.4. Triggering the Open File function using interprocess communication

4.4.1. Understanding the CommonJS require system

4.4.2. Requiring functionality from another process

4.5. Sending content from the main process to the renderer process

4.5.1. Sending the file contents to the renderer contents

Summary

Chapter 5. Working with multiple windows

5.1. Creating and managing multiple windows

5.1.1. Communicating between the main process and multiple windows

5.1.2. Passing a reference to the current window to the main process

5.2. Improving the user experience of creating new windows

5.3. Integrating with macOS

Summary

Chapter 6. Working with files

6.1. Keeping track of the current file

6.1.1. Updating the window title based on the current file

6.1.2. Determining whether the current file has changed

6.1.3. Enabling the Save and Revert buttons in the UI

6.1.4. Updating the represented file on macOS

6.2. Tracking recently opened files

6.3. Saving files

6.3.1. Exporting the rendered HTML output

6.3.2. Common paths

6.3.3. Saving files from the renderer process

6.3.4. Saving the current file

6.3.5. Reverting files

6.4. Opening files using drag and drop

6.4.1. Ignoring dropped files everywhere else

6.4.2. Providing visual feedback

6.4.3. Opening dropped files

6.5. Watching files for changes

6.6. Prompting the user before discarding changes

Summary

Chapter 7. Building application and context menus

7.1. Replacing and replicating the default menu

7.1.1. macOS and the case of the missing Edit menu

7.1.2. The hidden cost of replacing Electron’s default menu

7.1.3. Implementing the Edit and Window menus

7.1.4. Defining menu item roles and keyboard shortcuts

7.1.5. Restoring the application menu on macOS

7.1.6. Adding a Help menu

7.2. Adding application-specific menu functionality

7.2.1. Handling the case of having no focused window

7.3. Building context menus

Summary

Chapter 8. Further operating system integration and dynamically enabling menu items

8.1. Using the shell module from the UI in the renderer process

8.2. Using the shell module in the application menu

8.2.1. Additional features of the Electron shell module

8.3. Accessing the shell module from a context menu

8.3.1. Deciding between putting functionality in a menu or in the browser

8.3.2. Deciding between putting functionality in the application or context menu

8.4. Disabling menu items when appropriate

8.4.1. Dynamically enabling and disabling menu items in the context menu

8.4.2. Dynamically enabling and disabling menu items in the application menu

Summary

Chapter 9. Introducing the tray module

9.1. Getting started with Clipmaster

9.2. Creating an application with the tray module

9.2.1. Using the correct icon for macOS and Windows

9.2.2. Supporting dark mode in macOS

9.2.3. Reading from the clipboard and storing clippings

9.3. Reading from and writing to the clipboard

9.3.1. Writing to the clipboard

9.3.2. Handling edge cases

9.4. Registering global shortcuts

9.4.1. Checking registrations and unregistering global shortcuts

9.5. Displaying notifications

9.6. Switching menu bar icons when pressed in macOS

9.7. Completed code

Summary

Chapter 10. Building applications with the menubar library

10.1. Starting an application with menubar

10.2. Adding clippings to the UI

10.3. Working with clippings in the application

10.3.1. Preventing memory leaks using event delegation

10.3.2. Removing a clipping

10.3.3. Writing to the clipboard

10.4. Publishing clippings

10.4.1. Setting up request

10.5. Displaying notifications and registering global shortcuts

10.5.1. Registering global shortcuts

10.5.2. Solving for the edge case that occurs if the window has never been shown

10.6. Adding a secondary menu

Summary

Chapter 11. Using transpilers and frameworks

11.1. Introducing electron-compile

11.2. Laying the application’s foundation

11.3. Building the UI in React

11.3.1. The Application component

11.3.2. Displaying the lists of items

11.4. Adding new items

11.5. Live reload and hot module reloading

11.5.1. Enabling live reload

11.5.2. Setting up hot module reloading

Summary

Chapter 12. Persisting user data and using native Node.js modules

12.1. Storing data in an SQLite database

12.1.1. Using the right versions with electron-rebuild

12.1.2. Setting up SQLite and Knex.js

12.1.3. Hooking the database into React

12.1.4. Fetching all of the items from the database

12.1.5. Adding items to the database

12.1.6. Updating items in the database

12.1.7. Deleting items

12.1.8. Storing the database in the right place

12.2. IndexedDB

12.2.1. Creating a store with IndexedDB

12.2.2. Getting data from IndexedDB

12.2.3. Writing data to IndexedDB

12.2.4. Connecting the database to the UI

Summary

Chapter 13. Testing applications with Spectron

13.1. Introducing Spectron

13.2. Getting comfortable with Spectron and WebdriverIO

13.3. Setting up Spectron and the test runner

13.4. Writing asynchronous tests using Spectron

13.4.1. Waiting for the window to load

13.4.2. Testing Electron BrowserWindow APIs

13.4.3. Traversing and testing the DOM with Spectron

13.4.4. Controlling Electron’s APIs with Spectron

Summary

3. Deploying Electron applications

Chapter 14. Building applications for deployment

14.1. Introducing Electron Packager

14.1.1. Setting up Electron Packager

14.1.2. Configuring the output directory

14.1.3. Configuring the application’s name and version

14.1.4. Updating the application icon

14.1.5. Building for multiple operating systems

14.2. Using asar

14.3. Electron Forge

14.3.1. Importing an Electron application into Electron Forge

14.3.2. Building the application with Electron Forge

Summary

Chapter 15. Releasing and updating applications

15.1. Collecting crash reports

15.1.1. Setting up the crash reporter

15.1.2. Setting up a server to receive crash reports

15.1.3. Reporting uncaught exceptions

15.2. Signing your applications

15.2.1. Signing applications for macOS

15.2.2. Building an installer and code signing on Windows

15.3. Automatically updating applications

15.3.1. Setting up automatic updates in Electron

15.3.2. Setting up a server for automatic updates

Summary

Chapter 16. Distributing your application through the Mac App Store

16.1. Submitting your application to the Mac App Store

16.1.1. Signing the application

16.1.2. Registering your application with the Mac App Store

16.1.3. Adding the application to iTunes Connect

16.1.4. Packaging your application for the Mac App Store

16.1.5. Configuring application categories

16.1.6. Register the application to open a file type

16.2. Validating and uploading your application

16.3. Finishing touches

Summary

 Appendix. Code samples from Fire Sale and Clipmaster 9000

Code from the end of chapter 6

Code from the end of chapter 7

Code from the end of chapter 8

Completed code from the end of chapter 10

Index

List of Figures

List of Tables

List of Listings