@lakutata/builder 3.1.1 → 3.1.5

package/dist/esm/lib/nwjs/Package.js

@@ -0,0 +1,149 @@
+import { existsSync } from 'node:fs';
+import { cp, mkdir, mkdtemp, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { programName } from '../Bundle.js';
+import { applicationIcon, icnsFile, icoFile, setExecutableIcon } from '../Icons.js';
+import { runCommand } from '../Processes.js';
+import { downloadNwjs } from './Runtime.js';
+import { stageNwjsApp } from './Stage.js';
+/**
+ * Run a command which must succeed
+ * @param command
+ * @param args
+ * @param cwd
+ * @param what
+ */
+async function must(command, args, cwd, what) {
+    const result = await runCommand(command, args, cwd);
+    if (result.code !== 0)
+        throw new Error(`${what}: ${result.output.trim()}`);
+}
+/**
+ * Give the files of an application to every user: readable, its directories and its programs runnable. The archives of
+ * the older releases of NW.js (0.72) give their files to their owner only: installed by root (/opt, /Applications), the
+ * application would run for root only. The files of Windows have no modes
+ * @param directory
+ */
+async function shareFiles(directory) {
+    if (process.platform !== 'win32')
+        await must('chmod', ['-R', 'a+rX', directory], directory, 'The files of the application cannot be given to every user');
+}
+/**
+ * The four numbers of a version of Windows (1.2.3 → 1.2.3.0)
+ * @param version
+ */
+function windowsVersion(version) {
+    const parts = version.split(/[.+-]/).slice(0, 3).map((part) => Math.min(parseInt(part, 10) || 0, 65535));
+    return [parts[0] ?? 0, parts[1] ?? 0, parts[2] ?? 0, 0];
+}
+/**
+ * Give the executable of NW.js of Windows the identity of the application: its icon, and the names and the version of its
+ * version information (the ones the task manager and the properties of the file show)
+ * @param file
+ * @param identity
+ */
+async function windowsIdentity(file, identity) {
+    if (identity.ico)
+        await setExecutableIcon(file, identity.ico);
+    const { NtExecutable, NtExecutableResource, Resource } = await import('resedit');
+    const executable = NtExecutable.from(await readFile(file), { ignoreCert: true });
+    const resource = NtExecutableResource.from(executable);
+    const information = Resource.VersionInfo.fromEntries(resource.entries)[0] ?? Resource.VersionInfo.createEmpty();
+    const numbers = windowsVersion(identity.version);
+    information.setFileVersion(...numbers);
+    information.setProductVersion(...numbers);
+    const languages = information.getAllLanguagesForStringValues();
+    for (const language of languages.length ? languages : [{ lang: 1033, codepage: 1200 }]) {
+        information.setStringValues(language, {
+            FileDescription: identity.productName,
+            ProductName: identity.productName,
+            CompanyName: identity.company,
+            InternalName: identity.program,
+            OriginalFilename: `${identity.program}.exe`,
+            FileVersion: identity.version,
+            ProductVersion: identity.version
+        });
+    }
+    information.outputToResourceEntries(resource.entries);
+    resource.outputResource(executable);
+    await writeFile(file, Buffer.from(executable.generate()));
+}
+/**
+ * Make the application of NW.js of a project for this system: the runtime of NW.js (normal) with the application
+ * (stageNwjsApp: its bundle, its native addons made to load in NW.js, its resources, its manifest), named after it.
+ * On Windows and Linux, the files of the application are next to its executable (nw.exe, nw renamed after its program:
+ * the name of its installers, lakutata.installer.name, else the program of its package; on Windows, its icon and its
+ * version information are the ones of the application); on macOS, they are in the bundle
+ * (<product>.app/Contents/Resources/app.nw), whose Info.plist gives its name, its identifier (the appId of the
+ * installer), its version and its icon, signed again (ad hoc). The icon is lakutata.icon. Its files are readable by
+ * every user, its programs runnable (once installed by root, the application runs for the users)
+ * @param options
+ * @example
+ * import {buildNwjsApp} from '@lakutata/builder'
+ *
+ * //dist/nwjs/desk-osx-arm64/Desk.app on a Mac with Apple silicon
+ * const app = await buildNwjsApp({})
+ * console.log(app.directory, app.runtime.version)
+ */
+export async function buildNwjsApp(options) {
+    const project = path.resolve(options.project ?? process.cwd());
+    const manifest = JSON.parse(await readFile(path.join(project, 'package.json'), 'utf8'));
+    //The program is named after the package of its installers, else after the program of the package (the package of an
+    //application of a workspace is often named app)
+    const program = String(manifest.lakutata?.installer?.name ?? programName(manifest));
+    const productName = String(manifest.productName ?? manifest.lakutata?.installer?.productName ?? program);
+    const work = await mkdtemp(path.join(os.tmpdir(), 'lakutata-nwjs-app-'));
+    try {
+        const stage = await stageNwjsApp({ ...options, project: project, outdir: path.join(work, 'app'), minify: options.minify ?? true });
+        const runtime = await downloadNwjs({ version: stage.release.version, flavor: 'normal', platform: options.platform, arch: options.arch });
+        const directory = path.join(path.resolve(project, options.outdir ?? path.join('dist', 'nwjs')), `${program}-${runtime.platform}`);
+        await rm(directory, { recursive: true, force: true });
+        await mkdir(directory, { recursive: true });
+        const icon = applicationIcon(project, manifest);
+        const version = String(manifest.version ?? '0.0.0');
+        if (runtime.platform.startsWith('osx-')) {
+            //ditto keeps the links of the frameworks and the signatures of the helpers
+            const bundle = path.join(directory, `${productName}.app`);
+            await must('ditto', [path.join(runtime.directory, 'nwjs.app'), bundle], directory, 'The bundle of macOS cannot be copied');
+            await must('ditto', [stage.directory, path.join(bundle, 'Contents', 'Resources', 'app.nw')], directory, 'The application cannot be copied into the bundle');
+            const plist = path.join(bundle, 'Contents', 'Info.plist');
+            const appId = String(manifest.lakutata?.installer?.appId ?? `com.${program}.app`);
+            for (const [key, value] of Object.entries({ CFBundleName: productName, CFBundleDisplayName: productName, CFBundleIdentifier: appId, CFBundleShortVersionString: version, CFBundleVersion: version })) {
+                await must('plutil', ['-replace', key, '-string', value, plist], directory, `${key} cannot be written into the Info.plist`);
+            }
+            if (icon)
+                await writeFile(path.join(bundle, 'Contents', 'Resources', 'app.icns'), icnsFile(icon.image));
+            await shareFiles(bundle);
+            //Its files changed, the bundle is signed again (ad hoc: the signature of a developer is given by its installer)
+            await must('codesign', ['--force', '--deep', '--sign', '-', bundle], directory, 'The bundle cannot be signed');
+            return { directory: bundle, executable: path.join(bundle, 'Contents', 'MacOS', 'nwjs'), program: program, productName: productName, runtime: runtime, stage: stage };
+        }
+        //The links of the runtime of Linux kept as they are (cp -a); the runtime of Windows has none
+        for (const source of [runtime.directory, stage.directory]) {
+            if (process.platform === 'win32')
+                await cp(source, directory, { recursive: true });
+            else
+                await must('cp', ['-a', `${source}/.`, directory], directory, 'The application cannot be copied');
+        }
+        const windows = runtime.platform.startsWith('win-');
+        const executable = path.join(directory, windows ? `${program}.exe` : program);
+        await rename(path.join(directory, windows ? 'nw.exe' : 'nw'), executable);
+        if (windows) {
+            await windowsIdentity(executable, {
+                productName: productName,
+                program: program,
+                version: version,
+                company: String(manifest.lakutata?.installer?.vendor ?? (typeof manifest.author === 'string' ? manifest.author : manifest.author?.name) ?? productName),
+                ico: icon && icoFile(icon.image)
+            });
+        }
+        if (!existsSync(executable))
+            throw new Error(`The executable of NW.js ${runtime.version} (${runtime.platform}) is missing`);
+        await shareFiles(directory);
+        return { directory: directory, executable: executable, program: program, productName: productName, runtime: runtime, stage: stage };
+    }
+    finally {
+        await rm(work, { recursive: true, force: true });
+    }
+}

package/dist/esm/lib/nwjs/Runtime.js

@@ -0,0 +1,214 @@
+import { createHash } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { mkdir, mkdtemp, open, readFile, rename, rm, stat, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { runCommand } from '../Processes.js';
+import { cacheDirectory } from '../Tools.js';
+/**
+ * The oldest Node.js lakutata runs on: the releases of NW.js embedding an older one are refused
+ */
+const OLDEST_NODE = '18.10.0';
+/**
+ * The aliases of the versions
+ */
+const ALIASES = { win7: '0.72.0' };
+/**
+ * The releases are read again after a day
+ */
+const RELEASES_TTL = 24 * 60 * 60 * 1000;
+/**
+ * Where the releases are downloaded from: LAKUTATA_NWJS_MIRROR (a mirror of dl.nwjs.io), else dl.nwjs.io
+ */
+function mirror() {
+    return (process.env.LAKUTATA_NWJS_MIRROR ?? 'https://dl.nwjs.io').replace(/\/+$/, '');
+}
+/**
+ * Compare two versions (1.2.3)
+ * @param left
+ * @param right
+ */
+export function compareVersions(left, right) {
+    const parts = (version) => version.replace(/^v/, '').split('.').map((part) => parseInt(part, 10) || 0);
+    const [a, b] = [parts(left), parts(right)];
+    for (let index = 0; index < Math.max(a.length, b.length); index++) {
+        const difference = (a[index] ?? 0) - (b[index] ?? 0);
+        if (difference)
+            return difference;
+    }
+    return 0;
+}
+/**
+ * The releases of NW.js, newest first: the list of nwjs.io (LAKUTATA_NWJS_VERSIONS), kept a day in the cache; the
+ * cached one when it cannot be read
+ * @example
+ * import {nwjsReleases} from '@lakutata/builder'
+ *
+ * for (const release of (await nwjsReleases()).slice(0, 3)) console.log(release.version, release.node, release.chromium)
+ */
+export async function nwjsReleases() {
+    const cache = path.join(cacheDirectory(), 'nwjs', 'versions.json');
+    const fresh = existsSync(cache) && Date.now() - (await stat(cache)).mtimeMs < RELEASES_TTL;
+    let list;
+    if (!fresh) {
+        try {
+            const response = await fetch(process.env.LAKUTATA_NWJS_VERSIONS ?? 'https://nwjs.io/versions.json');
+            if (!response.ok)
+                throw new Error(`${response.status}`);
+            list = await response.json();
+            await mkdir(path.dirname(cache), { recursive: true });
+            await writeFile(cache, JSON.stringify(list));
+        }
+        catch (error) {
+            if (!existsSync(cache))
+                throw new Error(`The releases of NW.js cannot be read (${error.message}): LAKUTATA_NWJS_VERSIONS gives another list`, { cause: error });
+        }
+    }
+    list ??= JSON.parse(await readFile(cache, 'utf8'));
+    const versions = list.versions ?? [];
+    return versions.map((entry) => ({
+        version: String(entry.version).replace(/^v/, ''),
+        date: String(entry.date ?? ''),
+        node: String(entry.components?.node ?? ''),
+        chromium: String(entry.components?.chromium ?? ''),
+        platforms: (entry.files ?? []).map((file) => String(file).replace(/-symbol$/, '')).filter((file) => /^(win|osx|linux)-/.test(file))
+    })).sort((a, b) => compareVersions(b.version, a.version));
+}
+/**
+ * A release of NW.js: a version, latest (the latest release) or win7 (0.72.0, the last one running on Windows 7, 8
+ * and 8.1). Refused when it embeds a Node.js older than the one lakutata runs on (18.10)
+ * @param version
+ * @example
+ * import {nwjsRelease} from '@lakutata/builder'
+ *
+ * const release = await nwjsRelease('win7')
+ * console.log(release.version, release.node, release.chromium) //0.72.0 19.3.0 109.0.5414.87
+ */
+export async function nwjsRelease(version) {
+    const releases = await nwjsReleases();
+    const wanted = ALIASES[version] ?? version.replace(/^v/, '');
+    const release = wanted === 'latest' ? releases[0] : releases.find((item) => item.version === wanted);
+    if (!release)
+        throw new Error(`NW.js ${version} is not a release of NW.js (the latest: ${releases[0]?.version})`);
+    if (compareVersions(release.node, OLDEST_NODE) < 0)
+        throw new Error(`NW.js ${release.version} embeds Node.js ${release.node}: lakutata runs on Node.js ${OLDEST_NODE} or later (NW.js 0.70.0 or later)`);
+    return release;
+}
+/**
+ * The system and the architecture of a release as NW.js names them (osx-arm64), the x64 build on a Mac with Apple
+ * silicon when the release has no arm64 one
+ * @param release
+ * @param platform
+ * @param arch
+ */
+export function nwjsPlatform(release, platform = process.platform, arch = process.arch) {
+    const system = { win32: 'win', darwin: 'osx', linux: 'linux' }[platform];
+    if (!system)
+        throw new Error(`NW.js has no build for ${platform}`);
+    const name = `${system}-${arch}`;
+    if (release.platforms.includes(name))
+        return name;
+    if (system === 'osx' && arch === 'arm64' && release.platforms.includes('osx-x64'))
+        return 'osx-x64';
+    throw new Error(`NW.js ${release.version} has no build for ${name} (${release.platforms.join(', ')})`);
+}
+/**
+ * The sha256 of the files of a release, from its SHASUMS256.txt
+ * @param version
+ */
+async function checksums(version) {
+    const url = `${mirror()}/v${version}/SHASUMS256.txt`;
+    const response = await fetch(url);
+    if (!response.ok)
+        throw new Error(`The checksums of NW.js ${version} cannot be read (${url}: ${response.status})`);
+    const sums = new Map();
+    for (const line of (await response.text()).split('\n')) {
+        const match = line.trim().match(/^([0-9a-f]{64})\s+\*?(.+)$/);
+        if (match)
+            sums.set(match[2], match[1]);
+    }
+    return sums;
+}
+/**
+ * Download a file, its sha256 computed while it is written
+ * @param url
+ * @param file
+ */
+async function download(url, file) {
+    const response = await fetch(url);
+    if (!response.ok || !response.body)
+        throw new Error(`${url} cannot be downloaded (${response.status})`);
+    const hash = createHash('sha256');
+    const handle = await open(file, 'w');
+    try {
+        for await (const chunk of response.body) {
+            hash.update(chunk);
+            await handle.write(chunk);
+        }
+    }
+    finally {
+        await handle.close();
+    }
+    return hash.digest('hex');
+}
+/**
+ * The executable of a runtime in its directory
+ * @param platform
+ */
+function executableOf(platform) {
+    if (platform.startsWith('win-'))
+        return 'nw.exe';
+    if (platform.startsWith('osx-'))
+        return path.join('nwjs.app', 'Contents', 'MacOS', 'nwjs');
+    return 'nw';
+}
+/**
+ * A runtime of NW.js for a system, downloaded once into the cache (~/.cache/lakutata/nwjs, LAKUTATA_CACHE_DIR) from
+ * dl.nwjs.io (LAKUTATA_NWJS_MIRROR: a mirror of it) and checked with the SHASUMS256.txt of its release
+ * @param options
+ * @example
+ * import {downloadNwjs} from '@lakutata/builder'
+ *
+ * //The NW.js of the development (its developer tools), for the machine
+ * const runtime = await downloadNwjs({version: 'latest', flavor: 'sdk'})
+ * console.log(runtime.executable, runtime.node)
+ */
+export async function downloadNwjs(options) {
+    const release = await nwjsRelease(options.version);
+    const flavor = options.flavor ?? 'normal';
+    const platform = nwjsPlatform(release, options.platform, options.arch);
+    const name = `nwjs${flavor === 'sdk' ? '-sdk' : ''}-v${release.version}-${platform}`;
+    const archive = `${name}.${platform.startsWith('linux-') ? 'tar.gz' : 'zip'}`;
+    const target = path.join(cacheDirectory(), 'nwjs', name);
+    const runtime = { ...release, flavor: flavor, platform: platform, directory: target, executable: path.join(target, executableOf(platform)) };
+    if (existsSync(runtime.executable))
+        return runtime;
+    const sum = (await checksums(release.version)).get(archive);
+    if (!sum)
+        throw new Error(`NW.js ${release.version} has no ${archive} in its checksums`);
+    //Extracted aside, then renamed: the builds running together do not see it partly written
+    await mkdir(path.dirname(target), { recursive: true });
+    const temporary = await mkdtemp(`${target}.`);
+    try {
+        const file = path.join(temporary, archive);
+        const downloaded = await download(`${mirror()}/v${release.version}/${archive}`, file);
+        if (downloaded !== sum)
+            throw new Error(`The ${archive} downloaded is not the one of NW.js ${release.version} (sha256 ${downloaded}, ${sum} expected)`);
+        //ditto keeps the links of the frameworks of macOS; the tar of Windows reads the zip archives
+        const extracted = process.platform === 'darwin' && archive.endsWith('.zip')
+            ? await runCommand('ditto', ['-x', '-k', archive, '.'], temporary)
+            : await runCommand('tar', ['-xf', archive], temporary);
+        if (extracted.code !== 0)
+            throw new Error(`${archive} cannot be extracted: ${extracted.output.trim()}`);
+        if (!existsSync(path.join(temporary, name, executableOf(platform))))
+            throw new Error(`${archive} has no ${name}/${executableOf(platform).split(path.sep).join('/')}`);
+        await rename(path.join(temporary, name), target).catch((error) => {
+            //Extracted by another build
+            if (!existsSync(runtime.executable))
+                throw error;
+        });
+    }
+    finally {
+        await rm(temporary, { recursive: true, force: true });
+    }
+    return runtime;
+}

package/dist/esm/lib/nwjs/Stage.js

@@ -0,0 +1,92 @@
+import { existsSync } from 'node:fs';
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { bundleProject } from '../Bundle.js';
+import { nwjsPlatform, nwjsRelease } from './Runtime.js';
+import { prepareNwjsAddons } from './Addons.js';
+/**
+ * The background script of the application in NW.js: its Node.js context, where the application runs. Its timers are
+ * the ones of Node.js: the older releases (0.72) give the background page the timers of the browser, whose ids are
+ * numbers (without unref and refresh)
+ */
+const BACKGROUND_SCRIPT = `//The background script of the application in NW.js (its Node.js context): the timers of Node.js, then the application, bundled
+const timers = require('timers')
+for (const name of ['setTimeout', 'clearTimeout', 'setInterval', 'clearInterval', 'setImmediate', 'clearImmediate']) globalThis[name] = timers[name]
+require('./app.cjs')
+`;
+/**
+ * The NW.js of an application, from the "lakutata.nwjs" of its package.json
+ * @param manifest
+ */
+export function nwjsConfig(manifest) {
+    const config = manifest.lakutata?.nwjs;
+    if (!config || typeof config !== 'object' || typeof config.version !== 'string')
+        throw new Error('The application has no version of NW.js: give it with lakutata nwjs use <version> (latest, win7, 0.119.2…), which writes "lakutata": {"nwjs": {"version": …}} into its package.json');
+    return config;
+}
+/**
+ * The name of an application in NW.js: lower case, the characters of the names of the packages
+ * @param manifest
+ * @param config
+ */
+function nwjsName(manifest, config) {
+    const name = String(config.name ?? manifest.lakutata?.installer?.appId ?? manifest.name ?? 'app');
+    return name.toLowerCase().replace(/^@/, '').replace(/[^a-z0-9._-]+/g, '-');
+}
+/**
+ * Make the application of NW.js of a project: its bundle (CommonJS, for the Node.js of the release), its native tree
+ * and its resources (lakutata.resources), the manifest of NW.js (its name, its background script, the partition of the
+ * webviews holding its user interface) and the background script running the bundle
+ * @param options
+ * @example
+ * import {stageNwjsApp} from '@lakutata/builder'
+ *
+ * //The application of the development, run by: nw .nwjs/app
+ * const stage = await stageNwjsApp({outdir: '.nwjs/app'})
+ * console.log(stage.directory, stage.release.version, stage.name)
+ */
+export async function stageNwjsApp(options) {
+    const project = path.resolve(options.project ?? process.cwd());
+    const manifestFile = path.join(project, 'package.json');
+    if (!existsSync(manifestFile))
+        throw new Error(`${project} has no package.json`);
+    const manifest = JSON.parse(await readFile(manifestFile, 'utf8'));
+    const config = options.version ? { ...manifest.lakutata?.nwjs, version: options.version } : nwjsConfig(manifest);
+    const release = await nwjsRelease(config.version);
+    //nwjs.json, what the user interface is built for (its Chromium), follows the version of the application
+    const derived = `${JSON.stringify({ version: release.version, node: release.node, chromium: release.chromium }, null, 2)}\n`;
+    const derivedFile = path.join(project, 'nwjs.json');
+    if (!existsSync(derivedFile) || await readFile(derivedFile, 'utf8') !== derived)
+        await writeFile(derivedFile, derived);
+    const directory = path.resolve(project, options.outdir);
+    //The directory is made again: never the project or a directory holding it
+    if (!path.relative(directory, project).startsWith('..'))
+        throw new Error(`The application of NW.js is made in a directory of its own, not ${directory}`);
+    await rm(directory, { recursive: true, force: true });
+    await mkdir(directory, { recursive: true });
+    const bundle = await bundleProject({
+        project: project,
+        entry: options.entry,
+        outfile: path.join(directory, 'app.cjs'),
+        node: release.node,
+        minify: options.minify ?? false,
+        external: options.external,
+        directories: { native: 'app.native', resources: 'resources' }
+    });
+    //Its addons loaded by the runtime: its architecture, its headers, its library of Node.js on Windows
+    const platform = nwjsPlatform(release, options.platform, options.arch);
+    const addons = bundle.native && bundle.nativeDirectory ? await prepareNwjsAddons(project, bundle.nativeDirectory, bundle.native.files, release, platform) : { renamed: [], rebuilt: [] };
+    const name = nwjsName(manifest, config);
+    const nwManifest = {
+        name: name,
+        productName: manifest.productName ?? manifest.name,
+        version: manifest.version ?? '0.0.0',
+        main: 'main.js',
+        //The pages of the user interface, held by the webviews of the windows (without Node.js), are the files of the application
+        webview: { partitions: [{ name: 'trusted', accessible_resources: ['<all_urls>'] }] },
+        ...(config.chromiumArgs ? { 'chromium-args': config.chromiumArgs } : {})
+    };
+    await writeFile(path.join(directory, 'package.json'), `${JSON.stringify(nwManifest, null, 2)}\n`);
+    await writeFile(path.join(directory, 'main.js'), BACKGROUND_SCRIPT);
+    return { directory: directory, release: release, name: name, platform: platform, bundle: bundle, addons: addons };
+}