@lakutata/builder 3.1.3 → 3.1.5

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 };
+}

package/dist/esm/lib/win/Windows.js

@@ -12,8 +12,8 @@ export const WINDOWS_TARGETS = ['nsis', 'msi', 'zip'];
 /**
  * The architecture of the packages (the one of the executable)
  */
-function packageArch() {
-    return process.arch === 'arm64' ? 'arm64' : 'x64';
+function packageArch(plan) {
+    return { arm64: 'arm64', ia32: 'x86' }[plan.arch] ?? 'x64';
 }
 /**
  * A text of XML
@@ -164,8 +164,9 @@ function numericVersion(version) {
  * @param stage the files it installs
  * @param file
  * @param scripts the scripts of the application (written with the mark of UTF-8, which Windows PowerShell reads them by)
+ * @internal
  */
-function nsisScript(plan, stage, file, scripts) {
+export function nsisScript(plan, stage, file, scripts) {
     const uninstallKey = `Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\${plan.appId}`;
     //A text given (its $ are not variables of NSIS), a path of NSIS (its variables: $INSTDIR)
     const string = (value) => `"${value.replace(/\$/g, '$$$$').replace(/"/g, '$\\"')}"`;
@@ -187,15 +188,20 @@ function nsisScript(plan, stage, file, scripts) {
     const macro = (name) => scripts.include ? [`  !ifmacrodef ${name}`, `    !insertmacro ${name}`, '  !endif'] : [];
     //The directory of the application, given to its scripts
     const environment = '  System::Call \'Kernel32::SetEnvironmentVariable(t "LAKUTATA_INSTALL_DIR", t "$INSTDIR")i\'';
+    //A desktop application: shortcuts to its executable, no installation script (PowerShell) of the service and of the PATH
+    const desktop = plan.desktop;
+    const shortcuts = desktop ? [`$SMPROGRAMS\\${plan.productName}.lnk`, `$DESKTOP\\${plan.productName}.lnk`] : [];
+    //A 32-bit program (Windows 7 32-bit) in the programs of 32 bits, with the 32-bit registry
+    const wide = plan.arch !== 'ia32';
     return [
         'Unicode true',
         'ManifestDPIAware true',
-        '!include "x64.nsh"',
+        ...wide ? ['!include "x64.nsh"'] : [],
         `Name ${string(plan.productName)}`,
         `OutFile ${string(file)}`,
         //The icon of the application
         ...plan.icon ? [`Icon ${string(plan.icon)}`, `UninstallIcon ${string(plan.icon)}`] : [],
-        `InstallDir ${variables(`$PROGRAMFILES64\\${plan.name}`)}`,
+        `InstallDir ${variables(`${wide ? '$PROGRAMFILES64' : '$PROGRAMFILES'}\\${plan.name}`)}`,
         'RequestExecutionLevel admin',
         'SetCompressor /SOLID lzma',
         'ShowInstDetails show',
@@ -210,13 +216,11 @@ function nsisScript(plan, stage, file, scripts) {
         '',
         '; The 64-bit registry and system (the installer is a 32-bit program)',
         'Function .onInit',
-        '  SetRegView 64',
-        '  ${DisableX64FSRedirection}',
+        ...wide ? ['  SetRegView 64', '  ${DisableX64FSRedirection}'] : [],
         ...macro('customInit'),
         'FunctionEnd',
         'Function un.onInit',
-        '  SetRegView 64',
-        '  ${DisableX64FSRedirection}',
+        ...wide ? ['  SetRegView 64', '  ${DisableX64FSRedirection}'] : [],
         ...macro('customUnInit'),
         'FunctionEnd',
         '',
@@ -225,32 +229,36 @@ function nsisScript(plan, stage, file, scripts) {
         environment,
         '  ; An upgrade replaces the application installed',
         '  StrCpy $R9 "install"',
-        '  IfFileExists "$INSTDIR\\installer.ps1" 0 +2',
+        `  IfFileExists ${variables(`$INSTDIR\\${desktop ? desktop.executable : 'installer.ps1'}`)} 0 +2`,
         '  StrCpy $R9 "upgrade"',
         ...hook('preinstall'),
-        '  ; The service of the version replaced is stopped: its files are replaced',
-        '  IfFileExists "$INSTDIR\\installer.ps1" 0 +3',
-        `  ${script('stop')}`,
-        '  Pop $0',
+        ...desktop ? [] : [
+            '  ; The service of the version replaced is stopped: its files are replaced',
+            '  IfFileExists "$INSTDIR\\installer.ps1" 0 +3',
+            `  ${script('stop')}`,
+            '  Pop $0'
+        ],
         '  SetOutPath "$INSTDIR"',
         `  File /r ${string(`${stage}\\*.*`)}`,
+        ...shortcuts.map((shortcut) => `  CreateShortCut ${variables(shortcut)} ${variables(`$INSTDIR\\${desktop.executable}`)}`),
         '  WriteUninstaller "$INSTDIR\\uninstall.exe"',
         `  WriteRegStr HKLM ${string(uninstallKey)} "DisplayName" ${string(plan.productName)}`,
         `  WriteRegStr HKLM ${string(uninstallKey)} "DisplayVersion" ${string(plan.version)}`,
         `  WriteRegStr HKLM ${string(uninstallKey)} "Publisher" ${string(plan.vendor ?? plan.maintainer)}`,
         `  WriteRegStr HKLM ${string(uninstallKey)} "InstallLocation" "$INSTDIR"`,
-        `  WriteRegStr HKLM ${string(uninstallKey)} "DisplayIcon" ${variables(`$INSTDIR\\${plan.program}.exe`)}`,
+        `  WriteRegStr HKLM ${string(uninstallKey)} "DisplayIcon" ${variables(`$INSTDIR\\${desktop ? desktop.executable : `${plan.program}.exe`}`)}`,
         `  WriteRegStr HKLM ${string(uninstallKey)} "UninstallString" '"$INSTDIR\\uninstall.exe"'`,
         `  WriteRegStr HKLM ${string(uninstallKey)} "QuietUninstallString" '"$INSTDIR\\uninstall.exe" /S'`,
         `  WriteRegDWORD HKLM ${string(uninstallKey)} "NoModify" 1`,
         `  WriteRegDWORD HKLM ${string(uninstallKey)} "NoRepair" 1`,
-        `  ${script('install')}`,
-        '  Pop $0',
-        '  StrCmp $0 "0" +2',
-        '  Abort "The installation failed ($0)"',
+        ...desktop ? [] : [
+            `  ${script('install')}`,
+            '  Pop $0',
+            '  StrCmp $0 "0" +2',
+            '  Abort "The installation failed ($0)"'
+        ],
         ...hook('postinstall'),
-        `  ${script('start')}`,
-        '  Pop $0',
+        ...desktop ? [] : [`  ${script('start')}`, '  Pop $0'],
         ...macro('customInstall'),
         'SectionEnd',
         '',
@@ -259,8 +267,7 @@ function nsisScript(plan, stage, file, scripts) {
         environment,
         '  StrCpy $R9 "remove"',
         ...macro('customUnInstall'),
-        `  ${script('uninstall')}`,
-        '  Pop $0',
+        ...desktop ? shortcuts.map((shortcut) => `  Delete ${variables(shortcut)}`) : [`  ${script('uninstall')}`, '  Pop $0'],
         ...hook('preremove'),
         '  RMDir /r "$INSTDIR"',
         `  DeleteRegKey HKLM ${string(uninstallKey)}`,
@@ -341,9 +348,11 @@ function msiScripts(hooks) {
  * @param stage the files it installs
  * @param serviceDirectory the files of its service (WinSW and its configuration)
  * @param environment the environment file
+ * @internal
  */
-function wixSource(plan, stage, serviceDirectory, environment) {
+export function wixSource(plan, stage, serviceDirectory, environment) {
     const scripts = msiScripts(plan.scripts.msi?.hooks ?? {});
+    const desktop = plan.desktop;
     const id = (prefix, value) => `${prefix}${createHash('sha1').update(value).digest('hex').slice(0, 30)}`;
     const components = [];
     const directory = (absolute, relative, depth) => {
@@ -379,20 +388,33 @@ function wixSource(plan, stage, serviceDirectory, environment) {
         ...plan.icon ? [`    <Icon Id="ProductIcon.ico" SourceFile="${xml(plan.icon)}"/>`, '    <Property Id="ARPPRODUCTICON" Value="ProductIcon.ico"/>'] : [],
         `    <Property Id="ARPINSTALLLOCATION" Value="[INSTALLDIR]"/>`,
         '    <Directory Id="TARGETDIR" Name="SourceDir">',
-        '      <Directory Id="ProgramFiles64Folder">',
+        `      <Directory Id="${plan.arch === 'ia32' ? 'ProgramFilesFolder' : 'ProgramFiles64Folder'}">`,
         `        <Directory Id="INSTALLDIR" Name="${xml(plan.name)}">`,
         ...files,
         '        </Directory>',
         '      </Directory>',
-        '      <Directory Id="CommonAppDataFolder">',
-        `        <Directory Id="DATADIR" Name="${xml(plan.name)}">`,
-        '          <Directory Id="LOGSDIR" Name="logs"/>',
-        '        </Directory>',
-        '      </Directory>',
+        ...desktop ? ['      <Directory Id="ProgramMenuFolder"/>', '      <Directory Id="DesktopFolder"/>'] : [
+            '      <Directory Id="CommonAppDataFolder">',
+            `        <Directory Id="DATADIR" Name="${xml(plan.name)}">`,
+            '          <Directory Id="LOGSDIR" Name="logs"/>',
+            '        </Directory>',
+            '      </Directory>'
+        ],
         '    </Directory>',
-        //The data, the logs and the environment file are kept by the removals
-        `    <Component Id="Data" Directory="DATADIR" Guid="${namedUuid(`${plan.appId}:data`)}" Permanent="yes" KeyPath="yes"><CreateFolder/></Component>`,
-        `    <Component Id="Logs" Directory="LOGSDIR" Guid="${namedUuid(`${plan.appId}:logs`)}" Permanent="yes" KeyPath="yes"><CreateFolder/></Component>`,
+        //The data, the logs and the environment file are kept by the removals (a service, a program of the command line)
+        ...desktop ? [] : [
+            `    <Component Id="Data" Directory="DATADIR" Guid="${namedUuid(`${plan.appId}:data`)}" Permanent="yes" KeyPath="yes"><CreateFolder/></Component>`,
+            `    <Component Id="Logs" Directory="LOGSDIR" Guid="${namedUuid(`${plan.appId}:logs`)}" Permanent="yes" KeyPath="yes"><CreateFolder/></Component>`
+        ],
+        //The shortcuts of a desktop application, their key a value of the registry of the user installing (the ones of
+        //the menus and of the desktop must be of HKCU: ICE43, ICE57)
+        ...desktop ? [
+            `    <Component Id="Shortcuts" Directory="INSTALLDIR" Guid="${namedUuid(`${plan.appId}:shortcuts`)}">`,
+            `      <Shortcut Id="ProgramMenuShortcut" Directory="ProgramMenuFolder" Name="${xml(plan.productName)}" Target="[INSTALLDIR]${xml(desktop.executable)}" WorkingDirectory="INSTALLDIR"/>`,
+            `      <Shortcut Id="DesktopShortcut" Directory="DesktopFolder" Name="${xml(plan.productName)}" Target="[INSTALLDIR]${xml(desktop.executable)}" WorkingDirectory="INSTALLDIR"/>`,
+            `      <RegistryValue Root="HKCU" Key="Software\\${xml(plan.appId)}" Name="Shortcuts" Type="integer" Value="1" KeyPath="yes"/>`,
+            '    </Component>'
+        ] : [],
         ...environment ? [`    <Component Id="Environment" Directory="DATADIR" Guid="${namedUuid(`${plan.appId}:environment`)}" Permanent="yes" NeverOverwrite="yes"><File Id="EnvironmentFile" Name="${xml(`${plan.name}.env`)}" Source="${xml(environment)}" KeyPath="yes"/></Component>`] : [],
         ...plan.addToPath ? [`    <Component Id="Path" Directory="INSTALLDIR" Guid="${namedUuid(`${plan.appId}:path`)}" KeyPath="yes"><Environment Id="Path" Name="PATH" Value="[INSTALLDIR]" Permanent="no" Part="last" Action="set" System="yes"/></Component>`] : [],
         ...service ? [
@@ -419,8 +441,7 @@ function wixSource(plan, stage, serviceDirectory, environment) {
         ] : [],
         '    <Feature Id="Application" Level="1">',
         ...components.map((component) => `      <ComponentRef Id="${component}"/>`),
-        '      <ComponentRef Id="Data"/>',
-        '      <ComponentRef Id="Logs"/>',
+        ...desktop ? ['      <ComponentRef Id="Shortcuts"/>'] : ['      <ComponentRef Id="Data"/>', '      <ComponentRef Id="Logs"/>'],
         ...environment ? ['      <ComponentRef Id="Environment"/>'] : [],
         ...plan.addToPath ? ['      <ComponentRef Id="Path"/>'] : [],
         ...service ? ['      <ComponentRef Id="Service"/>'] : [],
@@ -467,7 +488,7 @@ export async function buildWindowsPackages(plan, targets, work, outdir) {
     }
     for (const target of targets) {
         if (target === 'zip') {
-            const base = `${plan.name}-${plan.version}-win-${packageArch()}`;
+            const base = `${plan.name}-${plan.version}-win-${packageArch(plan)}`;
             await rm(path.join(work, base), { recursive: true, force: true });
             await cp(plan.directory, path.join(work, base), { recursive: true });
             const file = path.join(outdir, `${base}.zip`);
@@ -485,8 +506,9 @@ export async function buildWindowsPackages(plan, targets, work, outdir) {
             if (service)
                 for (const name of readdirSync(serviceDirectory).filter((name) => !name.endsWith('.env')))
                     await copyFile(path.join(serviceDirectory, name), path.join(stage, name));
-            //Windows PowerShell reads the scripts of UTF-8 by their mark
-            await writeFile(path.join(stage, 'installer.ps1'), `\ufeff${installerScript(plan)}`);
+            //Windows PowerShell reads the scripts of UTF-8 by their mark (a desktop application has none)
+            if (!plan.desktop)
+                await writeFile(path.join(stage, 'installer.ps1'), `\ufeff${installerScript(plan)}`);
             //The scripts of the application, extracted by the installer when it runs them
             const own = plan.scripts.nsis;
             const hooks = {};
@@ -502,7 +524,7 @@ export async function buildWindowsPackages(plan, targets, work, outdir) {
                 include = path.join(directory, 'include.nsh');
                 await writeFile(include, own.include.content);
             }
-            const file = path.join(outdir, `${plan.name}-${plan.version}-${packageArch()}-setup.exe`);
+            const file = path.join(outdir, `${plan.name}-${plan.version}-${packageArch(plan)}-setup.exe`);
             await rm(file, { force: true });
             const script = path.join(work, 'installer.nsi');
             await writeFile(script, `\ufeff${nsisScript(plan, stage, file, { hooks: hooks, include: include })}`);
@@ -515,9 +537,9 @@ export async function buildWindowsPackages(plan, targets, work, outdir) {
         await writeFile(source, wixSource(plan, plan.directory, serviceDirectory, environment));
         const candle = await ensureTool('wix');
         const light = path.join(path.dirname(candle), 'light.exe');
-        const file = path.join(outdir, `${plan.name}-${plan.version}-${packageArch()}.msi`);
+        const file = path.join(outdir, `${plan.name}-${plan.version}-${packageArch(plan)}.msi`);
         await rm(file, { force: true });
-        await must(candle, ['-nologo', '-arch', packageArch(), '-ext', 'WixUtilExtension', '-out', path.join(work, 'package.wixobj'), source], work, 'The package of Windows Installer');
+        await must(candle, ['-nologo', '-arch', packageArch(plan), '-ext', 'WixUtilExtension', '-out', path.join(work, 'package.wixobj'), source], work, 'The package of Windows Installer');
         await must(light, ['-nologo', '-ext', 'WixUtilExtension', '-spdb', '-out', file, path.join(work, 'package.wixobj')], work, 'The package of Windows Installer');
         files.push({ target: target, file: file, size: (await stat(file)).size });
     }

package/dist/types/index.d.ts

@@ -11,3 +11,7 @@ export { INSTALLER_HOOKS, NATIVE_HOOKS, type InstallerHook, type InstallerScript
 export { detectLibc } from './lib/Platform.js';
 export { WINDOWS_TARGETS, type WindowsTarget } from './lib/win/Windows.js';
 export { MAC_TARGETS, type MacTarget } from './lib/mac/Mac.js';
+export { downloadNwjs, nwjsPlatform, nwjsRelease, nwjsReleases, type NwjsFlavor, type NwjsRelease, type NwjsRuntime, type NwjsRuntimeOptions } from './lib/nwjs/Runtime.js';
+export { stageNwjsApp, type NwjsConfig, type NwjsStage, type NwjsStageOptions } from './lib/nwjs/Stage.js';
+export type { NwjsAddons } from './lib/nwjs/Addons.js';
+export { buildNwjsApp, type NwjsApp, type NwjsAppOptions } from './lib/nwjs/Package.js';

package/dist/types/lib/Bundle.d.ts

@@ -32,6 +32,11 @@ export type BundleOptions = {
      * The runtime running the bundle: node (by default), or bun (the executables of Bun, which bundle it again)
      */
     runtime?: 'node' | 'bun';
+    /**
+     * The version of Node.js running the bundle ("18.10", the one of NW.js 0.70): the bundle is written in the syntax that
+     * version reads; the version running the build by default
+     */
+    node?: string;
     /**
      * Whether the bundle is the one of an executable (buildExecutable): it runs the scripts of its tree it is started
      * for, in both layouts, and on Node.js it loads the modules left out of it from next to the executable

package/dist/types/lib/Directories.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Copy a directory into another one, its links kept as they are: cp -a on macOS and Linux (the copy of Node.js turns
+ * the relative links into absolute ones before Node.js 18.17 and 20.2: its option verbatimSymlinks), the copy of Node.js
+ * on Windows (its directories have no links)
+ * @param source
+ * @param target
+ */
+export declare function copyDirectory(source: string, target: string): Promise<void>;

package/dist/types/lib/Executable.d.ts

@@ -11,6 +11,13 @@ export type ExecutableOptions = Omit<BundleOptions, 'outfile' | 'native' | 'dire
      * installers, the images)
      */
     layout?: 'file' | 'directory';
+    /**
+     * The node program embedded in the executable, which also makes its single executable application. Another Node.js
+     * than the one running the build (20.12, 21.7 or later, which have the assets of the single executable applications),
+     * so that an older Node.js can run the build; the bundle is written in the syntax of the node program. The one
+     * running the build by default.
+     */
+    nodeProgram?: string;
 };
 export type ExecutableResult = {
     name: string;

package/dist/types/lib/Installer.d.ts

@@ -1,3 +1,4 @@
+import { type NwjsApp } from './nwjs/Package.js';
 import { type ExecutableResult } from './Executable.js';
 import { type InstallerScripts, type NativeScripts, type TargetScripts } from './Scripts.js';
 import { type LinuxTarget } from './linux/Linux.js';
@@ -63,9 +64,10 @@ export type InstallerConfig = {
     vendor?: string;
     /**
      * The runtime of the executable: node (by default) or bun; electron for the Electron applications, whose installers
-     * are made by electron-builder
+     * are made by electron-builder; nwjs for the applications of NW.js (lakutata.nwjs: its version), installed as desktop
+     * applications (shortcuts, /Applications, desktop entries)
      */
-    runtime?: 'node' | 'bun' | 'electron';
+    runtime?: 'node' | 'bun' | 'electron' | 'nwjs';
     /**
      * The configuration of electron-builder of an Electron application, merged over the one made from lakutata.installer
      */
@@ -168,6 +170,15 @@ export type InstallerOptions = {
      * The directory of the packages, dist/installer by default
      */
     outdir?: string;
+    /**
+     * The node program embedded in the executable (nodeProgram of buildExecutable), the one running the build by default
+     */
+    nodeProgram?: string;
+    /**
+     * The architecture of an application of NW.js (process.arch), the one of the machine by default: ia32 for the 32-bit
+     * systems of Windows (Windows 7)
+     */
+    arch?: string;
 };
 export type InstallerResult = {
     name: string;
@@ -181,9 +192,13 @@ export type InstallerResult = {
         size: number;
     }[];
     /**
-     * The executable they install
+     * The executable they install, undefined for the applications of NW.js
+     */
+    executable?: ExecutableResult;
+    /**
+     * The application of NW.js they install (runtime nwjs)
      */
-    executable: ExecutableResult;
+    nwjs?: NwjsApp;
     warnings: string[];
 };
 /**
@@ -231,6 +246,20 @@ export type InstallerPlan = {
      * (lakutata.icon), none without it
      */
     icon?: string;
+    /**
+     * The architecture of the program (process.arch: x64, ia32, arm64), which names the packages and, on Windows, the
+     * directory of the programs it is installed into
+     */
+    arch: string;
+    /**
+     * A desktop application (NW.js): its executable in the directory (<product>.exe, <product>.app, <program>), given
+     * shortcuts (Windows), a desktop entry and icons (Linux), installed into /Applications (macOS); without service and
+     * outside the PATH by default; its icon (a PNG image: lakutata.icon), which the icons of Linux are made of
+     */
+    desktop?: {
+        executable: string;
+        icon?: string;
+    };
 };
 /**
  * Make the installers of the application for the platform it is made on (the installers of the other platforms are

package/dist/types/lib/mac/Mac.d.ts

@@ -2,7 +2,7 @@ import type { InstallerPlan } from '../Installer.js';
 /**
  * The installers of macOS: the package of its installer, and the archive of the directory of the executable
  */
-export declare const MAC_TARGETS: readonly ["pkg", "tar.gz"];
+export declare const MAC_TARGETS: readonly ["pkg", "dmg", "tar.gz"];
 export type MacTarget = typeof MAC_TARGETS[number];
 /**
  * Make the installers of macOS of an application: the package installed by its installer (pkgbuild, productbuild), the

package/dist/types/lib/nwjs/Addons.d.ts

@@ -0,0 +1,51 @@
+import type { NativeFile } from '../Native.js';
+import { type NwjsRelease } from './Runtime.js';
+/**
+ * Make an addon of Windows load in NW.js: the libraries it imports (imported or delay-loaded) named node.exe are named
+ * node.dll, the library of NW.js holding the functions of Node.js (Node-API). The delay-load hook of node-gyp gives an
+ * addon the executable when it loads node.exe, which in NW.js does not export them: the addon fails to load ("A dynamic
+ * link library (DLL) initialization routine failed"), or blocks NW.js. Named node.dll, the library is the one NW.js
+ * loaded. The addon is changed in place (its other bytes are kept); it then loads in NW.js only, not in Node.js.
+ * @param file the content of the addon (a .node file of Windows)
+ * @returns the names changed: 0 when it imports no node.exe (an addon built for NW.js, or loading Node.js otherwise)
+ * @internal
+ */
+export declare function nameNwjsNode(file: Buffer): number;
+/**
+ * The architectures of a native binary (Mach-O, possibly universal; ELF; PE) as node names them: x64, ia32, arm64, arm
+ * @param file
+ * @internal
+ */
+export declare function binaryArchitectures(file: Buffer): string[];
+/**
+ * Whether an addon uses the C++ API of V8 (NAN, v8.h) rather than Node-API: the names of the functions of V8 it imports
+ * (mangled by the Itanium ABI or by MSVC). Built for the V8 of Node.js, it does not run in the one of NW.js (Chromium)
+ * @param file
+ * @internal
+ */
+export declare function usesV8Api(file: Buffer): boolean;
+/**
+ * What {@link prepareNwjsAddons} did to the addons of the native tree
+ */
+export type NwjsAddons = {
+    /**
+     * The addons whose node.exe was named node.dll (Windows)
+     */
+    renamed: string[];
+    /**
+     * The packages built again from their sources: for the architecture of the runtime, or with the headers of NW.js
+     */
+    rebuilt: string[];
+};
+/**
+ * Make the addons of the native tree of an application of NW.js load in its runtime: the packages whose addons are not
+ * for the architecture of the runtime (built with the headers of its Node.js), or use V8 (NW.js 0.111.3 and later: the
+ * headers of NW.js), built again from their sources; on Windows, the node.exe they import named node.dll
+ * @param project
+ * @param directory the native tree
+ * @param files the files of the tree (their sources)
+ * @param release
+ * @param platform the build of NW.js (win-x64, osx-arm64…)
+ * @internal
+ */
+export declare function prepareNwjsAddons(project: string, directory: string, files: NativeFile[], release: NwjsRelease, platform: string): Promise<NwjsAddons>;

package/dist/types/lib/nwjs/Package.d.ts

@@ -0,0 +1,52 @@
+import { type NwjsRuntime } from './Runtime.js';
+import { type NwjsStage, type NwjsStageOptions } from './Stage.js';
+/**
+ * The options of {@link buildNwjsApp}
+ */
+export type NwjsAppOptions = Omit<NwjsStageOptions, 'outdir'> & {
+    /**
+     * The directory of the application made (dist/nwjs by default): <program>-<build of NW.js> in it
+     */
+    outdir?: string;
+};
+/**
+ * The application of NW.js made by {@link buildNwjsApp}, distributed as it is or by its installers
+ */
+export type NwjsApp = {
+    /**
+     * Its directory: the runtime of NW.js and the application (Windows, Linux), the bundle of macOS (<product>.app)
+     */
+    directory: string;
+    /**
+     * Its executable, named after the program (<program>.exe, <product>.app/Contents/MacOS/nwjs, <program>)
+     */
+    executable: string;
+    /**
+     * The name of its program and of its product
+     */
+    program: string;
+    productName: string;
+    runtime: NwjsRuntime;
+    /**
+     * The application staged (its release, its addons): its directory is removed once copied
+     */
+    stage: NwjsStage;
+};
+/**
+ * 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 declare function buildNwjsApp(options: NwjsAppOptions): Promise<NwjsApp>;