@depup/nexe 5.0.0-beta.4-depup.0

package/lib/steps/clean.js

@@ -0,0 +1,30 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../util");
+function clean(compiler, next) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { options } = compiler;
+        if (options.clean) {
+            let path = compiler.src;
+            if (!options.build) {
+                path = compiler.getNodeExecutableLocation(compiler.options.targets[0]);
+            }
+            const step = compiler.log.step('Cleaning up nexe build artifacts...');
+            step.log(`Deleting contents at: ${path}`);
+            yield (0, util_1.rimrafAsync)(path);
+            step.log(`Deleted contents at: ${path}`);
+            return compiler.quit();
+        }
+        return next();
+    });
+}
+exports.default = clean;

package/lib/steps/cli.d.ts

@@ -0,0 +1,12 @@
+import { NexeCompiler } from '../compiler';
+/**
+ * The "cli" step detects the appropriate input. If no input options are passed,
+ * the package.json#main file is used.
+ * After all the build steps have run, the output (the executable) is written to a file or piped to stdout.
+ *
+ * Configuration:
+ *
+ * @param {*} compiler
+ * @param {*} next
+ */
+export default function cli(compiler: NexeCompiler, next: () => Promise<void>): Promise<unknown>;

package/lib/steps/cli.js

@@ -0,0 +1,55 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const fs_1 = require("fs");
+const util_1 = require("../util");
+const mkdirp = require("mkdirp");
+/**
+ * The "cli" step detects the appropriate input. If no input options are passed,
+ * the package.json#main file is used.
+ * After all the build steps have run, the output (the executable) is written to a file or piped to stdout.
+ *
+ * Configuration:
+ *
+ * @param {*} compiler
+ * @param {*} next
+ */
+function cli(compiler, next) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield next();
+        const { log } = compiler, target = compiler.options.targets.shift(), deliverable = yield compiler.compileAsync(target), output = (0, path_1.normalize)(compiler.output);
+        mkdirp.sync((0, path_1.dirname)(output));
+        return new Promise((res, rej) => {
+            const step = log.step('Writing result to file');
+            deliverable
+                .pipe((0, fs_1.createWriteStream)(output))
+                .on('error', rej)
+                .once('close', (e) => {
+                if (e) {
+                    rej(e);
+                }
+                else if (compiler.output) {
+                    const output = compiler.output, mode = (0, fs_1.statSync)(output).mode | 0o111, inputFileLogOutput = (0, path_1.relative)(process.cwd(), (0, path_1.resolve)(compiler.options.cwd, compiler.entrypoint || compiler.options.input)), outputFileLogOutput = (0, path_1.relative)(process.cwd(), output);
+                    (0, fs_1.chmodSync)(output, mode.toString(8).slice(-3));
+                    step.log(`Entry: '${compiler.stdinUsed
+                        ? compiler.options.mangle
+                            ? util_1.STDIN_FLAG
+                            : '[none]'
+                        : inputFileLogOutput}' written to: ${outputFileLogOutput}`);
+                    compiler.quit();
+                    res(output);
+                }
+            });
+        });
+    });
+}
+exports.default = cli;

package/lib/steps/download.d.ts

@@ -0,0 +1,7 @@
+import { NexeCompiler } from '../compiler';
+/**
+ * Downloads the node source to the configured temporary directory
+ * @param {*} compiler
+ * @param {*} next
+ */
+export default function downloadNode(compiler: NexeCompiler, next: () => Promise<void>): Promise<void>;

package/lib/steps/download.js

@@ -0,0 +1,76 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const download = require("download");
+const util_1 = require("../util");
+const compiler_1 = require("../compiler");
+const path_1 = require("path");
+function fetchNodeSourceAsync(dest, url, step, options = {}) {
+    const setText = (p) => step.modify(`Downloading Node: ${p.toFixed()}%...`);
+    return download(url, dest, Object.assign(options, { extract: true, strip: 1 }))
+        .on('response', (res) => {
+        const total = +res.headers['content-length'];
+        let current = 0;
+        res.on('data', (data) => {
+            current += data.length;
+            setText((current / total) * 100);
+            if (current === total) {
+                step.log('Extracting Node...');
+            }
+        });
+    })
+        .then(() => step.log(`Node source extracted to: ${dest}`));
+}
+function fetchPrebuiltBinary(compiler, step) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { target, remoteAsset } = compiler, filename = compiler.getNodeExecutableLocation(target);
+        try {
+            yield download(remoteAsset, (0, path_1.dirname)(filename), compiler.options.downloadOptions).on('response', (res) => {
+                const total = +res.headers['content-length'];
+                let current = 0;
+                res.on('data', (data) => {
+                    current += data.length;
+                    step.modify(`Downloading...${((current / total) * 100).toFixed()}%`);
+                });
+            });
+        }
+        catch (e) {
+            if (e.statusCode === 404) {
+                throw new compiler_1.NexeError(`${remoteAsset} is not available, create it using the --build flag`);
+            }
+            else {
+                throw new compiler_1.NexeError('Error downloading prebuilt binary: ' + e);
+            }
+        }
+    });
+}
+/**
+ * Downloads the node source to the configured temporary directory
+ * @param {*} compiler
+ * @param {*} next
+ */
+function downloadNode(compiler, next) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { src, log, target } = compiler, { version } = target, { sourceUrl, downloadOptions, build } = compiler.options, url = sourceUrl || `https://nodejs.org/dist/v${version}/node-v${version}.tar.gz`, step = log.step(`Downloading ${build ? '' : 'pre-built '}Node.js${build ? ` source from: ${url}` : ''}`), exeLocation = compiler.getNodeExecutableLocation(build ? undefined : target), downloadExists = yield (0, util_1.pathExistsAsync)(build ? src : exeLocation);
+        if (downloadExists) {
+            step.log('Already downloaded...');
+            return next();
+        }
+        if (build) {
+            yield fetchNodeSourceAsync(src, url, step, downloadOptions);
+        }
+        else {
+            yield fetchPrebuiltBinary(compiler, step);
+        }
+        return next();
+    });
+}
+exports.default = downloadNode;

package/lib/steps/resource.d.ts

@@ -0,0 +1,2 @@
+import { NexeCompiler } from '../compiler';
+export default function resource(compiler: NexeCompiler, next: () => Promise<any>): Promise<any>;

package/lib/steps/resource.js

@@ -0,0 +1,38 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../util");
+const globby_1 = __importDefault(require("globby"));
+const path_1 = require("path");
+function resource(compiler, next) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { cwd, resources } = compiler.options;
+        if (!resources.length) {
+            return next();
+        }
+        const step = compiler.log.step('Bundling Resources...');
+        let count = 0;
+        // workaround for https://github.com/sindresorhus/globby/issues/127
+        // and https://github.com/mrmlnc/fast-glob#pattern-syntax
+        const resourcesWithForwardSlashes = resources.map((r) => r.replace(/\\/g, '/'));
+        yield (0, util_1.each)((0, globby_1.default)(resourcesWithForwardSlashes, { cwd, onlyFiles: true }), (file) => __awaiter(this, void 0, void 0, function* () {
+            count++;
+            step.log(`Including file: ${file}`);
+            yield compiler.addResource((0, path_1.resolve)(cwd, file));
+        }));
+        step.log(`Included ${count} file(s)`);
+        return next();
+    });
+}
+exports.default = resource;

package/lib/steps/shim.d.ts

@@ -0,0 +1,2 @@
+import { NexeCompiler } from '../compiler';
+export default function (compiler: NexeCompiler, next: () => Promise<void>): Promise<void>;