electron-process-type - npm Package Compare versions

Comparing version 2.5.0 to 3.0.0

lib/electron-process-type-util.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const isBrowser = (typeof window !== 'undefined') && (typeof window.document !== 'undefined');
+var ElectronProcessTypeFlags;
+(function (ElectronProcessTypeFlags) {
+    ElectronProcessTypeFlags[ElectronProcessTypeFlags["Node"] = 0] = "Node";
+    ElectronProcessTypeFlags[ElectronProcessTypeFlags["Browser"] = 1] = "Browser";
+    ElectronProcessTypeFlags[ElectronProcessTypeFlags["Electron"] = 16] = "Electron";
+    ElectronProcessTypeFlags[ElectronProcessTypeFlags["ElectronNode"] = 16] = "ElectronNode";
+    ElectronProcessTypeFlags[ElectronProcessTypeFlags["ElectronBrowser"] = 17] = "ElectronBrowser";
+    ElectronProcessTypeFlags[ElectronProcessTypeFlags["Main"] = 256] = "Main";
+    ElectronProcessTypeFlags[ElectronProcessTypeFlags["ElectronMainNode"] = 272] = "ElectronMainNode";
+})(ElectronProcessTypeFlags = exports.ElectronProcessTypeFlags || (exports.ElectronProcessTypeFlags = {}));
+function IsProcessNode() {
+    const electronProcessType = GetElectronProcessType();
+    return electronProcessType & ElectronProcessTypeFlags.Node;
+}
+exports.IsProcessNode = IsProcessNode;
+function IsProcessBrowser() {
+    const electronProcessType = GetElectronProcessType();
+    return electronProcessType & ElectronProcessTypeFlags.Browser;
+}
+exports.IsProcessBrowser = IsProcessBrowser;
+function IsProcessElectron() {
+    const electronProcessType = GetElectronProcessType();
+    return electronProcessType & ElectronProcessTypeFlags.Electron;
+}
+exports.IsProcessElectron = IsProcessElectron;
 function GetElectronProcessType() {
-    let electronProcessType = 'node';
+    let electronProcessType = ElectronProcessTypeFlags.Node;
     const processType = process.type;
     if (processType === 'browser') {
-        electronProcessType = 'electron-main';
+        electronProcessType = ElectronProcessTypeFlags.ElectronMainNode;
     }
     else if (processType === 'renderer') {
-        electronProcessType = 'browser';
+        electronProcessType = ElectronProcessTypeFlags.ElectronBrowser;
     }
     else {
         if (isBrowser) {
-            electronProcessType = 'browser';
+            electronProcessType = ElectronProcessTypeFlags.Browser;
+            try {
+                const electron = require('electron');
+                if (electron.ipcRenderer) {
+                    electronProcessType = ElectronProcessTypeFlags.ElectronBrowser;
+                }
+            }
+            catch (err) {
+            }
         }
         else {
-            electronProcessType = process.env['ELECTRON_RUN_AS_NODE'] ? 'electron-node' : 'node';
+            electronProcessType = process.env['ELECTRON_RUN_AS_NODE'] ? ElectronProcessTypeFlags.ElectronNode : ElectronProcessTypeFlags.Node;
         }
@@ -20,0 +53,0 @@ }

lib/v1/electron-process-type.js

@@ -7,8 +7,9 @@ "use strict";
     switch (electronProcessType) {
-        case 'electron-main':
+        case util.ElectronProcessTypeFlags.ElectronMainNode:
             return 'browser';
-        case 'node':
-        case 'electron-node':
+        case util.ElectronProcessTypeFlags.Node:
+        case util.ElectronProcessTypeFlags.ElectronNode:
             return 'node';
-        case 'browser':
+        case util.ElectronProcessTypeFlags.Browser:
+        case util.ElectronProcessTypeFlags.ElectronBrowser:
             return 'renderer';
@@ -15,0 +16,0 @@ }

lib/v2/electron-process-type.js

@@ -7,8 +7,9 @@ "use strict";
     switch (electronProcessType) {
-        case 'electron-main':
+        case util.ElectronProcessTypeFlags.ElectronMainNode:
             return 'main';
-        case 'node':
-        case 'electron-node':
+        case util.ElectronProcessTypeFlags.Node:
+        case util.ElectronProcessTypeFlags.ElectronNode:
             return 'node';
-        case 'browser':
+        case util.ElectronProcessTypeFlags.Browser:
+        case util.ElectronProcessTypeFlags.ElectronBrowser:
             return 'renderer';
@@ -15,0 +16,0 @@ }

lib/v3/electron-process-type.js

@@ -7,8 +7,9 @@ "use strict";
     switch (electronProcessType) {
-        case 'electron-main':
+        case util.ElectronProcessTypeFlags.ElectronMainNode:
             return 'main';
-        case 'node':
-        case 'electron-node':
+        case util.ElectronProcessTypeFlags.Node:
+        case util.ElectronProcessTypeFlags.ElectronNode:
             return 'node';
-        case 'browser':
+        case util.ElectronProcessTypeFlags.Browser:
+        case util.ElectronProcessTypeFlags.ElectronBrowser:
             return 'browser';
@@ -15,0 +16,0 @@ }

lib/v4/electron-process-type.d.ts

@@ -1,3 +0,3 @@
-import * as util from '../electron-process-type-util';
-export declare type ElectronProcessType = util.ElectronProcessType;
+export declare type ElectronProcessType = 'electron-node' | 'electron-browser' | 'electron-main-node' | 'node' | 'browser';
+export { IsProcessNode, IsProcessBrowser, IsProcessElectron } from '../electron-process-type-util';
 export declare function GetElectronProcessType(): ElectronProcessType;

lib/v4/electron-process-type.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const util = require("../electron-process-type-util");
+var electron_process_type_util_1 = require("../electron-process-type-util");
+exports.IsProcessNode = electron_process_type_util_1.IsProcessNode;
+exports.IsProcessBrowser = electron_process_type_util_1.IsProcessBrowser;
+exports.IsProcessElectron = electron_process_type_util_1.IsProcessElectron;
 function GetElectronProcessType() {
-    return util.GetElectronProcessType();
+    const electronProcessType = util.GetElectronProcessType();
+    switch (electronProcessType) {
+        case util.ElectronProcessTypeFlags.ElectronMainNode:
+            return 'electron-main-node';
+        case util.ElectronProcessTypeFlags.Node:
+            return 'node';
+        case util.ElectronProcessTypeFlags.ElectronNode:
+            return 'electron-node';
+        case util.ElectronProcessTypeFlags.Browser:
+            return 'browser';
+        case util.ElectronProcessTypeFlags.ElectronBrowser:
+            return 'electron-browser';
+    }
 }
 exports.GetElectronProcessType = GetElectronProcessType;
 //# sourceMappingURL=electron-process-type.js.map

package.json

 {
   "name": "electron-process-type",
-  "version": "2.5.0",
+  "version": "3.0.0",
   "description": "Retrieve the process type running your code : 'node',  'browser' or 'renderer'.",
@@ -43,2 +43,3 @@ "repository": {
     "ncp": "^2.0.0",
+    "shelljs": "^0.8.3",
     "sinon": "^4.0.1",
@@ -57,10 +58,12 @@ "tslint": "^4.1.1",
     "copy-resources": "echo ncp ./src/v2/electron.d.ts ./lib/v2/electron.d.ts",
-    "browserify-test": "npm run browserify-test-preload && npm run browserify-test-js",
+    "browserify-test": "npm run browserify-test-preload && npm run browserify-test-js && npm run browserify-browser-test-js",
     "browserify-test-preload": "browserify -o ./test/electron-tests/process-page-preload.bundle.js -x electron ./test/electron-tests/process-page-preload.js",
     "browserify-test-js": "browserify -o ./test/electron-tests/process-page.bundle.js -x electron ./test/electron-tests/process-page.js",
-    "test": "npm run test-mocha-node && npm run test-mocha-electron-main && npm run test-mocha-electron-node && npm run test-mocha-browser",
+    "browserify-browser-test-js": "browserify -o ./test/browser-tests/browser-test.bundle.js -x electron ./test/browser-tests/browser-test.js",
+    "test": "npm run test-mocha-node && npm run test-mocha-electron-main && npm run test-mocha-electron-node && npm run test-mocha-electron-browser && npm run test-mocha-browser",
     "test-mocha-node": "mocha test/*-node.test.js",
-    "test-mocha-electron-main": "electron-mocha test/*electron-main.test.js",
-    "test-mocha-electron-node": "electron-mocha test/*electron-node.test.js",
-    "test-mocha-browser": "electron-mocha --renderer test/*-browser.test.js",
+    "test-mocha-electron-main": "electron-mocha test/type-electron-main.test.js",
+    "test-mocha-electron-node": "electron-mocha test/type-electron-node.test.js",
+    "test-mocha-electron-browser": "electron-mocha --renderer test/type-electron-browser.test.js",
+    "test-mocha-browser": "electron-mocha --renderer test/type-browser.test.js",
     "tsc": "tsc",
@@ -67,0 +70,0 @@ "tslint": "tslint",

README.md

@@ -13,6 +13,6 @@ # electron-process-type
 - 'node' / 'electron-node' (No Electron API available)
-- 'browser' / 'main' / 'electron-main' (Electron API available)
-- 'renderer' / 'browser'
+- 'browser' / 'main' / 'electron-main-node' (Electron API available)
+- 'renderer' / 'browser' / 'electron-browser'
 
-There are different versions which use either Electron semantic (renderer, main) or Browser semantic (browser, electron-main).
+There are different versions which use either Electron semantic (renderer, main) or Browser semantic (browser, electron-main-node).
 
@@ -106,4 +106,4 @@ Dependencies
 
-## v4/GetElectronProcessType(): 'electron-node' | 'electron-main' | 'browser' | 'node';
-Identify node process running under Electron ('electron-node' / 'electron-main') vs pure node process ('node')
+## v4/GetElectronProcessType(): 'electron-node' | 'electron-main-node' | 'electron-browser' | 'browser' | 'node';
+Identify node process running under Electron ('electron-node' / 'electron-main-node') vs pure node process ('node')
 ```ts
@@ -119,3 +119,3 @@ import * as electronProcessType from 'electron-process-type';
         }
-        case 'electron-main': {
+        case 'electron-main-node': {
 ...
@@ -122,0 +122,0 @@ break;

New alerts

Environment variable access

Supply chain risk

Package accesses environment variables, which may be a sign of credential stuffing or data theft.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

23315

29.95%

Lines of code

224

30.23%

Worsened metrics

Dev dependency count

15

7.14%

Number of low supply chain risk alerts

2

100%

No dependency changes