@lakutata/builder 3.1.3 → 3.1.5

package/README.md

@@ -6,7 +6,7 @@ The builder for lakutata applications. The `package bundle`, `package exe` and `
 `@lakutata/cli` use it, and a project's scripts can call it directly:
 
 ```js
-import {buildExecutable, buildInstaller, bundleProject} from '@lakutata/builder'
+import {buildExecutable, buildInstaller, buildNwjsApp, bundleProject} from '@lakutata/builder'
 
 //dist/<name>.cjs, run by node, with its native addons and its resources next to it
 await bundleProject({project: process.cwd()})
@@ -16,6 +16,8 @@ await buildExecutable({project: process.cwd(), runtime: 'node', layout: 'directo
 //dist/installer: the installers for the current platform (deb, rpm, apk, archlinux, tar.gz on Linux; pkg, tar.gz on
 //macOS; nsis, msi, zip on Windows), which also register the application's service when it declares one
 await buildInstaller({project: process.cwd()})
+//An NW.js application (its version in lakutata.nwjs): dist/nwjs/<name>-<build>, the runtime of NW.js named after it
+await buildNwjsApp({project: process.cwd()})
 ```
 
 The builder works on the compiled application: build the project with `tsc` first, since `tsc` emits the decorator
@@ -29,6 +31,14 @@ result. At run time, `resourcesPath()` from lakutata locates the application's r
 `lakutata package bundle`, `lakutata package exe` and `lakutata package installer` in the `@lakutata/cli`
 documentation.
 
+The NW.js applications run in the version of NW.js of their `lakutata.nwjs`. `nwjsReleases()` lists the releases of
+NW.js, `downloadNwjs()` downloads a runtime into the cache (checked against the checksums of its release), and
+`stageNwjsApp()` makes the application for NW.js: its bundle for the Node.js of that NW.js, its native addons made to
+load in it (built again for its architecture, or with its headers when they use the V8 API; on Windows, given the
+Node.js of NW.js), its resources and the manifest of NW.js. `buildNwjsApp()` puts it into the normal flavor of NW.js
+named after the application, and `buildInstaller()` makes its installers with `"runtime": "nwjs"` (the installers of a
+desktop application: dmg on macOS, nsis on Windows, deb on Linux by default).
+
 The Linux installers are tested in containers (Docker): `npm run test:installer` builds them on Debian and Alpine, then
 installs, upgrades and removes them on Debian and Fedora (systemd) and on Alpine (OpenRC). The macOS installers are
 installed in a macOS virtual machine (`npm run test:installer:mac`, with tart), and the Windows installers on Windows,

package/README.zh-CN.md

@@ -5,7 +5,7 @@
 lakutata 应用的打包工具。`@lakutata/cli` 的 `package bundle`、`package exe` 和 `package installer` 命令都靠它完成工作，项目的脚本也可以直接调用它：
 
 ```js
-import {buildExecutable, buildInstaller, bundleProject} from '@lakutata/builder'
+import {buildExecutable, buildInstaller, buildNwjsApp, bundleProject} from '@lakutata/builder'
 
 //dist/<name>.cjs，由 node 运行，原生插件和资源放在它旁边
 await bundleProject({project: process.cwd()})
@@ -15,10 +15,14 @@ await buildExecutable({project: process.cwd(), runtime: 'node', layout: 'directo
 //dist/installer：当前平台的安装包（Linux 上是 deb、rpm、apk、archlinux、tar.gz；macOS 上是 pkg、tar.gz；
 //Windows 上是 nsis、msi、zip），应用声明了服务时，安装包还会注册这个服务
 await buildInstaller({project: process.cwd()})
+//NW.js 应用（版本在 lakutata.nwjs 中）：dist/nwjs/<name>-<build>，以应用命名的 NW.js 运行时
+await buildNwjsApp({project: process.cwd()})
 ```
 
 打包工具处理的是编译后的应用：请先用 `tsc` 构建项目，因为装饰器的元数据是由 `tsc` 生成的。单文件包是一个 CommonJS 文件，由 esbuild 生成。原生插件不能打进单文件包，所以它们连同运行时加载的内容会一起收集到一个 native 目录树中。打包器跟踪不到应用按路径读取的文件，这些文件也放在这个目录树中：单独运行的脚本（worker、worker 池、`fork()`、`require(path.join(__dirname, 'x.js'))`）会各自打包，数据文件和目录则直接复制。打包工具会找出由模块位置构造的路径，并改写它们；无法一起发布的内容会列在结果的 `warnings` 中。运行时，lakutata 的 `resourcesPath()` 负责找到应用的资源，这些资源在应用 `package.json` 的 `lakutata.resources` 中声明。安装包则由同一个文件中的 `lakutata.installer` 配置。详见 `@lakutata/cli` 文档中的 `lakutata package bundle`、`lakutata package exe` 和 `lakutata package installer`。
 
+NW.js 应用运行在它 `lakutata.nwjs` 中指定的 NW.js 版本里。`nwjsReleases()` 列出 NW.js 的发布版本，`downloadNwjs()` 把一个运行时下载到缓存目录（按其发布版本的校验和核对），`stageNwjsApp()` 为 NW.js 准备应用：为这个 NW.js 的 Node.js 打包的代码、处理成能在其中加载的原生插件（为它的架构重新构建，使用 V8 API 的插件用它的头文件重新构建；在 Windows 上让插件加载 NW.js 的 Node.js）、资源和 NW.js 的清单。`buildNwjsApp()` 把应用放进以应用命名的 NW.js normal 版本中，`buildInstaller()` 在 `"runtime": "nwjs"` 时制作它的安装包（桌面应用的安装包：默认 macOS 上是 dmg，Windows 上是 nsis，Linux 上是 deb）。
+
 Linux 安装包在容器（Docker）中测试：`npm run test:installer` 先在 Debian 和 Alpine 上制作安装包，再在 Debian、Fedora（systemd）和 Alpine（OpenRC）上安装、升级和卸载它们。macOS 安装包在 macOS 虚拟机中测试安装（`npm run test:installer:mac`，使用 tart），Windows 安装包则在 Windows 上以管理员身份测试安装（`LAKUTATA_WINDOWS_INSTALL=1 npm run test:installer:windows`）。
 
 ## 另见

package/dist/esm/index.js

@@ -11,3 +11,6 @@ export { INSTALLER_HOOKS, NATIVE_HOOKS } from './lib/Scripts.js';
 export { detectLibc } from './lib/Platform.js';
 export { WINDOWS_TARGETS } from './lib/win/Windows.js';
 export { MAC_TARGETS } from './lib/mac/Mac.js';
+export { downloadNwjs, nwjsPlatform, nwjsRelease, nwjsReleases } from './lib/nwjs/Runtime.js';
+export { stageNwjsApp } from './lib/nwjs/Stage.js';
+export { buildNwjsApp } from './lib/nwjs/Package.js';

package/dist/esm/lib/Archive.js

@@ -1,5 +1,6 @@
-import { cp, rm, stat } from 'node:fs/promises';
+import { rm, stat } from 'node:fs/promises';
 import path from 'node:path';
+import { copyDirectory } from './Directories.js';
 import { runCommand } from './Processes.js';
 /**
  * The tar.gz archive of the directory of the executable (its native addons and its resources next to it), named after
@@ -12,7 +13,7 @@ import { runCommand } from './Processes.js';
 export async function archiveDirectory(plan, arch, work, outdir) {
     const base = `${plan.name}-${plan.version}-${process.platform}-${arch}`;
     await rm(path.join(work, base), { recursive: true, force: true });
-    await cp(plan.directory, path.join(work, base), { recursive: true, verbatimSymlinks: true });
+    await copyDirectory(plan.directory, path.join(work, base));
     const file = path.join(outdir, `${base}.tar.gz`);
     const archived = await runCommand('tar', ['-czf', file, base], work);
     if (archived.code !== 0)

package/dist/esm/lib/Bundle.js

@@ -25,6 +25,7 @@ const IMPORT_META_URL = '__lakutataImportMetaUrl';
  * arguments of the CommonJS modules: its file is the executable (as in the executables of Node.js), its require loads
  * the modules of node and the ones of a node_modules next to the executable (the ones left out of the bundle)
  */
+//node-compat: process.getBuiltinModule (Bun only)
 const BUN_PRELUDE = 'var __filename=process.execPath,__dirname=process.getBuiltinModule(\'node:path\').dirname(__filename),require=typeof require===\'function\'?require:process.getBuiltinModule(\'node:module\').createRequire(__filename);';
 /**
  * The files of the resources of an application, declared by the "lakutata.resources" of its package.json: their paths in
@@ -111,7 +112,7 @@ export async function bundleProject(options) {
             metafile: true,
             bundle: true,
             platform: 'node',
-            target: `node${process.versions.node.split('.')[0]}`,
+            target: `node${options.node?.replace(/^v/, '') ?? process.versions.node.split('.')[0]}`,
             format: 'cjs',
             minify: options.minify ?? true,
             //The names of the classes are the ones of the objects of the container and of the errors

package/dist/esm/lib/Directories.js

@@ -0,0 +1,18 @@
+import { cp, mkdir } from 'node:fs/promises';
+import path from 'node:path';
+import { runCommand } from './Processes.js';
+/**
+ * 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 async function copyDirectory(source, target) {
+    if (process.platform === 'win32')
+        return await cp(source, target, { recursive: true });
+    await mkdir(target, { recursive: true });
+    const copied = await runCommand('cp', ['-a', `${source}/.`, target], path.dirname(target));
+    if (copied.code !== 0)
+        throw new Error(`${source} cannot be copied: ${copied.output.trim()}`);
+}

package/dist/esm/lib/Executable.js

@@ -76,14 +76,31 @@ async function writeIcon(work, icon) {
     return file;
 }
 /**
- * Embed a bundle in the Node.js binary running the tool (the single executable applications of Node.js)
+ * The node program embedded in an executable and its version: the one given, else the one running the tool. It must
+ * have the assets of the single executable applications (Node.js 20.12, 21.7 or later): node:sea and its getAsset.
+ * @param program
+ */
+async function nodeOfExecutable(program) {
+    const node = program ? path.resolve(program) : process.execPath;
+    //node-compat: node:sea (the probe, run by the node program, loads it in a try)
+    const probe = await runCommand(node, ['-e', "let assets=false;try{assets=typeof require('node:sea').getAsset==='function'}catch{}process.stdout.write(process.version+' '+assets)"], process.cwd()).catch((error) => ({ code: 1, output: error.message }));
+    const [version, assets] = probe.output.trim().split(' ');
+    if (probe.code !== 0 || !/^v\d+\.\d+\.\d+$/.test(version))
+        throw new Error(`${node} cannot be run as the node program of the executable: ${probe.output.trim()}`);
+    if (assets !== 'true')
+        throw new Error(`The executables of Node.js need the assets of its single executable applications (Node.js 20.12, 21.7 or later): ${node} is Node.js ${version}. Give a newer node program (nodeProgram, --node-program). Or make the executable with Bun (--runtime bun)`);
+    return { path: node, version: version };
+}
+/**
+ * Embed a bundle in a Node.js binary (the single executable applications of Node.js)
  * @param bundle
  * @param work
  * @param file
  * @param warnings
+ * @param node the node program embedded
  * @param icon the icon of the application (ico, Windows)
  */
-async function embedInNode(bundle, work, file, warnings, icon) {
+async function embedInNode(bundle, work, file, warnings, node, icon) {
     const assets = {};
     if (bundle.native) {
         //The files of the native packages, extracted by the executable at its first run
@@ -104,9 +121,9 @@ async function embedInNode(bundle, work, file, warnings, icon) {
         useSnapshot: false,
         assets: assets
     }));
-    await must(process.execPath, ['--experimental-sea-config', 'sea-config.json'], work);
+    await must(node.path, ['--experimental-sea-config', 'sea-config.json'], work);
     const { inject } = await import('postject');
-    await copyFile(process.execPath, file);
+    await copyFile(node.path, file);
     //The icon of the application replaces the one of node.exe, before the bundle is embedded
     if (icon)
         await setExecutableIcon(file, icon);
@@ -119,7 +136,7 @@ async function embedInNode(bundle, work, file, warnings, icon) {
     //The Authenticode signature of node.exe does not match the executable anymore
     if (process.platform === 'win32')
         warnings.push(`${path.basename(file)} has the signature of Node.js, which is not valid anymore: sign it (signtool) before distributing it`);
-    return `Node.js ${process.version}`;
+    return `Node.js ${node.version}`;
 }
 /**
  * Compile a bundle into an executable of Bun, in bytecode: the files of the native tree are embedded beside it, the
@@ -189,6 +206,8 @@ export async function buildExecutable(options) {
     const outdir = path.resolve(project, options.outdir ?? 'dist');
     //Bun is found before the application is bundled
     const bun = options.runtime === 'bun' ? await findBun(project) : undefined;
+    //The node program embedded, checked before the application is bundled
+    const node = bun ? undefined : await nodeOfExecutable(options.nodeProgram);
     const work = await mkdtemp(path.join(os.tmpdir(), 'lakutata-executable-'));
     try {
         const directory = options.layout === 'directory';
@@ -200,6 +219,8 @@ export async function buildExecutable(options) {
             await rm(target, { recursive: true, force: true });
         await mkdir(target, { recursive: true });
         const bundle = await bundleProject({
+            //The syntax of the node embedded
+            ...node ? { node: node.version } : {},
             ...options,
             outfile: path.join(work, 'main.cjs'),
             native: directory ? 'directory' : 'embedded',
@@ -225,7 +246,7 @@ export async function buildExecutable(options) {
         //The icon of the application: the one of the executables of Windows (the ones of macOS and Linux have none)
         const application = applicationIcon(project, manifest);
         const icon = application && process.platform === 'win32' ? icoFile(application.image) : undefined;
-        const runtime = bun ? await compileWithBun(bun, embedded, work, made, icon) : await embedInNode(embedded, work, made, warnings, icon);
+        const runtime = bun ? await compileWithBun(bun, embedded, work, made, icon) : await embedInNode(embedded, work, made, warnings, node, icon);
         await copyFile(made, file);
         await chmod(file, 0o755);
         return {

package/dist/esm/lib/Installer.js

@@ -3,6 +3,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { programName } from './Bundle.js';
 import { buildElectronInstaller } from './electron/Electron.js';
+import { buildNwjsApp } from './nwjs/Package.js';
 import { buildExecutable } from './Executable.js';
 import { applicationIcon, icoFile } from './Icons.js';
 import { detectLibc } from './Platform.js';
@@ -51,10 +52,12 @@ export async function buildInstaller(options) {
     if (process.platform !== 'linux' && !mac && !windows)
         throw new Error(`The installers of ${process.platform} are not supported: the ones of Linux are made on Linux, the ones of macOS on macOS, the ones of Windows on Windows`);
     const libc = detectLibc();
+    //A desktop application (NW.js): its installers by default the ones of the desktop applications (as electron-builder)
+    const desktop = config.runtime === 'nwjs';
     const targets = options.targets?.length ? options.targets
-        : mac ? config.mac?.targets ?? ['pkg', 'tar.gz']
-            : windows ? config.win?.targets ?? ['nsis', 'msi', 'zip']
-                : config.linux?.targets ?? (libc === 'glibc' ? ['deb', 'rpm', 'tar.gz'] : ['apk', 'tar.gz']);
+        : mac ? config.mac?.targets ?? (desktop ? ['dmg'] : ['pkg', 'tar.gz'])
+            : windows ? config.win?.targets ?? (desktop ? ['nsis'] : ['nsis', 'msi', 'zip'])
+                : config.linux?.targets ?? (libc === 'glibc' ? (desktop ? ['deb'] : ['deb', 'rpm', 'tar.gz']) : desktop ? ['tar.gz'] : ['apk', 'tar.gz']);
     for (const target of targets) {
         if (mac) {
             if (!MAC_TARGETS.includes(target))
@@ -91,6 +94,8 @@ export async function buildInstaller(options) {
     if (!/^[A-Za-z0-9][A-Za-z0-9.-]*$/.test(appId))
         throw new Error(`The identifier of the application "${appId}" must be letters, digits, "." and "-" (lakutata.installer.appId)`);
     const service = config.service === true ? {} : config.service || undefined;
+    if (desktop && service)
+        throw new Error('A desktop application (lakutata.installer.runtime nwjs) has no service (lakutata.installer.service)');
     if (service?.name !== undefined && !/^[A-Za-z0-9_.@-]+$/.test(service.name))
         throw new Error(`The name of the service "${service.name}" must be letters, digits, "_", ".", "@" and "-"`);
     //A user of the system (Linux, macOS), an account of Windows (DOMAIN\user, NT SERVICE\name, a managed account ending in $)
@@ -108,35 +113,42 @@ export async function buildInstaller(options) {
             icon = path.join(work, 'icon.ico');
             await writeFile(icon, icoFile(application.image));
         }
-        const executable = await buildExecutable({
+        //The executable and what it loads; or the application of NW.js (its runtime, its executable named after it)
+        const nwjs = desktop ? await buildNwjsApp({ project: project, entry: options.entry, minify: options.minify, external: options.external, arch: options.arch, outdir: path.join(work, 'stage') }) : undefined;
+        const executable = nwjs ? undefined : await buildExecutable({
             project: project,
             entry: options.entry,
             minify: options.minify,
             external: options.external,
             runtime: config.runtime,
+            nodeProgram: options.nodeProgram,
             layout: 'directory',
             outdir: path.join(work, 'stage')
         });
-        warnings.push(...executable.warnings);
+        warnings.push(...executable?.warnings ?? nwjs.stage.bundle.warnings);
+        //The directory installed: the one of the bundle of macOS (/Applications/<product>.app), the one of the runtime of NW.js
+        const installed = nwjs ? (mac ? path.dirname(nwjs.directory) : nwjs.directory) : executable.directory;
+        const launcher = nwjs && path.basename(mac ? nwjs.directory : nwjs.executable);
         const plan = {
             name: name,
             appId: appId,
             productName: config.productName ?? (typeof manifest.productName === 'string' ? manifest.productName : name),
             program: program,
             version: version,
-            description: config.description ?? manifest.description ?? name,
+            //An empty description is none (the one of a project created without it): Windows Installer refuses it
+            description: config.description || manifest.description || name,
             maintainer: maintainer,
             homepage: config.homepage ?? (typeof manifest.homepage === 'string' ? manifest.homepage : undefined),
             license: config.license ?? (typeof manifest.license === 'string' ? manifest.license : undefined),
             vendor: config.vendor,
-            addToPath: config.addToPath ?? true,
+            addToPath: config.addToPath ?? !desktop,
             depends: config.linux?.depends ?? [],
             recommends: config.linux?.recommends ?? [],
             section: config.linux?.section,
             priority: config.linux?.priority,
             service: service && {
                 name: service.name ?? name,
-                description: service.description ?? config.description ?? manifest.description ?? name,
+                description: service.description || config.description || manifest.description || name,
                 args: service.args ?? [],
                 env: { MODE: 'production', ...service.env },
                 //The users of the services of macOS are hidden by their names (_www), the ones of Windows are virtual
@@ -144,17 +156,19 @@ export async function buildInstaller(options) {
                 restart: service.restart ?? 'on-failure',
                 autoStart: service.autoStart ?? true
             },
-            directory: executable.directory,
-            prefix: mac ? `/usr/local/lib/${name}` : windows ? `C:\\Program Files\\${name}` : `/opt/${name}`,
+            directory: installed,
+            prefix: mac ? (launcher ? `/Applications/${launcher}` : `/usr/local/lib/${name}`) : windows ? `C:\\Program Files\\${name}` : `/opt/${name}`,
             scripts: scripts,
-            icon: icon
+            icon: icon,
+            arch: nwjs ? nwjs.runtime.platform.slice(nwjs.runtime.platform.indexOf('-') + 1) : process.arch,
+            ...launcher ? { desktop: { executable: launcher, icon: application?.file } } : {}
         };
         const outdir = path.resolve(project, options.outdir ?? path.join('dist', 'installer'));
         await mkdir(outdir, { recursive: true });
         const files = mac ? await buildMacPackages(plan, targets, path.join(work, 'mac'), outdir)
             : windows ? await buildWindowsPackages(plan, targets, path.join(work, 'win'), outdir)
                 : await buildLinuxPackages(plan, targets, path.join(work, 'linux'), outdir);
-        return { name: name, version: version, files: files, executable: executable, warnings: warnings };
+        return { name: name, version: version, files: files, ...executable ? { executable: executable } : {}, ...nwjs ? { nwjs: nwjs } : {}, warnings: warnings };
     }
     finally {
         await rm(work, { recursive: true, force: true });

package/dist/esm/lib/NativeRuntime.js

@@ -30,8 +30,10 @@ export function lakutataNativeRequire(nodeRequire, config) {
     const fs = nodeRequire('node:fs');
     const os = nodeRequire('node:os');
     const { createRequire, isBuiltin } = nodeRequire('node:module');
+    //node-compat: node:sea (a type here; loaded below only where it exists)
     let sea;
     try {
+        //node-compat: node:sea
         sea = nodeRequire('node:sea');
     }
     catch {

package/dist/esm/lib/linux/Linux.js

@@ -1,7 +1,8 @@
 import { copyFileSync, lstatSync, mkdirSync, readdirSync, readlinkSync } from 'node:fs';
-import { stat, mkdir, writeFile, rm } from 'node:fs/promises';
+import { stat, mkdir, readFile, writeFile, rm } from 'node:fs/promises';
 import path from 'node:path';
 import { archiveDirectory } from '../Archive.js';
+import { decodePng, writeLinuxIcons } from '../Icons.js';
 import { runCommand } from '../Processes.js';
 import { ensureTool } from '../Tools.js';
 import { embeddedShell, INSTALLER_HOOKS, NATIVE_HOOKS } from '../Scripts.js';
@@ -18,11 +19,47 @@ const RUNTIME_DEPENDS = {
     apk: ['libstdc++', 'libgcc'],
     archlinux: ['gcc-libs']
 };
+/**
+ * The libraries of the system a desktop application of Chromium (NW.js) loads, by package: the deb ones of Electron, and
+ * the atomic operations the Node.js of NW.js loads (libnode.so needs libatomic.so.1, which only the compilers install)
+ */
+const DESKTOP_DEPENDS = {
+    deb: ['libgtk-3-0', 'libnotify4', 'libnss3', 'libxss1', 'libxtst6', 'xdg-utils', 'libatspi2.0-0', 'libuuid1', 'libsecret-1-0', 'libasound2', 'libgbm1', 'libatomic1'],
+    rpm: ['gtk3', 'libnotify', 'nss', 'libXScrnSaver', 'libXtst', 'xdg-utils', 'at-spi2-core', 'libuuid', 'libsecret', 'alsa-lib', 'mesa-libgbm', 'libatomic'],
+    apk: [],
+    archlinux: []
+};
+/**
+ * The desktop entry of a desktop application, which the menus of the desktops list
+ * @param plan
+ * @param executable
+ */
+function desktopEntry(plan, executable) {
+    return [
+        '[Desktop Entry]',
+        'Type=Application',
+        `Name=${plan.productName}`,
+        `Comment=${plan.description.replace(/\s+/g, ' ')}`,
+        `Exec="${plan.prefix}/${executable}" %U`,
+        `Icon=${plan.name}`,
+        'Terminal=false',
+        'Categories=Utility;',
+        ''
+    ].join('\n');
+}
+/**
+ * The lines refreshing the menus and the icons of the desktops after the installation and the removal of a desktop
+ * application, where their tools are installed
+ */
+const DESKTOP_REFRESH = [
+    'command -v update-desktop-database >/dev/null 2>&1 && update-desktop-database -q /usr/share/applications || true',
+    'command -v gtk-update-icon-cache >/dev/null 2>&1 && gtk-update-icon-cache -q -t -f /usr/share/icons/hicolor || true'
+];
 /**
  * The architecture of the packages (the one of Go, which nFPM translates for each package)
  */
-function packageArch() {
-    return { x64: 'amd64', arm64: 'arm64', ia32: '386', arm: 'arm7' }[process.arch] ?? process.arch;
+function packageArch(plan) {
+    return { x64: 'amd64', arm64: 'arm64', ia32: '386', arm: 'arm7' }[plan.arch] ?? plan.arch;
 }
 /**
  * The characters of the globs, which nFPM reads in the sources of the contents (the chunks of Turbopack are named
@@ -78,7 +115,7 @@ function packageFile(plan, target) {
     const arch = { x64: 'x86_64', arm64: 'aarch64' }[process.arch] ?? process.arch;
     switch (target) {
         case 'deb':
-            return `${plan.name}_${plan.version}_${packageArch()}.deb`;
+            return `${plan.name}_${plan.version}_${packageArch(plan)}.deb`;
         case 'rpm':
             return `${plan.name}-${plan.version}-1.${arch}.rpm`;
         case 'apk':
@@ -276,7 +313,8 @@ function packageScripts(plan, target) {
             //Not indented: the lines of the script are the ones of its file
             ...application ? [scriptAction(target, hook), 'if [ -n "$lakutata_action" ]; then', ...embeddedShell(application, plan.prefix, '"$lakutata_action"'), 'fi'] : [],
             ...native ? embeddedShell(native, plan.prefix, '"$@"') : [],
-            ...service.after[hook] ?? []
+            ...service.after[hook] ?? [],
+            ...plan.desktop && (hook === 'postinstall' || hook === 'postremove' || hook === 'postupgrade') ? DESKTOP_REFRESH : []
         ];
         if (lines.length)
             scripts[hook] = ['#!/bin/sh', 'set -e', ...lines, ''].join('\n');
@@ -297,7 +335,7 @@ export async function buildLinuxPackages(plan, targets, work, outdir) {
     const service = plan.service;
     for (const target of targets) {
         if (target === 'tar.gz') {
-            files.push(await archiveDirectory(plan, packageArch(), work, outdir));
+            files.push(await archiveDirectory(plan, packageArch(plan), work, outdir));
             continue;
         }
         const directory = path.join(work, target);
@@ -305,6 +343,17 @@ export async function buildLinuxPackages(plan, targets, work, outdir) {
         const contents = packageContents(plan.directory, plan.prefix, directory);
         if (plan.addToPath)
             contents.push({ src: `${plan.prefix}/${plan.program}`, dst: `/usr/bin/${plan.program}`, type: 'symlink' });
+        if (plan.desktop) {
+            //Its entry in the menus of the desktops, its icons in the theme hicolor
+            await writeFile(path.join(directory, 'desktop'), desktopEntry(plan, plan.desktop.executable));
+            contents.push({ src: path.join(directory, 'desktop'), dst: `/usr/share/applications/${plan.name}.desktop`, file_info: { mode: 0o644 } });
+            if (plan.desktop.icon) {
+                for (const icon of await writeLinuxIcons(decodePng(await readFile(plan.desktop.icon), plan.desktop.icon), path.join(directory, 'icons'))) {
+                    const size = path.basename(icon, '.png');
+                    contents.push({ src: icon, dst: `/usr/share/icons/hicolor/${size}/apps/${plan.name}.png`, file_info: { mode: 0o644 } });
+                }
+            }
+        }
         if (service) {
             await writeFile(path.join(directory, 'environment'), environmentFile(service));
             contents.push({ src: path.join(directory, 'environment'), dst: `/etc/${plan.name}/${plan.name}.env`, type: 'config|noreplace', file_info: { mode: 0o640 } });
@@ -331,7 +380,7 @@ export async function buildLinuxPackages(plan, targets, work, outdir) {
         }
         const config = {
             name: plan.name,
-            arch: packageArch(),
+            arch: packageArch(plan),
             platform: 'linux',
             version: plan.version,
             maintainer: plan.maintainer,
@@ -341,7 +390,7 @@ export async function buildLinuxPackages(plan, targets, work, outdir) {
             ...plan.license ? { license: plan.license } : {},
             ...plan.section ? { section: plan.section } : {},
             ...plan.priority ? { priority: plan.priority } : {},
-            depends: [...new Set([...RUNTIME_DEPENDS[target], ...plan.depends])],
+            depends: [...new Set([...RUNTIME_DEPENDS[target], ...plan.desktop ? DESKTOP_DEPENDS[target] : [], ...plan.depends])],
             ...plan.recommends.length ? { recommends: plan.recommends } : {},
             contents: contents,
             scripts: common,

package/dist/esm/lib/mac/Mac.js

@@ -1,17 +1,18 @@
-import { chmod, cp, mkdir, readFile, rm, stat, symlink, writeFile } from 'node:fs/promises';
+import { chmod, mkdir, readFile, rm, stat, symlink, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { archiveDirectory } from '../Archive.js';
+import { copyDirectory } from '../Directories.js';
 import { runCommand } from '../Processes.js';
 import { embeddedShell } from '../Scripts.js';
 /**
  * The installers of macOS: the package of its installer, and the archive of the directory of the executable
  */
-export const MAC_TARGETS = ['pkg', 'tar.gz'];
+export const MAC_TARGETS = ['pkg', 'dmg', 'tar.gz'];
 /**
  * The architecture of the packages
  */
-function packageArch() {
-    return process.arch;
+function packageArch(plan) {
+    return plan.arch;
 }
 /**
  * A text of a property list
@@ -103,7 +104,7 @@ function preInstall(plan) {
     return [
         '#!/bin/sh',
         'set -e',
-        `if [ -e ${doubleQuoted(`${plan.prefix}/${plan.program}`)} ]; then lakutata_action=upgrade; else lakutata_action=install; fi`,
+        `if [ -e ${doubleQuoted(plan.desktop ? plan.prefix : `${plan.prefix}/${plan.program}`)} ]; then lakutata_action=upgrade; else lakutata_action=install; fi`,
         `if [ -n "$INSTALLER_TEMP" ]; then echo "$lakutata_action" > ${ACTION_FILE}; fi`,
         ...hooks.preinstall ? embeddedShell(hooks.preinstall, plan.prefix, '"$lakutata_action"') : [],
         ''
@@ -223,6 +224,26 @@ function uninstall(plan) {
         ''
     ].join('\n');
 }
+/**
+ * The disk image of a desktop application (dmg): its bundle and a link to /Applications, where its user drags it
+ * @param plan
+ * @param work
+ * @param outdir
+ */
+async function diskImage(plan, work, outdir) {
+    if (!plan.desktop)
+        throw new Error('The disk images (dmg) are made for the desktop applications (NW.js): the other applications are installed by pkg');
+    const volume = path.join(work, 'dmg');
+    await rm(volume, { recursive: true, force: true });
+    await copyDirectory(path.join(plan.directory, plan.desktop.executable), path.join(volume, plan.desktop.executable));
+    await symlink('/Applications', path.join(volume, 'Applications'));
+    const file = path.join(outdir, `${plan.name}-${plan.version}-${packageArch(plan)}.dmg`);
+    await rm(file, { force: true });
+    const created = await runCommand('hdiutil', ['create', '-volname', plan.productName, '-srcfolder', volume, '-ov', '-format', 'UDZO', file], work);
+    if (created.code !== 0)
+        throw new Error(`The disk image cannot be made: ${created.output.trim()}`);
+    return { target: 'dmg', file: file, size: (await stat(file)).size };
+}
 /**
  * Make the installers of macOS of an application: the package installed by its installer (pkgbuild, productbuild), the
  * tar.gz archive of the directory of the executable
@@ -236,7 +257,11 @@ export async function buildMacPackages(plan, targets, work, outdir) {
     const files = [];
     for (const target of targets) {
         if (target === 'tar.gz') {
-            files.push(await archiveDirectory(plan, packageArch(), work, outdir));
+            files.push(await archiveDirectory(plan, packageArch(plan), work, outdir));
+            continue;
+        }
+        if (target === 'dmg') {
+            files.push(await diskImage(plan, work, outdir));
             continue;
         }
         //The files installed, from the root of the system
@@ -246,9 +271,11 @@ export async function buildMacPackages(plan, targets, work, outdir) {
         await rm(scripts, { recursive: true, force: true });
         const prefix = path.join(root, ...plan.prefix.split('/'));
         await mkdir(path.dirname(prefix), { recursive: true });
-        await cp(plan.directory, prefix, { recursive: true, verbatimSymlinks: true });
-        await writeFile(path.join(prefix, 'uninstall'), uninstall(plan), { mode: 0o755 });
-        if (plan.addToPath) {
+        //A desktop application: its bundle into /Applications (removed by its user, as the other applications)
+        await copyDirectory(plan.desktop ? path.join(plan.directory, plan.desktop.executable) : plan.directory, prefix);
+        if (!plan.desktop)
+            await writeFile(path.join(prefix, 'uninstall'), uninstall(plan), { mode: 0o755 });
+        if (plan.addToPath && !plan.desktop) {
             await mkdir(path.join(root, 'usr', 'local', 'bin'), { recursive: true });
             await symlink(path.posix.relative('/usr/local/bin', `${plan.prefix}/${plan.program}`), path.join(root, 'usr', 'local', 'bin', plan.program));
         }
@@ -270,14 +297,15 @@ export async function buildMacPackages(plan, targets, work, outdir) {
         const built = await runCommand('pkgbuild', ['--root', root, '--identifier', plan.appId, '--version', plan.version, '--install-location', '/', '--scripts', scripts, '--ownership', 'recommended', component], work);
         if (built.code !== 0)
             throw new Error(`The pkg package cannot be made: ${built.output.trim()}`);
-        const file = path.join(outdir, `${plan.name}-${plan.version}-${packageArch()}.pkg`);
+        const file = path.join(outdir, `${plan.name}-${plan.version}-${packageArch(plan)}.pkg`);
         await rm(file, { force: true });
         //Installed on the Macs of the architecture of the program only (productbuild gives both)
         const distribution = path.join(work, 'distribution.xml');
         const synthesized = await runCommand('productbuild', ['--synthesize', '--package', component, distribution], work);
         if (synthesized.code !== 0)
             throw new Error(`The pkg package cannot be made: ${synthesized.output.trim()}`);
-        const architectures = `hostArchitectures="${packageArch() === 'arm64' ? 'arm64' : 'x86_64'}"`;
+        //A desktop application of Intel runs on the Macs of Apple silicon too (Rosetta)
+        const architectures = `hostArchitectures="${packageArch(plan) === 'arm64' ? 'arm64' : plan.desktop ? 'x86_64,arm64' : 'x86_64'}"`;
         const options = await readFile(distribution, 'utf8');
         await writeFile(distribution, /hostArchitectures="[^"]*"/.test(options) ? options.replace(/hostArchitectures="[^"]*"/, architectures) : options.replace('<options ', `<options ${architectures} `));
         const product = await runCommand('productbuild', ['--distribution', distribution, '--package-path', work, '--identifier', plan.appId, '--version', plan.version, file], work);