Fork: 0
0xRoM / CVSS_3.0_GUI
Transfer to URL with SHA Find file
Newer
Older
CVSS_3.0_GUI / node_modules / nwjs-builder-phoenix / dist / lib / util / index.js
root on 7 May 2019 12 KB Initial commit
Raw Blame History 
  1. "use strict";
  2. var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
  3.     return new (P || (P = Promise))(function (resolve, reject) {
  4.         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
  5.         function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
  6.         function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
  7.         step((generator = generator.apply(thisArg, _arguments || [])).next());
  8.     });
  9. };
  10. var __generator = (this && this.__generator) || function (thisArg, body) {
  11.     var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
  12.     return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
  13.     function verb(n) { return function (v) { return step([n, v]); }; }
  14.     function step(op) {
  15.         if (f) throw new TypeError("Generator is already executing.");
  16.         while (_) try {
  17.             if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t;
  18.             if (y = 0, t) op = [0, t.value];
  19.             switch (op[0]) {
  20.                 case 0: case 1: t = op; break;
  21.                 case 4: _.label++; return { value: op[1], done: false };
  22.                 case 5: _.label++; y = op[1]; op = [0]; continue;
  23.                 case 7: op = _.ops.pop(); _.trys.pop(); continue;
  24.                 default:
  25.                     if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
  26.                     if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
  27.                     if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
  28.                     if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
  29.                     if (t[2]) _.ops.pop();
  30.                     _.trys.pop(); continue;
  31.             }
  32.             op = body.call(thisArg, _);
  33.         } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
  34.         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
  35.     }
  36. };
  37. function __export(m) {
  38.     for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
  39. }
  40. Object.defineProperty(exports, "__esModule", { value: true });
  41. var path_1 = require("path");
  42. var child_process_1 = require("child_process");
  43. var tmp = require("tmp");
  44. tmp.setGracefulCleanup();
  45. var fs_extra_1 = require("fs-extra");
  46. var debug = require('debug')('build:util');
  47. var globby = require('globby');
  48. __export(require("./archive"));
  49. function mergeOptions(defaults, options) {
  50.     var opts = {};
  51.     Object.keys(defaults).map(function (key) {
  52.         opts[key] = defaults[key];
  53.     });
  54.     Object.keys(defaults).map(function (key) {
  55.         opts[key] = options[key] === undefined ? opts[key] : options[key];
  56.     });
  57.     return opts;
  58. }
  59. exports.mergeOptions = mergeOptions;
  60. function findExecutable(platform, runtimeDir) {
  61.     return new Promise(function (resolve, reject) {
  62.         var pattern = (function () {
  63.             switch (platform) {
  64.                 case 'win32':
  65.                 case 'win':
  66.                     return '**/nw.exe';
  67.                 case 'darwin':
  68.                 case 'osx':
  69.                 case 'mac':
  70.                     return '**/nwjs.app/Contents/MacOS/nwjs';
  71.                 case 'linux':
  72.                     return '**/nw';
  73.                 default:
  74.                     throw new Error('ERROR_UNKNOWN_PLATFORM');
  75.             }
  76.         })();
  77.         // FIXME: globby.d.ts.
  78.         globby([pattern], {
  79.             cwd: runtimeDir,
  80.         })
  81.             .then(function (matches) {
  82.             if (matches.length == 0) {
  83.                 var err = new Error('ERROR_EMPTY_MATCHES');
  84.                 return reject(err);
  85.             }
  86.             debug('in findExecutable', 'matches', matches);
  87.             resolve(path_1.join(runtimeDir, matches[0]));
  88.         });
  89.     });
  90. }
  91. exports.findExecutable = findExecutable;
  92. function findFFmpeg(platform, dir) {
  93.     return new Promise(function (resolve, reject) {
  94.         var pattern = (function () {
  95.             switch (platform) {
  96.                 case 'win32':
  97.                 case 'win':
  98.                     return '**/ffmpeg.dll';
  99.                 case 'darwin':
  100.                 case 'osx':
  101.                 case 'mac':
  102.                     return '**/libffmpeg.dylib';
  103.                 case 'linux':
  104.                     return '**/libffmpeg.so';
  105.                 default:
  106.                     throw new Error('ERROR_UNKNOWN_PLATFORM');
  107.             }
  108.         })();
  109.         // FIXME: globby.d.ts.
  110.         globby([pattern], {
  111.             cwd: dir,
  112.         })
  113.             .then(function (matches) {
  114.             if (matches.length == 0) {
  115.                 var err = new Error('ERROR_EMPTY_MATCHES');
  116.                 return reject(err);
  117.             }
  118.             debug('in findFFmpeg', 'matches', matches);
  119.             resolve(path_1.join(dir, matches[0]));
  120.         });
  121.     });
  122. }
  123. exports.findFFmpeg = findFFmpeg;
  124. function findRuntimeRoot(platform, runtimeDir) {
  125.     return new Promise(function (resolve, reject) {
  126.         var pattern = (function () {
  127.             switch (platform) {
  128.                 case 'win32':
  129.                 case 'win':
  130.                     return '**/nw.exe';
  131.                 case 'darwin':
  132.                 case 'osx':
  133.                 case 'mac':
  134.                     return '**/nwjs.app';
  135.                 case 'linux':
  136.                     return '**/nw';
  137.                 default:
  138.                     throw new Error('ERROR_UNKNOWN_PLATFORM');
  139.             }
  140.         })();
  141.         // FIXME: globby.d.ts.
  142.         globby([pattern], {
  143.             cwd: runtimeDir,
  144.         })
  145.             .then(function (matches) {
  146.             if (matches.length == 0) {
  147.                 var err = new Error('ERROR_EMPTY_MATCHES');
  148.                 return reject(err);
  149.             }
  150.             debug('in findExecutable', 'matches', matches);
  151.             resolve(path_1.join(runtimeDir, path_1.dirname(matches[0])));
  152.         });
  153.     });
  154. }
  155. exports.findRuntimeRoot = findRuntimeRoot;
  156. function findExcludableDependencies(dir, pkg) {
  157.     return __awaiter(this, void 0, void 0, function () {
  158.         var prod, dev, excludable, _i, dev_1, d;
  159.         return __generator(this, function (_a) {
  160.             switch (_a.label) {
  161.                 case 0: return [4 /*yield*/, execAsync('npm ls --prod --parseable', {
  162.                         cwd: dir,
  163.                     })
  164.                         .then(function (_a) {
  165.                         var stdout = _a.stdout, stderr = _a.stderr;
  166.                         return stdout.split(/\r?\n/)
  167.                             .filter(function (path) { return path; })
  168.                             .map(function (path) {
  169.                             return path_1.relative(dir, path);
  170.                         });
  171.                     })];
  172.                 case 1:
  173.                     prod = _a.sent();
  174.                     debug('in findExcludableDependencies', 'prod', prod);
  175.                     return [4 /*yield*/, execAsync('npm ls --dev --parseable', {
  176.                             cwd: dir,
  177.                         })
  178.                             .then(function (_a) {
  179.                             var stdout = _a.stdout, stderr = _a.stderr;
  180.                             return stdout.split(/\r?\n/)
  181.                                 .filter(function (path) { return path; })
  182.                                 .map(function (path) {
  183.                                 return path_1.relative(dir, path);
  184.                             });
  185.                         })];
  186.                 case 2:
  187.                     dev = _a.sent();
  188.                     debug('in findExcludableDependencies', 'dev', dev);
  189.                     excludable = [];
  190.                     for (_i = 0, dev_1 = dev; _i < dev_1.length; _i++) {
  191.                         d = dev_1[_i];
  192.                         if (prod.indexOf(d) == -1) {
  193.                             excludable.push(d);
  194.                         }
  195.                     }
  196.                     debug('in findExcludableDependencies', 'excludable', excludable);
  197.                     return [2 /*return*/, excludable];
  198.             }
  199.         });
  200.     });
  201. }
  202. exports.findExcludableDependencies = findExcludableDependencies;
  203. function tmpName(options) {
  204.     if (options === void 0) { options = {}; }
  205.     return new Promise(function (resolve, reject) {
  206.         tmp.tmpName(Object.assign({}, {}, options), function (err, path) { return err ? reject(err) : resolve(path); });
  207.     });
  208. }
  209. exports.tmpName = tmpName;
  210. function tmpFile(options) {
  211.     if (options === void 0) { options = {}; }
  212.     return new Promise(function (resolve, reject) {
  213.         tmp.file(Object.assign({}, {}, options), function (err, path, fd, cleanup) { return err ? reject(err) : resolve({
  214.             path: path, fd: fd, cleanup: cleanup,
  215.         }); });
  216.     });
  217. }
  218. exports.tmpFile = tmpFile;
  219. function tmpDir(options) {
  220.     if (options === void 0) { options = {}; }
  221.     return new Promise(function (resolve, reject) {
  222.         tmp.dir(Object.assign({}, {
  223.             unsafeCleanup: true,
  224.         }, options), function (err, path, cleanup) { return err ? reject(err) : resolve({
  225.             path: path, cleanup: cleanup,
  226.         }); });
  227.     });
  228. }
  229. exports.tmpDir = tmpDir;
  230. function fixWindowsVersion(version, build) {
  231.     if (build === void 0) { build = 0; }
  232.     return /^\d+\.\d+\.\d+$/.test(version)
  233.         ? version + "." + build
  234.         : version;
  235. }
  236. exports.fixWindowsVersion = fixWindowsVersion;
  237. function copyFileAsync(src, dest) {
  238.     return __awaiter(this, void 0, void 0, function () {
  239.         var rsrc, stats, _a, _b;
  240.         return __generator(this, function (_c) {
  241.             switch (_c.label) {
  242.                 case 0: return [4 /*yield*/, fs_extra_1.realpath(src)];
  243.                 case 1:
  244.                     rsrc = _c.sent();
  245.                     return [4 /*yield*/, fs_extra_1.lstat(rsrc)];
  246.                 case 2:
  247.                     stats = _c.sent();
  248.                     if (!stats.isDirectory()) return [3 /*break*/, 3];
  249.                     return [3 /*break*/, 6];
  250.                 case 3:
  251.                     _a = fs_extra_1.outputFile;
  252.                     _b = [dest];
  253.                     return [4 /*yield*/, fs_extra_1.readFile(rsrc)];
  254.                 case 4: return [4 /*yield*/, _a.apply(void 0, _b.concat([_c.sent()]))];
  255.                 case 5:
  256.                     _c.sent();
  257.                     _c.label = 6;
  258.                 case 6: return [2 /*return*/];
  259.             }
  260.         });
  261.     });
  262. }
  263. exports.copyFileAsync = copyFileAsync;
  264. function spawnAsync(executable, args, options) {
  265.     if (options === void 0) { options = {}; }
  266.     return new Promise(function (resolve, reject) {
  267.         debug('in spawnAsync', 'executable', executable);
  268.         debug('in spawnAsync', 'args', args);
  269.         debug('in spawnAsync', 'options', options);
  270.         var child = child_process_1.spawn(executable, args, options);
  271.         if (child.stdout) {
  272.             child.stdout.on('data', function (chunk) { return debug('in spawnAsync', 'stdout', chunk.toString()); });
  273.         }
  274.         if (child.stderr) {
  275.             child.stderr.on('data', function (chunk) { return debug('in spawnAsync', 'stderr', chunk.toString()); });
  276.         }
  277.         child.on('close', function (code, signal) {
  278.             if (!options.detached) {
  279.                 resolve({
  280.                     code: code, signal: signal,
  281.                 });
  282.             }
  283.         });
  284.         if (options.detached) {
  285.             child.unref();
  286.             resolve({
  287.                 code: 0,
  288.                 signal: '',
  289.             });
  290.         }
  291.     });
  292. }
  293. exports.spawnAsync = spawnAsync;
  294. function execAsync(command, options) {
  295.     if (options === void 0) { options = {}; }
  296.     return new Promise(function (resolve, reject) {
  297.         debug('in execAsync', 'command', command);
  298.         debug('in execAsync', 'options', options);
  299.         var child = child_process_1.exec(command, options, function (err, stdout, stderr) {
  300.             if (!options.detached) {
  301.                 resolve({
  302.                     stdout: stdout, stderr: stderr,
  303.                 });
  304.             }
  305.         });
  306.         if (options.detached) {
  307.             child.unref();
  308.             resolve({
  309.                 stdout: null,
  310.                 stderr: null,
  311.             });
  312.         }
  313.     });
  314. }
  315. exports.execAsync = execAsync;
  316. //# sourceMappingURL=index.js.map
Buy Me A Coffee