nw-builder 3.6.0 → 3.7.0

package/lib/{platformOverrides.js → platformOverrides.cjs}

@@ -6,45 +6,58 @@ Apply platform-specific manifest values. Works with JSON or plain objects. The p
 
 var applyOverrides, detectPlatform, getOverridesToApply, os, _;
 
-os = require('os');
-_ = require('lodash');
+os = require("os");
+_ = require("lodash");
 
-detectPlatform = function() {
+detectPlatform = function () {
   var platform;
   platform = os.platform();
-  if (platform === 'darwin') {
-    platform = 'osx';
+  if (platform === "darwin") {
+    platform = "osx";
   } else if (platform.match(/^win/)) {
-    platform = 'win';
+    platform = "win";
   }
   return {
     agnostic: platform,
-    specific: platform + (process.arch === 'x64' || process.env.hasOwnProperty('PROCESSOR_ARCHITEW6432') ? 64 : 32)
+    specific:
+      platform +
+      (process.arch === "x64" ||
+      Object.prototype.hasOwnProperty.call(
+        process.env,
+        "PROCESSOR_ARCHITEW6432",
+      )
+        ? 64
+        : 32),
   };
 };
 
-getOverridesToApply = function(platform, cb) {
+getOverridesToApply = function (platform, cb) {
   var agnosticPlatform, architectureAgnostic, architectureSpecific, _i, _len;
-  architectureAgnostic = ['linux', 'osx', 'win'];
+  architectureAgnostic = ["linux", "osx", "win"];
   architectureSpecific = [];
   for (_i = 0, _len = architectureAgnostic.length; _i < _len; _i++) {
     agnosticPlatform = architectureAgnostic[_i];
-    architectureSpecific.push(agnosticPlatform + '32');
-    architectureSpecific.push(agnosticPlatform + '64');
+    architectureSpecific.push(agnosticPlatform + "32");
+    architectureSpecific.push(agnosticPlatform + "64");
   }
   if (platform) {
-    if (!(architectureAgnostic.indexOf(platform) > -1 || architectureSpecific.indexOf(platform) > -1)) {
-      return cb(new Error('Invalid platform passed', null));
+    if (
+      !(
+        architectureAgnostic.indexOf(platform) > -1 ||
+        architectureSpecific.indexOf(platform) > -1
+      )
+    ) {
+      return cb(new Error("Invalid platform passed", null));
     }
     if (architectureAgnostic.indexOf(platform) > -1) {
       return cb(null, {
         agnostic: platform,
-        specific: null
+        specific: null,
       });
     } else {
       return cb(null, {
         agnostic: platform.substr(0, platform.length - 2),
-        specific: platform
+        specific: platform,
       });
     }
   } else {
@@ -52,30 +65,39 @@ getOverridesToApply = function(platform, cb) {
   }
 };
 
-applyOverrides = function(_arg) {
+applyOverrides = function (_arg) {
   var cb, options, platform, result;
-  platform = _arg.platform, options = _arg.options, cb = _arg.cb;
+  (platform = _arg.platform), (options = _arg.options), (cb = _arg.cb);
   result = _.cloneDeep(options);
-  if ((options.platformOverrides[platform] != null) && Object.keys(options.platformOverrides[platform]).length) {
-    result = _.mergeWith(result, options.platformOverrides[platform], function(optionValue, overrideValue) {
-
-      /*
+  if (
+    options.platformOverrides[platform] != null &&
+    Object.keys(options.platformOverrides[platform]).length
+  ) {
+    result = _.mergeWith(
+      result,
+      options.platformOverrides[platform],
+      function (optionValue, overrideValue) {
+        /*
         If overrides.x is {} but source.x is a non-empty object {prop:0, another:2},
         take the {}}
        */
-      if ((_.isPlainObject(overrideValue) || _.isArray(overrideValue)) && _.isEmpty(overrideValue)) {
-        return overrideValue;
-      }
-    });
+        if (
+          (_.isPlainObject(overrideValue) || _.isArray(overrideValue)) &&
+          _.isEmpty(overrideValue)
+        ) {
+          return overrideValue;
+        }
+      },
+    );
   }
   return cb(result);
 };
 
-module.exports = function(_arg, cb) {
+module.exports = function (_arg, cb) {
   var callback, options, platform;
-  options = _arg.options, platform = _arg.platform;
-  callback = cb != null ? cb : (function() {});
-  return getOverridesToApply(platform, function(err, overridesToApply) {
+  (options = _arg.options), (platform = _arg.platform);
+  callback = cb != null ? cb : function () {};
+  return getOverridesToApply(platform, function (err, overridesToApply) {
     var applySpecificOverrides, objectMode, originalOptions;
     if (err != null) {
       return callback(err, null);
@@ -89,28 +111,31 @@ module.exports = function(_arg, cb) {
       return callback(err, null);
     }
     if (options.platformOverrides != null) {
-      applySpecificOverrides = function(optionsToOverride) {
+      applySpecificOverrides = function (optionsToOverride) {
         return applyOverrides({
           platform: overridesToApply.specific,
           options: optionsToOverride,
-          cb: function(result) {
+          cb: function (result) {
             delete result.platformOverrides;
             return callback(null, objectMode ? result : JSON.stringify(result));
-          }
+          },
         });
       };
       if (overridesToApply.agnostic != null) {
         return applyOverrides({
           platform: overridesToApply.agnostic,
           options: options,
-          cb: function(result) {
+          cb: function (result) {
             if (overridesToApply.specific != null) {
               return applySpecificOverrides(result);
             } else {
               delete result.platformOverrides;
-              return callback(null, objectMode ? result : JSON.stringify(result));
+              return callback(
+                null,
+                objectMode ? result : JSON.stringify(result),
+              );
             }
-          }
+          },
         });
       } else {
         return applySpecificOverrides(options);
@@ -119,4 +144,4 @@ module.exports = function(_arg, cb) {
       return callback(null, originalOptions);
     }
   });
-};
+};

package/lib/platforms.cjs

@@ -0,0 +1,141 @@
+var semver = require("semver");
+
+module.exports = {
+  win32: {
+    needsZip: true,
+    getRunnable: function () {
+      return "nw.exe";
+    },
+    files: {
+      // First file must be the executable
+      "<=0.9.2": [
+        "nw.exe",
+        "ffmpegsumo.dll",
+        "icudt.dll",
+        "libEGL.dll",
+        "libGLESv2.dll",
+        "nw.pak",
+      ],
+      ">0.9.2 <0.12.0": [
+        "nw.exe",
+        "ffmpegsumo.dll",
+        "icudtl.dat",
+        "libEGL.dll",
+        "libGLESv2.dll",
+        "nw.pak",
+        "locales",
+      ],
+      ">=0.12.0": [
+        "nw.exe",
+        "ffmpegsumo.dll",
+        "icudtl.dat",
+        "libEGL.dll",
+        "libGLESv2.dll",
+        "nw.pak",
+        "locales",
+        "d3dcompiler_47.dll",
+        "pdf.dll",
+      ],
+    },
+    versionNameTemplate: "v${ version }/${ name }-v${ version }-win-ia32.zip",
+  },
+  win64: {
+    needsZip: true,
+    getRunnable: function () {
+      return "nw.exe";
+    },
+    files: {
+      // First file must be the executable
+      "<=0.9.2": [
+        "nw.exe",
+        "ffmpegsumo.dll",
+        "icudt.dll",
+        "libEGL.dll",
+        "libGLESv2.dll",
+        "nw.pak",
+        "locales",
+      ],
+      ">0.9.2 <0.12.0": [
+        "nw.exe",
+        "ffmpegsumo.dll",
+        "icudtl.dat",
+        "libEGL.dll",
+        "libGLESv2.dll",
+        "nw.pak",
+        "locales",
+      ],
+      ">=0.12.0": [
+        "nw.exe",
+        "ffmpegsumo.dll",
+        "icudtl.dat",
+        "libEGL.dll",
+        "libGLESv2.dll",
+        "nw.pak",
+        "locales",
+        "d3dcompiler_47.dll",
+        "pdf.dll",
+      ],
+    },
+    versionNameTemplate: "v${ version }/${ name }-v${ version }-win-x64.zip",
+  },
+  osx32: {
+    needsZip: false,
+    getRunnable: function (version) {
+      if (semver.satisfies(version, ">=0.12.0 || ~0.12.0-alpha")) {
+        return "nwjs.app/Contents/MacOS/nwjs";
+      } else {
+        return "node-webkit.app/Contents/MacOS/node-webkit";
+      }
+    },
+    files: {
+      "<0.12.0-alpha": ["node-webkit.app"],
+      ">=0.12.0 || ~0.12.0-alpha": ["nwjs.app"],
+    },
+    versionNameTemplate: "v${ version }/${ name }-v${ version }-osx-ia32.zip",
+  },
+  osx64: {
+    needsZip: false,
+    getRunnable: function (version) {
+      if (semver.satisfies(version, ">=0.12.0 || ~0.12.0-alpha")) {
+        return "nwjs.app/Contents/MacOS/nwjs";
+      } else {
+        return "node-webkit.app/Contents/MacOS/node-webkit";
+      }
+    },
+    files: {
+      "<0.12.0-alpha": ["node-webkit.app"],
+      ">=0.12.0 || ~0.12.0-alpha": ["nwjs.app"],
+    },
+    versionNameTemplate: "v${ version }/${ name }-v${ version }-osx-x64.zip",
+  },
+  linux32: {
+    needsZip: true,
+    chmod: "0755",
+    getRunnable: function () {
+      return "nw";
+    },
+    files: {
+      // First file must be the executable
+      "<=0.9.2": ["nw", "nw.pak", "libffmpegsumo.so"],
+      ">0.9.2 <=0.10.1": ["nw", "nw.pak", "libffmpegsumo.so", "icudtl.dat"],
+      ">0.10.1": ["nw", "nw.pak", "libffmpegsumo.so", "icudtl.dat", "locales"],
+    },
+    versionNameTemplate:
+      "v${ version }/${ name }-v${ version }-linux-ia32.tar.gz",
+  },
+  linux64: {
+    needsZip: true,
+    chmod: "0755", // chmod file file to be executable
+    getRunnable: function () {
+      return "nw";
+    },
+    files: {
+      // First file must be the executable
+      "<=0.9.2": ["nw", "nw.pak", "libffmpegsumo.so"],
+      ">0.9.2 <=0.10.1": ["nw", "nw.pak", "libffmpegsumo.so", "icudtl.dat"],
+      ">0.10.1": ["nw", "nw.pak", "libffmpegsumo.so", "icudtl.dat", "locales"],
+    },
+    versionNameTemplate:
+      "v${ version }/${ name }-v${ version }-linux-x64.tar.gz",
+  },
+};

package/lib/utils.cjs

@@ -0,0 +1,293 @@
+var fs = require("graceful-fs-extra");
+var path = require("path");
+var _ = require("lodash");
+var plist = require("plist");
+var Glob = require("simple-glob");
+var temp = require("temp");
+var archiver = require("archiver");
+var thenify = require("thenify");
+
+var readFile = thenify(fs.readFile);
+var writeFile = thenify(fs.writeFile);
+
+// Automatically track and cleanup files at exit
+temp.track();
+
+module.exports = {
+  getPackageInfo: function (path) {
+    return new Promise(function (resolve, reject) {
+      fs.readFile(path, function (err, data) {
+        if (err) return reject(err);
+        try {
+          var appPkg = JSON.parse(data);
+        } catch (e) {
+          reject(
+            "Invalid package.json: " +
+              e +
+              "\nMake sure the file is encoded as utf-8",
+          );
+          return;
+        }
+        if (!appPkg.name || !appPkg.version) {
+          reject(
+            "Please make sure that your project's package.json includes a version and a name value",
+          );
+        } else {
+          resolve(appPkg);
+        }
+      });
+    });
+  },
+  getFileList: function (fileglob) {
+    var self = this,
+      jsonfile,
+      destFiles = [],
+      srcFiles = [],
+      package_path,
+      matches = Glob(fileglob);
+
+    return new Promise(function (resolve, reject) {
+      if (!matches.length) return reject("No files matching");
+
+      matches.forEach(function (file) {
+        var internalFileName = path.normalize(file);
+        if (internalFileName.match("package.json")) {
+          jsonfile = self.closerPathDepth(internalFileName, jsonfile);
+          package_path = path.normalize(
+            jsonfile.split("package.json")[0] || "./",
+          );
+        }
+        if (!fs.lstatSync(internalFileName).isDirectory()) {
+          srcFiles.push(internalFileName);
+        }
+      });
+
+      if (!jsonfile) {
+        return reject("Could not find a package.json in your src folder");
+      }
+
+      srcFiles.forEach(function (file) {
+        destFiles.push({
+          src: file,
+          dest: file.replace(package_path, ""),
+        });
+      });
+
+      resolve({
+        files: destFiles,
+        json: jsonfile,
+      });
+    });
+  },
+  closerPathDepth: function (path1, path2) {
+    if (!path2) {
+      return path1;
+    }
+
+    var d1 = this.pathDepth(path1),
+      d2 = this.pathDepth(path2);
+
+    return d1 < d2 ? path1 : path2;
+  },
+  pathDepth: function (absolutePath) {
+    return absolutePath.split(path.sep).length;
+  },
+  copyFile: function (src, dest, _event, options) {
+    return new Promise(function (resolve, reject) {
+      options = options || {};
+      var stats = fs.lstatSync(src);
+      fs.copy(src, dest, options, function (err) {
+        if (err) return reject(err);
+
+        var retryCount = 0;
+        var existsCallback = function (exists) {
+          if (exists) {
+            fs.chmod(dest, stats.mode, function (err) {
+              // ignore error
+              if (err) {
+                _event.emit(
+                  "log",
+                  "chmod " +
+                    stats.mode +
+                    " on " +
+                    dest +
+                    " failed after copying, ignoring",
+                );
+              }
+
+              resolve();
+            });
+          } else if (retryCount++ < 2) {
+            // This is antipattern!!!
+            // Callback should be called when the copy is finished!!!!
+            setTimeout(function () {
+              fs.exists(dest, existsCallback);
+            }, 1000);
+          } else {
+            reject(
+              new Error(
+                "Copied file (" +
+                  dest +
+                  ") doesn't exist in destination after copying",
+              ),
+            );
+          }
+        };
+
+        fs.exists(dest, existsCallback);
+      });
+    });
+  },
+  mergeFiles: function (app, zipfile, chmod) {
+    // we need to pipe the app into the zipfile and chmod it
+    return new Promise(function (resolve, reject) {
+      var zipStream = fs.createReadStream(zipfile),
+        writeStream = fs.createWriteStream(app, { flags: "a" });
+
+      zipStream.on("error", reject);
+      writeStream.on("error", reject);
+
+      writeStream.on("finish", function () {
+        if (chmod) {
+          fs.chmodSync(app, chmod);
+        }
+        resolve();
+      });
+
+      zipStream.pipe(writeStream);
+    });
+  },
+  generateZipFile: function (
+    files,
+    _event,
+    platformSpecificManifest,
+    zipOptions,
+  ) {
+    var destStream = temp.createWriteStream(),
+      archive = archiver("zip", zipOptions || {});
+
+    return new Promise(function (resolve, reject) {
+      // Resolve on close
+      destStream.on("close", function () {
+        resolve(destStream.path);
+      });
+
+      // Reject on Error
+      archive.on("error", reject);
+
+      // Add the files
+      files.forEach(function (file) {
+        if (file.dest === "package.json" && platformSpecificManifest) {
+          archive.append(platformSpecificManifest, { name: "package.json" });
+        } else {
+          archive.file(file.src, { name: file.dest });
+        }
+      });
+
+      // Some logs
+      archive.on("entry", function (file) {
+        _event.emit("log", "Zipping " + file.name);
+      });
+
+      // Pipe the stream
+      archive.pipe(destStream);
+      archive.finalize();
+    });
+  },
+  getPlistOptions: function (parsedParams, custom) {
+    var obj = {};
+    if (parsedParams.name) {
+      obj.CFBundleName = parsedParams.name;
+      obj.CFBundleDisplayName = parsedParams.name;
+    }
+    if (parsedParams.version) {
+      obj.CFBundleVersion = parsedParams.version;
+      obj.CFBundleShortVersionString = "Version " + parsedParams.version;
+    }
+    if (parsedParams.copyright) {
+      obj.NSHumanReadableCopyright = parsedParams.copyright;
+    }
+
+    return _.merge(obj, custom);
+  },
+  editPlist: function (plistInput, plistOutput, options) {
+    options = options || {};
+
+    // Make sure all required properties are set
+    [
+      "CFBundleName",
+      "CFBundleDisplayName",
+      "CFBundleVersion",
+      "CFBundleShortVersionString",
+    ].forEach(function (prop) {
+      if (!Object.prototype.hasOwnProperty.call(options, prop)) {
+        throw new Error("Missing macPlist property '" + prop + "'");
+      }
+    });
+
+    // Bundle identifier based on package name
+    if (options.CFBundleIdentifier === undefined) {
+      options.CFBundleIdentifier =
+        "com.nw-builder." +
+        options.CFBundleName.toLowerCase().replace(/[^a-z-]/g, "");
+    }
+
+    // Read the input file
+    return (
+      readFile(plistInput, "utf8")
+        // Parse it
+        .then(plist.parse)
+        // Then overwrite the properties with custom values
+        .then(function (info) {
+          // Keep backwards compatibility and handle aliases
+          Object.keys(options).forEach(function (key) {
+            var value = options[key];
+            switch (key) {
+              case "mac_bundle_id":
+                info.CFBundleIdentifier = value;
+                break;
+              case "mac_document_types":
+                info.CFBundleDocumentTypes = value.map(function (type) {
+                  return {
+                    CFBundleTypeName: type.name,
+                    CFBundleTypeExtensions: type.extensions,
+                    CFBundleTypeRole: type.role,
+                    LSIsAppleDefaultForType: type.isDefault,
+                  };
+                });
+                break;
+              default:
+                info[key] = value;
+            }
+          });
+
+          // Remove some unwanted properties
+          if (
+            !(
+              Object.prototype.hasOwnProperty.call(
+                options,
+                "mac_document_types",
+              ) ||
+              Object.prototype.hasOwnProperty.call(
+                options,
+                "CFBundleDocumentTypes",
+              )
+            )
+          ) {
+            info.CFBundleDocumentTypes = [];
+          }
+
+          if (
+            !Object.prototype.hasOwnProperty.call(
+              options,
+              "UTExportedTypeDeclarations",
+            )
+          )
+            info.UTExportedTypeDeclarations = [];
+
+          // Write output file
+          return writeFile(plistOutput, plist.build(info));
+        })
+    );
+  },
+};