@lakutata/builder 3.1.3 → 3.1.6

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');
@@ -290,14 +328,15 @@ function packageScripts(plan, target) {
  * @param targets
  * @param work
  * @param outdir
+ * @param progress Called with what is being downloaded (nFPM)
  */
-export async function buildLinuxPackages(plan, targets, work, outdir) {
+export async function buildLinuxPackages(plan, targets, work, outdir, progress) {
     await mkdir(work, { recursive: true });
     const files = [];
     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 +344,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 +381,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 +391,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,
@@ -349,7 +399,7 @@ export async function buildLinuxPackages(plan, targets, work, outdir) {
         };
         //JSON is YAML
         await writeFile(path.join(directory, 'nfpm.yaml'), JSON.stringify(config, null, 2));
-        const nfpm = await ensureTool('nfpm');
+        const nfpm = await ensureTool('nfpm', progress);
         const file = path.join(outdir, packageFile(plan, target));
         await rm(file, { force: true });
         const packaged = await runCommand(nfpm, ['package', '--config', path.join(directory, 'nfpm.yaml'), '--packager', target, '--target', file], directory);

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