nw 0.85.0 → 0.86.0-sdk

package/src/get.js

@@ -0,0 +1,221 @@
+import fs from "node:fs";
+import path from "node:path";
+import url from 'node:url';
+
+import decompress from "./decompress.js";
+import ffmpeg from "./ffmpeg.js";
+import node from "./node.js";
+import nw from "./nw.js";
+
+import util from "./util.js";
+
+/**
+ * @typedef {object} GetOptions
+ * @property {string | "latest" | "stable" | "lts"} [version = "latest"]                  Runtime version
+ * @property {"normal" | "sdk"}                     [flavor = "normal"]                   Build flavor
+ * @property {"linux" | "osx" | "win"}              [platform]                            Target platform
+ * @property {"ia32" | "x64" | "arm64"}             [arch]                                Target arch
+ * @property {string}                               [downloadUrl = "https://dl.nwjs.io"]  Download server.
+ * @property {string}                               [cacheDir = "./cache"]                Cache directory
+ * @property {boolean}                              [cache = true]                        If false, remove cache and redownload.
+ * @property {boolean}                              [ffmpeg = false]                      If true, ffmpeg is not downloaded.
+ * @property {false | "gyp"}                        [nativeAddon = false]                 Rebuild native modules
+ */
+
+/**
+ * Get binaries.
+ *
+ * @async
+ * @function
+ * @param  {GetOptions}    options  Get mode options
+ * @return {Promise<void>}
+ */
+async function get(options) {
+
+  const uri = new url.URL(options.downloadUrl);
+  
+  /* Download server is the cached directory. */
+  if (uri.protocol === 'file:') {
+    options.cacheDir = path.resolve(decodeURIComponent(options.downloadUrl.slice('file://'.length)));
+  }
+
+  /**
+   * If `options.cacheDir` exists, then `true`. Otherwise, it is `false`.
+   *
+   * @type {boolean}
+   */
+  const cacheDirExists = await util.fileExists(options.cacheDir);
+  if (cacheDirExists === false) {
+    await fs.promises.mkdir(options.cacheDir, { recursive: true });
+  }
+
+  /**
+   * File path to compressed binary.
+   *
+   * @type {string}
+   */
+  let nwFilePath = path.resolve(
+    options.cacheDir,
+    `nwjs${options.flavor === "sdk" ? "-sdk" : ""}-v${options.version}-${options.platform}-${options.arch}.${options.platform === "linux" ? "tar.gz" : "zip"
+    }`,
+  );
+
+  /**
+   * File path to directory which contain NW.js and related binaries.
+   *
+   * @type {string}
+   */
+  let nwDirPath = path.resolve(
+    options.cacheDir,
+    `nwjs${options.flavor === "sdk" ? "-sdk" : ""}-v${options.version}-${options.platform}-${options.arch}`,
+  );
+
+  // If `options.cache` is false, then remove the compressed binary.
+  if (options.cache === false) {
+    await fs.promises.rm(nwFilePath, {
+      recursive: true,
+      force: true,
+    });
+  }
+
+  // We remove the nwDir to prevent the edge case where you download with ffmpeg flag enabled
+  // but want a subsequent build with ffmpeg flag disabled. By removing the directory and
+  // decompressing it again, we prevent the community ffmpeg files from being left over.
+  // This is important since the community ffmpeg builds have specific licensing constraints.
+  await fs.promises.rm(nwDirPath, { recursive: true, force: true });
+
+  /**
+   * If the compressed binary exists, then `true`. Otherwise, it is `false`.
+   *
+   * @type {boolean}
+   */
+  const nwFilePathExists = await util.fileExists(nwFilePath);
+  if (nwFilePathExists === false) {
+    nwFilePath = await nw(options.downloadUrl, options.version, options.flavor, options.platform, options.arch, options.cacheDir);
+  }
+
+  await decompress(nwFilePath, options.cacheDir);
+
+  await fs.promises.symlink(nwDirPath, './nwjs', );
+
+  if (options.ffmpeg === true) {
+
+    /**
+     * File path to compressed binary which contains community FFmpeg binary.
+     *
+     * @type {string}
+     */
+    let ffmpegFilePath = path.resolve(
+      options.cacheDir,
+      `ffmpeg-${options.version}-${options.platform}-${options.arch}.zip`,
+    );
+
+    // If `options.cache` is false, then remove the compressed binary.
+    if (options.cache === false) {
+      await fs.promises.rm(ffmpegFilePath, {
+        recursive: true,
+        force: true,
+      });
+    }
+
+    /**
+     * If the compressed binary exists, then `true`. Otherwise, it is `false`.
+     *
+     * @type {boolean}
+     */
+    const ffmpegFilePathExists = await util.fileExists(ffmpegFilePath);
+    if (ffmpegFilePathExists === false) {
+      // Do not update the options.downloadUrl with the ffmpeg URL here. Doing so would lead to error when options.ffmpeg and options.nativeAddon are both enabled.
+      const downloadUrl =
+        "https://github.com/nwjs-ffmpeg-prebuilt/nwjs-ffmpeg-prebuilt/releases/download";
+      ffmpegFilePath = await ffmpeg(downloadUrl, options.version, options.platform, options.arch, options.cacheDir);
+    }
+
+    await decompress(ffmpegFilePath, options.cacheDir);
+
+    /**
+     * Platform dependant file name of FFmpeg binary.
+     *
+     * @type {string}
+     */
+    let ffmpegFileName = "";
+
+    if (options.platform === "linux") {
+      ffmpegFileName = "libffmpeg.so";
+    } else if (options.platform === "win") {
+      ffmpegFileName = "ffmpeg.dll";
+    } else if (options.platform === "osx") {
+      ffmpegFileName = "libffmpeg.dylib";
+    }
+
+    /**
+     * File path to platform specific FFmpeg file.
+     *
+     * @type {string}
+     */
+    let ffmpegBinaryPath = path.resolve(options.cacheDir, ffmpegFileName);
+
+    /**
+     * File path of where FFmpeg will be copied to.
+     *
+     * @type {string}
+     */
+    let ffmpegBinaryDest = "";
+
+    if (options.platform === "linux") {
+      ffmpegBinaryDest = path.resolve(nwDirPath, "lib", ffmpegFileName);
+    } else if (options.platform === "win") {
+      ffmpegBinaryDest = path.resolve(nwDirPath, ffmpegFileName);
+    } else if (options.platform === "osx") {
+      ffmpegBinaryDest = path.resolve(
+        nwDirPath,
+        "nwjs.app",
+        "Contents",
+        "Frameworks",
+        "nwjs Framework.framework",
+        "Versions",
+        "Current",
+        ffmpegFileName,
+      );
+    }
+
+    await fs.promises.copyFile(ffmpegBinaryPath, ffmpegBinaryDest);
+
+  }
+
+  if (options.nativeAddon === "gyp") {
+
+    /**
+     * File path to NW'js Node headers tarball.
+     *
+     * @type {string}
+     */
+    let nodeFilePath = path.resolve(
+      options.cacheDir,
+      `headers-v${options.version}.tar.gz`,
+    );
+
+    // If `options.cache` is false, then remove the compressed binary.
+    if (options.cache === false) {
+      await fs.promises.rm(nodeFilePath, {
+        recursive: true,
+        force: true,
+      });
+    }
+
+    /**
+     * If the compressed binary exists, then `true`. Otherwise, it is `false`.
+     *
+     * @type {boolean}
+     */
+    const nodeFilePathExists = await util.fileExists(nodeFilePath);
+    if (nodeFilePathExists === false) {
+      nodeFilePath = await node(options.downloadUrl, options.version, options.cacheDir);
+    }
+
+    await decompress(nodeFilePath, options.cacheDir);
+
+  }
+}
+
+export default get;

package/src/index.js

@@ -0,0 +1,11 @@
+import get from './get.js';
+import run from './run';
+import util from './util.js';
+
+const { findpath } = util;
+
+export {
+    findpath,
+    get,
+    run,
+}

package/src/node.js

@@ -0,0 +1,50 @@
+import path from "node:path";
+
+import request from "./request.js";
+
+/**
+ * Download NW.js's Node.js headers.
+ *
+ * @param  {string}          downloadUrl  - Download server
+ * @param  {string}          version      - Runtime version
+ * @param  {string}          cacheDir     - Directory to store NW binaries
+ * @return {Promise<string>}              - path of compressed file which contains the Node headers.
+ */
+export default async function nw(downloadUrl, version, cacheDir) {
+
+  /**
+   * Name of directory which contains Node headers.
+   *
+   * @type {string}
+   */
+  const nodeDir = `node-v${version}`;
+
+  /**
+   * Name of compressed file which contains Node headers.
+   *
+   * @type {string}
+   */
+  const nwFile = `${nodeDir}.tar.gz`
+
+  /**
+   * URL to download specific Node headers from.
+   *
+   * @type {string}
+   */
+  const url = [
+    downloadUrl,
+    `v${version}`,
+    `nw-headers-v${version}.tar.gz`
+  ].join('/');
+
+  /**
+   * Absolute path of compressed file which contains Node headers.
+   */
+  const nwFileAbs = path.resolve(
+    cacheDir,
+    nwFile
+  );
+  await request(url, nwFileAbs);
+
+  return nwFileAbs;
+}

package/src/node.test.js

@@ -0,0 +1,24 @@
+import fs from "node:fs";
+
+import { afterEach, describe, expect, it } from "vitest";
+
+import node from "./node.js";
+import util from "./util.js";
+
+describe("get/node", function () {
+
+  let nodeFile = '';
+
+  afterEach(function () {
+    fs.promises.rm(nodeFile, { recursive: true, force: true });
+  });
+
+  it("downloades Node headers", async function () {
+    nodeFile = await node(
+      "https://dl.nwjs.io",
+      "0.83.0",
+      "./test/fixture"
+    );
+    expect(util.fileExists(nodeFile)).resolves.toBe(true);
+  }, Infinity);
+});

package/src/nw.js

@@ -0,0 +1,60 @@
+import path from "node:path";
+
+import request from "./request.js";
+
+/**
+ * Download NW.js binary.
+ *
+ * @param  {string}          downloadUrl  - Download server
+ * @param  {string}          version      - Runtime version
+ * @param  {string}          flavor       - Runtime build flavor
+ * @param  {string}          platform     - NW supported platform
+ * @param  {string}          arch         - NW supported architecture
+ * @param  {string}          cacheDir     - Directory to store NW binaries
+ * @return {Promise<string>}              - path of compressed file which contains NW.js binaries.
+ */
+export default async function nw(downloadUrl, version, flavor, platform, arch, cacheDir) {
+
+  /**
+   * Name of directory which contains NW.js binaries.
+   *
+   * @type {string}
+   */
+  const nwDir = [
+    `nwjs`,
+    flavor === 'sdk' ? '-sdk' : '',
+    `-v${version}-${platform}-${arch}`,
+  ].join('');
+
+  /**
+   * Name of compressed file which contains NW.js binaries.
+   *
+   * @type {string}
+   */
+  const nwFile = [
+    nwDir,
+    platform === 'linux' ? "tar.gz" : "zip"
+  ].join('.');
+
+  /**
+   * URL to download specific NW.js binary from.
+   *
+   * @type {string}
+   */
+  const url = [
+    downloadUrl,
+    `v${version}`,
+    nwFile,
+  ].join('/');
+
+  /**
+   * Absolute path of compressed file which contains NW.js binaries.
+   */
+  const nwFileAbs = path.resolve(
+    cacheDir,
+    nwFile
+  );
+  await request(url, nwFileAbs);
+
+  return nwFileAbs;
+}

package/src/nw.test.js

@@ -0,0 +1,28 @@
+import fs from "node:fs";
+import process from "node:process";
+
+import { afterEach, describe, expect, it } from "vitest";
+
+import nw from "./nw.js";
+import util from "./util.js";
+
+describe("get/nw", function () {
+
+  let nwFile = '';
+
+  afterEach(function () {
+    fs.promises.rm(nwFile, { recursive: true, force: true });
+  });
+
+  it("downloades a NW.js Linux tarball or Windows/MacOS zip", async function () {
+    nwFile = await nw(
+      "https://dl.nwjs.io",
+      "0.83.0",
+      "sdk",
+      util.PLATFORM_KV[process.platform],
+      util.ARCH_KV[process.arch],
+      "./test/fixture"
+    );
+    expect(util.fileExists(nwFile)).resolves.toBe(true);
+  }, Infinity);
+});

package/src/parse.js

@@ -0,0 +1,65 @@
+import process from 'node:process';
+
+import semver from 'semver';
+
+import nodeManifest from '../package.json' assert { type: 'json' };
+import util from '../src/util.js';
+
+/**
+ * @typedef {object} ParseOptions
+ * @property {string | "latest" | "stable" | "lts"} version                  Runtime version
+ * @property {"normal" | "sdk"}                     flavor                  Build flavor
+ * @property {"linux" | "osx" | "win"}              platform                            Target platform
+ * @property {"ia32" | "x64" | "arm64"}             arch                                Target arch
+ * @property {string}                               downloadUrl  Download server.
+ * @property {string}                               cacheDir                Cache directory
+ * @property {boolean}                              cache                        If false, remove cache and redownload.
+ * @property {boolean}                              ffmpeg                      If true, ffmpeg is not downloaded.
+ * @property {false | "gyp"}                        nativeAddon                 Rebuild native modules
+ */
+
+/**
+ * Parse options.
+ * 
+ * @param {ParseOptions} options 
+ * @return {Promise<ParseOptions>}
+ */
+export default async function parse(options) {
+    options.version = options.version ?? nodeManifest.version;
+    const parsedVersion = semver.parse(options.version);
+    options.version = [
+        parsedVersion.major,
+        parsedVersion.minor,
+        parsedVersion.patch
+    ].join('.');
+
+    options.flavor = options.flavor || process.env.npm_config_nwjs_build_type || process.env.NWJS_BUILD_TYPE || 'normal';
+
+    /* Check if version is a prelease. */
+    if (typeof parsedVersion?.prerelease?.[0] === 'string') {
+        let prerelease = parsedVersion.prerelease[0].split('-');
+        if (prerelease.length > 1) {
+            prerelease = prerelease.slice(0, -1);
+        }
+        options.version = [options.version, ...prerelease].join('-');
+    }
+
+    /* Check build flavor and slice that off the `version`. */
+    if (options.version.endsWith('-sdk')) {
+        options.version = options.version.slice(0, -4);
+        options.flavor = 'sdk';
+    } else if (options.version.endsWith('sdk')) {
+        options.version = version.slice(0, -3);
+        options.flavor = 'sdk';
+    }
+
+    options.platform = options.platform || util.PLATFORM_KV[process.env.npm_config_nwjs_platform || process.env.NWJS_PLATFORM || process.platform];
+    options.arch = options.arch || util.ARCH_KV[process.env.npm_config_nwjs_process_arch || process.env.NWJS_ARCH || process.arch];
+    options.downloadUrl = options.downloadUrl || process.env.npm_config_nwjs_urlbase || process.env.NWJS_URLBASE || 'https://dl.nwjs.io';
+    options.cacheDir = options.npm_config_nwjs_urlbase || process.env.npm_config_nwjs_cache_dir || process.env.NWJS_CACHE_DIR || '.';
+    options.cache = options.cache || process.env.npm_config_nwjs_cache || process.env.NWJS_CACHE || true;
+    options.ffmpeg = options.ffmpeg || process.env.npm_config_nwjs_ffmpeg || process.env.NWJS_FFMPEG || false;
+    options.nativeAddon = options.nativeAddon || process.env.npm_config_nwjs_native_addon || process.env.NWJS_NATIVE_ADDON || false;
+
+    return { ...options };
+}

package/src/postinstall.js

@@ -0,0 +1,63 @@
+import process from 'node:process';
+
+import semver from 'semver';
+
+import get from './get.js';
+import util from './util.js';
+
+import nodeManifest from '../package.json' assert { type: 'json' };
+
+await postinstall()
+    .catch((error) => {
+        if (error.code === 'EPERM') {
+            console.error('Unable to create symlink since user did not run as Administrator.');
+        }
+    });
+
+async function postinstall() {
+    const parsedVersion = semver.parse(nodeManifest.version);
+    let version = [
+        parsedVersion.major,
+        parsedVersion.minor,
+        parsedVersion.patch
+    ].join('.');
+
+    let flavor = process.env.npm_config_nwjs_build_type || process.env.NWJS_BUILD_TYPE || 'normal';
+    /* Check if version is a prelease. */
+    if (typeof parsedVersion?.prerelease?.[0] === 'string') {
+        let prerelease = parsedVersion.prerelease[0].split('-');
+        if (prerelease.length > 1) {
+            prerelease = prerelease.slice(0, -1);
+        }
+        version = [version, ...prerelease].join('-');
+    }
+
+    /* Check build flavor and slice that off the `version`. */
+    if (version.endsWith('-sdk')) {
+        version = version.slice(0, -4);
+        flavor = 'sdk';
+    } else if (version.endsWith('sdk')) {
+        version = version.slice(0, -3);
+        flavor = 'sdk';
+    }
+
+    const platform = util.PLATFORM_KV[process.env.npm_config_nwjs_platform || process.env.NWJS_PLATFORM || process.platform];
+    const arch = util.ARCH_KV[process.env.npm_config_nwjs_process_arch || process.env.NWJS_ARCH || process.arch];
+    const downloadUrl = process.env.npm_config_nwjs_urlbase || process.env.NWJS_URLBASE || 'https://dl.nwjs.io';
+    const cacheDir = process.env.npm_config_nwjs_cache_dir || process.env.NWJS_CACHE_DIR || '.';
+    const cache = process.env.npm_config_nwjs_cache || process.env.NWJS_CACHE || true;
+    const ffmpeg = process.env.npm_config_nwjs_ffmpeg || process.env.NWJS_FFMPEG || false;
+    const nativeAddon = process.env.npm_config_nwjs_native_addon || process.env.NWJS_NATIVE_ADDON || false;
+
+    await get({
+        version,
+        flavor,
+        platform,
+        arch,
+        downloadUrl,
+        cacheDir,
+        cache,
+        ffmpeg: ffmpeg,
+        nativeAddon: nativeAddon
+    });
+}

package/src/request.js

@@ -0,0 +1,27 @@
+import fs from "node:fs";
+import stream from "node:stream";
+
+import axios from "axios";
+
+/**
+ * Download from `url`.
+ *
+ * @async
+ * @function
+ * 
+ * @param  {string}        url       - Download server
+ * @param  {string}        filePath  - file path of downloaded content
+ * @return {Promise<void>}
+ */
+export default async function request(url, filePath) {
+
+  const writeStream = fs.createWriteStream(filePath);
+
+  const response = await axios({
+    method: "get",
+    url: url,
+    responseType: "stream"
+  });
+
+  await stream.promises.pipeline(response.data, writeStream);
+}

package/src/request.test.js

@@ -0,0 +1,25 @@
+import fs from "node:fs";
+
+import { afterEach, beforeAll, describe, expect, it } from "vitest";
+
+import request from "./request.js";
+import util from "./util.js";
+
+describe("get/request", function () {
+
+  let url = "https://raw.githubusercontent.com/nwutils/nw-builder/main/src/util/osx.arm.versions.json"
+  const filePath = "./test/fixture/request.test.json";
+
+  afterEach(async function () {
+    await fs.promises.rm(filePath, { force: true });
+  });
+
+  beforeAll(async function () {
+    await fs.promises.mkdir('./test/fixture', { recursive: true });
+  });
+
+  it("downloads from specific url", async function () {
+    await request(url, filePath);
+    expect(util.fileExists(filePath)).resolves.toBe(true);
+  }, Infinity);
+});

package/src/run.js

@@ -0,0 +1,66 @@
+import child_process from "node:child_process";
+import console from "node:console";
+import path from "node:path";
+import process from "node:process";
+
+import util from "./util.js";
+
+/**
+ * @typedef {object} RunOptions
+ * @property {string | "latest" | "stable" | "lts"} [version = "latest"]    Runtime version
+ * @property {"normal" | "sdk"}                     [flavor = "normal"]     Build flavor
+ * @property {"linux" | "osx" | "win"}              [platform]              Target platform
+ * @property {"ia32" | "x64" | "arm64"}             [arch]                  Target arch
+ * @property {string}                               [srcDir = "./src"]      Source directory
+ * @property {string}                               [cacheDir = "./cache"]  Cache directory
+ */
+
+/**
+ * Run NW.js application.
+ *
+ * @async
+ * @function
+ * 
+ * @param  {RunOptions}    options  Run mode options
+ * @return {Promise<void>}
+ */
+async function run({
+  version = "latest",
+  flavor = "normal",
+  platform = util.PLATFORM_KV[process.platform],
+  arch = util.ARCH_KV[process.arch],
+  srcDir = ".",
+  cacheDir = "./cache",
+}) {
+
+  try {
+    if (util.EXE_NAME[platform] === undefined) {
+      throw new Error("Unsupported platform.");
+    }
+
+    const nwDir = path.resolve(
+      cacheDir,
+      `nwjs${flavor === "sdk" ? "-sdk" : ""}-v${version}-${platform}-${arch}`,
+    );
+
+    return new Promise((res, rej) => {
+      const nwProcess = child_process.spawn(
+        path.resolve(nwDir, util.EXE_NAME[platform]),
+        [srcDir]
+      );
+
+      nwProcess.on("close", () => {
+        res();
+      });
+
+      nwProcess.on("error", (error) => {
+        console.error(error);
+        rej(error);
+      });
+    });
+  } catch (error) {
+    console.error(error);
+  }
+}
+
+export default run;