@lakutata/builder 3.1.3 → 3.1.6

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"/>'] : [],
@@ -449,8 +470,9 @@ async function must(command, args, cwd, what) {
  * @param targets
  * @param work
  * @param outdir
+ * @param progress Called with what is being downloaded (WinSW, NSIS, WiX)
  */
-export async function buildWindowsPackages(plan, targets, work, outdir) {
+export async function buildWindowsPackages(plan, targets, work, outdir, progress) {
     await mkdir(work, { recursive: true });
     const files = [];
     const service = plan.service;
@@ -460,14 +482,14 @@ export async function buildWindowsPackages(plan, targets, work, outdir) {
     await mkdir(serviceDirectory, { recursive: true });
     let environment;
     if (service) {
-        await copyFile(await ensureTool('winsw'), path.join(serviceDirectory, `${installPaths(plan).wrapper}.exe`));
+        await copyFile(await ensureTool('winsw', progress), path.join(serviceDirectory, `${installPaths(plan).wrapper}.exe`));
         await writeFile(path.join(serviceDirectory, `${installPaths(plan).wrapper}.xml`), serviceConfiguration(plan, service));
         environment = path.join(serviceDirectory, `${plan.name}.env`);
         await writeFile(environment, environmentFile(service));
     }
     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 +507,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,22 +525,22 @@ 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 })}`);
-            await must(await ensureTool('nsis'), ['/V2', '/INPUTCHARSET', 'UTF8', script], work, 'The installer of NSIS');
+            await must(await ensureTool('nsis', progress), ['/V2', '/INPUTCHARSET', 'UTF8', script], work, 'The installer of NSIS');
             files.push({ target: target, file: file, size: (await stat(file)).size });
             continue;
         }
         //msi: compiled by candle, linked by light
         const source = path.join(work, 'package.wxs');
         await writeFile(source, wixSource(plan, plan.directory, serviceDirectory, environment));
-        const candle = await ensureTool('wix');
+        const candle = await ensureTool('wix', progress);
         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,10 @@ 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';
+export { stageMobileApp, type MobileStage, type MobileStageOptions } from './lib/mobile/Stage.js';
+export { downloadMobileNode, MOBILE_NODE_RELEASE, MOBILE_NODE_VERSION, type AndroidAbi, type MobileNodeDownloadOptions, type MobilePlatform } from './lib/mobile/Node.js';
+export type { IosSdk, MobileAddons } from './lib/mobile/Addons.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,19 @@ 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;
+    /**
+     * Called with what is being downloaded: the runtime of NW.js, the tools making the installers
+     */
+    progress?: (line: string) => void;
 };
 export type InstallerResult = {
     name: string;
@@ -181,9 +196,13 @@ export type InstallerResult = {
         size: number;
     }[];
     /**
-     * The executable they install
+     * The executable they install, undefined for the applications of NW.js
      */
-    executable: ExecutableResult;
+    executable?: ExecutableResult;
+    /**
+     * The application of NW.js they install (runtime nwjs)
+     */
+    nwjs?: NwjsApp;
     warnings: string[];
 };
 /**
@@ -231,6 +250,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/Processes.d.ts

@@ -13,9 +13,10 @@ export declare function spawnCommand(command: string, args: string[], options: S
  * @param command
  * @param args
  * @param cwd
+ * @param env its environment, the one of the process by default
  * @return the exit code and the output
  */
-export declare function runCommand(command: string, args: string[], cwd: string): Promise<{
+export declare function runCommand(command: string, args: string[], cwd: string, env?: NodeJS.ProcessEnv): Promise<{
     code: number;
     output: string;
 }>;

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

@@ -22,11 +22,57 @@ declare const TOOLS: Record<'nfpm' | 'winsw' | 'nsis' | 'wix', Tool>;
  * The directory of the cache of lakutata (the one of its tool): LAKUTATA_CACHE_DIR, else ~/.cache/lakutata
  */
 export declare function cacheDirectory(): string;
+/**
+ * The options of a download
+ */
+type DownloadOptions = {
+    /**
+     * Told when the file is downloaded again: a line naming it, read after "Downloading "
+     */
+    progress?: (line: string) => void;
+    /**
+     * The headers of the requests
+     */
+    headers?: Record<string, string>;
+    /**
+     * The while (milliseconds) a connection has to receive the minimum in, else it is left for another one: 30 s by
+     * default
+     */
+    interval?: number;
+    /**
+     * The bytes a connection has to receive in each interval: 100 KB by default
+     */
+    minimum?: number;
+    /**
+     * The connections tried: 3 by default
+     */
+    attempts?: number;
+};
+/**
+ * Download a file, its sha256 computed while it is written. A connection receiving too little (one of the releases of
+ * GitHub can stay at some kilobytes a second while another one downloads the file at once) or broken is left for
+ * another one, which downloads the file again from its start
+ * @param url
+ * @param file
+ * @param options
+ */
+export declare function downloadFile(url: string, file: string, options?: DownloadOptions): Promise<string>;
+/**
+ * Move a directory written aside into its place in the cache. The one already there is kept when it is complete (put
+ * there by another build running at the same time), and replaced when it is not: left by a build that was stopped, or
+ * emptied by a cleaning of the temporary files that removes the files and keeps the directories (macOS cleans its
+ * temporary directory so)
+ * @param temporary The directory written, removed by the caller.
+ * @param target Its place in the cache.
+ * @param complete Whether the directory in its place is complete.
+ */
+export declare function moveIntoCache(temporary: string, target: string, complete: () => boolean): Promise<void>;
 /**
  * A tool of the builder: the one given by its environment variable (LAKUTATA_NFPM, LAKUTATA_WINSW, LAKUTATA_NSIS:
  * makensis.exe, LAKUTATA_WIX: candle.exe, next to light.exe), else the version of the builder, downloaded once into the
  * cache and checked with its sha256
  * @param name
+ * @param progress Called with what is being downloaded
  */
-export declare function ensureTool(name: keyof typeof TOOLS): Promise<string>;
+export declare function ensureTool(name: keyof typeof TOOLS, progress?: (line: string) => void): Promise<string>;
 export {};

package/dist/types/lib/linux/Linux.d.ts

@@ -21,8 +21,9 @@ export declare function scriptAction(target: Exclude<LinuxTarget, 'tar.gz'>, hoo
  * @param targets
  * @param work
  * @param outdir
+ * @param progress Called with what is being downloaded (nFPM)
  */
-export declare function buildLinuxPackages(plan: InstallerPlan, targets: LinuxTarget[], work: string, outdir: string): Promise<{
+export declare function buildLinuxPackages(plan: InstallerPlan, targets: LinuxTarget[], work: string, outdir: string, progress?: (line: string) => void): Promise<{
     target: string;
     file: string;
     size: number;

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