nw-builder 3.6.0 → 3.7.2

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/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));
+        })
+    );
+  },
+};

package/lib/versions.cjs

@@ -0,0 +1,206 @@
+const { Platforms } = require("../dist/index.cjs");
+var semver = require("semver");
+var request = require("request");
+var _ = require("lodash");
+var Version = require("./Version.cjs");
+
+/**
+ * @param {string} url
+ * @param {object} options - Passed to request
+ * @returns {promise} which resolves to response body
+ */
+function get(url, options) {
+  return new Promise(function (resolve, reject) {
+    request(url, options, function (err, res, body) {
+      if (err) {
+        reject(err);
+      } else if (res.statusCode !== 200) {
+        reject("Received status code " + res.statusCode + ": " + url);
+      } else {
+        resolve(body);
+      }
+    });
+  });
+}
+
+/**
+ * @param {string} downloadUrl
+ * @returns {promise} which resolves to an array of {Version}s
+ */
+function getLegacyVersions(downloadUrl) {
+  var scrapePtrn = /href="v?([0-9]+\.[0-9]+\.[0-9]+[^"]*)\/"/gi,
+    searchRes,
+    versions = [];
+
+  return get(downloadUrl).then(function (body) {
+    // scrapes valid semver versions from apache directory listing
+    while ((searchRes = scrapePtrn.exec(body)) !== null) {
+      searchRes = searchRes[1];
+      if (semver.valid(searchRes) && !_.includes(versions, searchRes)) {
+        versions.push(searchRes);
+      }
+    }
+    // order with newest version at front of array
+    versions = versions.sort(function (a, b) {
+      return semver.compare(b, a);
+    });
+
+    // filter out invalid / alpha versions
+    var validationPromises = [];
+    versions.forEach(function (version) {
+      if (!isLegacyVersion(version)) {
+        return;
+      }
+      validationPromises.push(
+        new Promise(function (resolve) {
+          // check if windows 64-bit ZIP exists
+          var win32Url = new Version({
+            version: version,
+            flavors: ["sdk"],
+            supportedPlatforms: ["win32"],
+            downloadUrl: downloadUrl,
+          }).platforms["win32-sdk"];
+          request.head(win32Url, function (err, res) {
+            // note: this takes a version string and replaces it with an object (will be converted back later)
+            resolve({
+              version: version,
+              flavors: ["sdk"],
+              valid: !err && res.statusCode === 200,
+            });
+          });
+        }),
+      );
+    });
+
+    var allPlatforms = Object.keys(Platforms);
+
+    return Promise.all(validationPromises).then(function (versions) {
+      // convert back to array of version strings (filtered)
+      return versions
+        .filter(function (versionObj) {
+          return versionObj.valid;
+        })
+        .map(function (versionObj) {
+          return new Version({
+            version: versionObj.version,
+            flavors: versionObj.flavors,
+            supportedPlatforms: allPlatforms,
+            downloadUrl: downloadUrl,
+          });
+        });
+    });
+  });
+}
+
+/**
+ * @param {string?} manifestUrl
+ * @returns {promise} which resolves to response body
+ */
+function getManifest(manifestUrl) {
+  if (!manifestUrl) {
+    manifestUrl = "https://nwjs.io/versions.json";
+  }
+  return get(manifestUrl, { json: true }).then(function (body) {
+    return body;
+  });
+}
+
+/**
+ * @param {string} downloadUrl
+ * @param {string} manifestUrl
+ * @returns {promise} which resolves to an array of {Version}s
+ */
+function getVersionsFromManifest(downloadUrl, manifestUrl) {
+  var mapFilesToPlatforms = function (files) {
+    return files.map(function (file) {
+      // convert win-x64 to win64, linux-ia32 to linux 32, etc.
+      return file.replace(/-(x|ia)/, "");
+    });
+  };
+
+  return getManifest(manifestUrl).then(function (manifest) {
+    return manifest.versions
+      .filter(function (versionFromManifest) {
+        // 0.12.3 is an exception that is in the manifest but is kind of a legacy version
+        return (
+          versionFromManifest.flavors !== undefined &&
+          (versionFromManifest.flavors.indexOf("sdk") !== -1 ||
+            versionFromManifest.version === "v0.12.3")
+        );
+      })
+      .map(function (versionFromManifest) {
+        return new Version({
+          version: versionFromManifest.version.replace("v", ""),
+          flavors: versionFromManifest.flavors,
+          supportedPlatforms: mapFilesToPlatforms(versionFromManifest.files),
+          downloadUrl: downloadUrl,
+        });
+      });
+  });
+}
+
+/**
+ * @param {string} version
+ * @returns {boolean}
+ */
+function isLegacyVersion(version) {
+  return semver.lte(version, "0.12.3");
+}
+
+module.exports = {
+  /**
+   * Gets the latest stable version
+   * @param {string} downloadUrl
+   * @param {string} manifestUrl
+   * @param {string} flavor
+   * @returns {promise} which resolves to a {Version}
+   */
+  getLatestVersion: function (downloadUrl, manifestUrl, flavor) {
+    return getManifest(manifestUrl)
+      .then(function (manifest) {
+        return {
+          desiredVersion: manifest.stable.replace("v", ""),
+          downloadUrl: downloadUrl,
+          manifestUrl: manifestUrl,
+          flavor: flavor,
+        };
+      })
+      .then(this.getVersion);
+  },
+  /**
+   * @param {string} args.desiredVersion
+   * @param {string} args.downloadUrl
+   * @param {string} args.manifestUrl
+   * @param {string} args.flavor
+   * @returns {promise} which resolves to a {Version}
+   */
+  getVersion: function (args) {
+    return (
+      isLegacyVersion(args.desiredVersion)
+        ? getLegacyVersions
+        : getVersionsFromManifest
+    )(args.downloadUrl, args.manifestUrl).then(function (versions) {
+      var version = versions.findIndex(function (version) {
+        return version.version === args.desiredVersion;
+      });
+
+      return version >= 0
+        ? Promise.resolve(versions[version])
+        : Promise.reject("Version " + args.desiredVersion + " not found.");
+    });
+  },
+  /**
+   * @param {string} downloadUrl
+   * @param {string} manifestUrl
+   * @param {string} flavor
+   * @returns {promise} which resolves to an array of {Version}s
+   */
+  getVersions: function (downloadUrl, manifestUrl, flavor) {
+    return Promise.all([
+      getVersionsFromManifest(downloadUrl, manifestUrl, flavor),
+      getLegacyVersions(downloadUrl, flavor),
+    ]).then(function (versionLists) {
+      return versionLists[0].concat(versionLists[1]);
+    });
+  },
+};