@lakutata/builder 3.1.1 → 3.1.5

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/Files.d.ts

@@ -27,6 +27,14 @@ type ScriptPath = {
      */
     base?: string;
 };
+/**
+ * The packages sharing the framework and holding addons, bundled with the application: the package of a file, the
+ * native files of one of its directories (shipped by the paths to its own directories)
+ */
+export type AddonPackages = {
+    packageOf(file: string): string | undefined;
+    nativeFilesOf(root: string, directory: string): string[];
+};
 /**
  * What a path from a module gives: the directory of its pattern, the parts from it, the scripts to bundle and the files
  * to copy (the files of its directories of data), or why it cannot be shipped
@@ -54,6 +62,7 @@ type Targets = {
  * paths their users give)
  */
 export declare class FileCollector {
+    protected readonly addons?: AddonPackages | undefined;
     /**
      * The scripts: their paths in the native tree, and their files
      */
@@ -71,8 +80,9 @@ export declare class FileCollector {
     /**
      * @param project The directory of the project: the scripts are named from it (as the modules the bundler gives, its
      * real path)
+     * @param addons The packages sharing the framework and holding addons
      */
-    constructor(project: string);
+    constructor(project: string, addons?: AddonPackages | undefined);
     /**
      * The key of a directory in the tree ("/" separated): its path from the project; outside of the project (the
      * packages of a workspace, linked), its path from the node_modules holding it, else a hash of its path (the paths of

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/Native.d.ts

@@ -121,10 +121,32 @@ export declare class NativeCollector {
     }[];
     /**
      * Whether a package is left out of the bundle: it holds addons, or one of its dependencies does (it loads them,
-     * with computed paths often), and it is not the project
+     * with computed paths often), and it is neither the project nor a package sharing the framework
      * @param root
      */
     protected isNative(root: string | undefined): root is string;
+    /**
+     * The package sharing the framework and holding addons a file belongs to: bundled with the application, the paths
+     * to its own directories ship their native files (its addons, its manifest, its data)
+     * @param file
+     * @returns its directory, undefined for a file of another package
+     */
+    addonPackageOf(file: string): string | undefined;
+    /**
+     * The native files of a directory of a package holding addons: the files node loads at run time (its addons, its
+     * libraries, its manifest, its data), without its scripts (bundled) and what node never loads
+     * @param root the directory of the package
+     * @param directory
+     */
+    nativeFilesOf(root: string, directory: string): string[];
+    /**
+     * The addons of the packages sharing the framework bundled with the application which are not shipped: none of
+     * their addons is loaded by a require or a path the bundler follows (they would not be found at run time)
+     * @param inputs the files bundled
+     * @param shipped the files of the tree (the addons loaded by a require, the files read by a path from a module)
+     * @returns the warnings, one by package
+     */
+    unshippedAddons(inputs: Iterable<string>, shipped: Iterable<string>): string[];
     /**
      * Resolve an import as esbuild does
      * @param build

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

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

@@ -0,0 +1,116 @@
+/**
+ * A release of NW.js: its version and the ones of the Node.js and the Chromium it embeds, the systems it is built for
+ */
+export type NwjsRelease = {
+    /**
+     * The version of NW.js (0.119.2)
+     */
+    version: string;
+    /**
+     * The day it was released (2026/10/22)
+     */
+    date: string;
+    /**
+     * The version of the Node.js it embeds (26.12.1)
+     */
+    node: string;
+    /**
+     * The version of the Chromium it embeds (156.0.8078.48)
+     */
+    chromium: string;
+    /**
+     * The systems it is built for: win-x64, win-ia32, win-arm64, osx-x64, osx-arm64, linux-x64, linux-ia32, linux-arm64
+     */
+    platforms: string[];
+};
+/**
+ * The flavors of NW.js: normal (the one shipped), sdk (with the developer tools, for the development)
+ */
+export type NwjsFlavor = 'normal' | 'sdk';
+/**
+ * The options of {@link downloadNwjs}
+ */
+export type NwjsRuntimeOptions = {
+    /**
+     * The version of NW.js: a version (0.72.0), latest (the latest release) or win7 (0.72.0, the last one running on
+     * Windows 7, 8 and 8.1)
+     */
+    version: string;
+    /**
+     * normal (by default) or sdk
+     */
+    flavor?: NwjsFlavor;
+    /**
+     * The system (process.platform: win32, darwin, linux), the one of the machine by default
+     */
+    platform?: NodeJS.Platform;
+    /**
+     * The architecture (process.arch: x64, ia32, arm64), the one of the machine by default. On a Mac with Apple silicon,
+     * a release without osx-arm64 (before 0.77) is the x64 one, run by Rosetta
+     */
+    arch?: string;
+};
+/**
+ * A runtime of NW.js, downloaded into the cache
+ */
+export type NwjsRuntime = NwjsRelease & {
+    flavor: NwjsFlavor;
+    /**
+     * Its system and its architecture as NW.js names them (osx-arm64)
+     */
+    platform: string;
+    /**
+     * The directory of the runtime: nw.exe and its libraries, nwjs.app, nw and its libraries
+     */
+    directory: string;
+    /**
+     * Its executable: nw.exe, nwjs.app/Contents/MacOS/nwjs, nw
+     */
+    executable: string;
+};
+/**
+ * Compare two versions (1.2.3)
+ * @param left
+ * @param right
+ */
+export declare function compareVersions(left: string, right: string): number;
+/**
+ * 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 declare function nwjsReleases(): Promise<NwjsRelease[]>;
+/**
+ * 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 declare function nwjsRelease(version: string): Promise<NwjsRelease>;
+/**
+ * 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 declare function nwjsPlatform(release: NwjsRelease, platform?: NodeJS.Platform, arch?: string): string;
+/**
+ * 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 declare function downloadNwjs(options: NwjsRuntimeOptions): Promise<NwjsRuntime>;