@lakutata/builder 3.0.0-beta.0

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

@@ -0,0 +1,77 @@
+/**
+ * The moments of the installers the scripts of the applications are run at, the same on every system: before and after
+ * the installation (and the upgrades), before and after the removal (not the one of an upgrade)
+ */
+export declare const INSTALLER_HOOKS: readonly ["preinstall", "postinstall", "preremove", "postremove"];
+export type InstallerHook = typeof INSTALLER_HOOKS[number];
+/**
+ * The scripts of an application run by its installers (files of its project): the ones of Linux and macOS are run by
+ * the interpreter of their first line (#!/bin/sh by default), the ones of Windows are scripts of PowerShell (.ps1). They
+ * are given what the installer does: install, upgrade (preinstall and postinstall) or remove (preremove and
+ * postremove), and the directory of the application (LAKUTATA_INSTALL_DIR)
+ */
+export type InstallerScripts = Partial<Record<InstallerHook, string>>;
+/**
+ * The scripts of the packages of Linux, as nFPM runs them: the ones of each package, given its own arguments (the ones
+ * of dpkg, of rpm, of apk, of pacman); the upgrades of apk and pacman have their own ones
+ */
+export declare const NATIVE_HOOKS: readonly ["preinstall", "postinstall", "preremove", "postremove", "preupgrade", "postupgrade"];
+export type NativeHook = typeof NATIVE_HOOKS[number];
+export type NativeScripts = Partial<Record<NativeHook, string>>;
+/**
+ * A script of the application, read from its project
+ */
+export type ScriptFile = {
+    /**
+     * Its path, from the project
+     */
+    file: string;
+    content: string;
+};
+/**
+ * The scripts of an installer: the ones of the moments (the ones of its platform, the ones of the installer replacing
+ * them), the native ones of the packages of Linux, the file of NSIS it includes
+ */
+export type TargetScripts = {
+    hooks: Partial<Record<InstallerHook, ScriptFile>>;
+    native: Partial<Record<NativeHook, ScriptFile>>;
+    include?: ScriptFile;
+};
+/**
+ * The scripts of the platform and of its installers, as configured (lakutata.installer.<platform>)
+ */
+export type PlatformScripts = {
+    scripts?: InstallerScripts;
+    [target: string]: unknown;
+};
+/**
+ * The scripts of the installers made on a platform: the ones of the platform (lakutata.installer.<platform>.scripts),
+ * replaced by the ones of each installer (lakutata.installer.<platform>.<installer>.scripts), the native ones of the
+ * packages of Linux (nativeScripts), the file of NSIS included by its installer (win.nsis.include). The ones an
+ * installer does not run are told (warnings)
+ * @param project
+ * @param platform its name in the configuration: linux, mac or win
+ * @param config its configuration
+ * @param targets the installers made
+ * @param warnings
+ * @param hooks the moments each installer runs the scripts at (the installers of lakutata by default)
+ * @param native whether the packages of Linux run native scripts (the ones of lakutata)
+ */
+export declare function resolveScripts(project: string, platform: 'linux' | 'mac' | 'win', config: PlatformScripts | undefined, targets: string[], warnings: string[], hooks?: (target: string) => readonly InstallerHook[], native?: boolean): Record<string, TargetScripts>;
+/**
+ * The lines of sh running a script embedded in them (the scripts run before the files of the application are installed,
+ * or after they are removed): written to a temporary file, run by the interpreter of its first line (a temporary file
+ * system may not run its files), its failure the one of the script running it
+ * @param script
+ * @param prefix the directory of the application (LAKUTATA_INSTALL_DIR)
+ * @param args the arguments given to it (sh)
+ */
+export declare function embeddedShell(script: ScriptFile, prefix: string, args: string): string[];
+/**
+ * The lines of sh running a script encoded in them (base64): the scripts of the packages of electron-builder are
+ * templates, which replace their ${...}
+ * @param script
+ * @param prefix the directory of the application (LAKUTATA_INSTALL_DIR)
+ * @param args the arguments given to it (sh)
+ */
+export declare function encodedShell(script: ScriptFile, prefix: string, args: string): string[];

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

@@ -0,0 +1,32 @@
+/**
+ * A tool the builder downloads (as electron-builder downloads its tools): its version, and the archives of its releases
+ * by platform with their sha256, written here (the checksums are not downloaded with the archives)
+ */
+type Tool = {
+    version: string;
+    /**
+     * The executable, in the archive (its path, "/" separated), or the file downloaded
+     */
+    executable: string;
+    url: (archive: string) => string;
+    archives: Record<string, {
+        archive: string;
+        sha256: string;
+    }>;
+};
+/**
+ * The tools of the builder
+ */
+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;
+/**
+ * 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
+ */
+export declare function ensureTool(name: keyof typeof TOOLS): Promise<string>;
+export {};

package/dist/types/lib/electron/Electron.d.ts

@@ -0,0 +1,13 @@
+import type { InstallerConfig, InstallerOptions, InstallerResult } from '../Installer.js';
+/**
+ * Make the installers of an Electron application (lakutata.installer.runtime: electron) for the platform it is made on,
+ * by electron-builder: its main process bundled with its dependencies (lakutata package bundle), Electron left out; its native
+ * addons and its resources (lakutata.resources: its renderer, its preload script) next to its archive (app.asar), in the
+ * resources of Electron. The configuration of electron-builder is made from lakutata.installer, lakutata.installer.electron
+ * merged over it; the scripts of the application are run by its installers
+ * @param project
+ * @param manifest
+ * @param config
+ * @param options
+ */
+export declare function buildElectronInstaller(project: string, manifest: Record<string, any>, config: InstallerConfig, options: InstallerOptions): Promise<InstallerResult>;

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

@@ -0,0 +1,29 @@
+import type { InstallerPlan } from '../Installer.js';
+import { type NativeHook } from '../Scripts.js';
+/**
+ * The packages of Linux: the ones of nFPM, and the archive of the directory of the executable
+ */
+export declare const LINUX_TARGETS: readonly ["deb", "rpm", "apk", "archlinux", "tar.gz"];
+export type LinuxTarget = typeof LINUX_TARGETS[number];
+/**
+ * What a script of a package does, as the scripts of the application are given it (lakutata_action: install, upgrade,
+ * remove, or none), from the arguments of its package manager: the upgrades of deb and rpm run their scripts of the
+ * installation (deb: preinst upgrade, postinst configure <version replaced>; rpm: $1 > 1) and their scripts of the
+ * removal of the version replaced (which run none); the ones of apk and pacman run their own scripts
+ * @param target
+ * @param hook
+ */
+export declare function scriptAction(target: Exclude<LinuxTarget, 'tar.gz'>, hook: NativeHook): string;
+/**
+ * Make the packages of Linux of an application: nFPM makes the deb, rpm, apk and archlinux packages, the tar.gz archive
+ * is the directory of the executable
+ * @param plan
+ * @param targets
+ * @param work
+ * @param outdir
+ */
+export declare function buildLinuxPackages(plan: InstallerPlan, targets: LinuxTarget[], work: string, outdir: string): Promise<{
+    target: string;
+    file: string;
+    size: number;
+}[]>;

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

@@ -0,0 +1,19 @@
+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 type MacTarget = typeof MAC_TARGETS[number];
+/**
+ * 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
+ * @param plan
+ * @param targets
+ * @param work
+ * @param outdir
+ */
+export declare function buildMacPackages(plan: InstallerPlan, targets: MacTarget[], work: string, outdir: string): Promise<{
+    target: string;
+    file: string;
+    size: number;
+}[]>;

package/dist/types/lib/win/Windows.d.ts

@@ -0,0 +1,20 @@
+import type { InstallerPlan } from '../Installer.js';
+/**
+ * The installers of Windows: the installer of NSIS (.exe), the package of Windows Installer (.msi), the zip archive of
+ * the directory of the executable
+ */
+export declare const WINDOWS_TARGETS: readonly ["nsis", "msi", "zip"];
+export type WindowsTarget = typeof WINDOWS_TARGETS[number];
+/**
+ * Make the installers of Windows of an application: the installer of NSIS, the package of Windows Installer (WiX), the
+ * zip archive of the directory of the executable; its service run by WinSW
+ * @param plan
+ * @param targets
+ * @param work
+ * @param outdir
+ */
+export declare function buildWindowsPackages(plan: InstallerPlan, targets: WindowsTarget[], work: string, outdir: string): Promise<{
+    target: string;
+    file: string;
+    size: number;
+}[]>;

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@lakutata/builder",
+  "version": "3.0.0-beta.0",
+  "description": "The builder of the applications of the lakutata framework: their bundles, their executables (Node.js, Bun) with their native addons and their resources.",
+  "type": "module",
+  "main": "./dist/esm/index.js",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "default": "./dist/esm/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "clean": "node -e \"require('node:fs').rmSync('dist', {recursive: true, force: true})\"",
+    "build:js": "tsc -p tsconfig.esm.json",
+    "rebuild": "npm run clean && npm run build:js",
+    "compile": "npm run rebuild",
+    "test:unit": "npm run compile && node --test \"dist/esm/tests/*.spec.js\"",
+    "test:installer": "npm run compile && LAKUTATA_DOCKER=1 node --test dist/esm/tests/Installer.spec.js",
+    "test:installer:mac": "npm run compile && LAKUTATA_TART=1 node --test dist/esm/tests/InstallerMac.spec.js",
+    "test:installer:windows": "npm run compile && node --test dist/esm/tests/InstallerWindows.spec.js"
+  },
+  "dependencies": {
+    "esbuild": "^0.28.2",
+    "postject": "^1.0.0-alpha.6",
+    "resedit": "^1.7.2"
+  },
+  "peerDependencies": {
+    "electron-builder": ">=26.0.0"
+  },
+  "peerDependenciesMeta": {
+    "electron-builder": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=22.12"
+  },
+  "license": "MIT",
+  "files": [
+    "dist/esm",
+    "!dist/esm/tests",
+    "dist/types",
+    "!dist/types/tests",
+    "*.md",
+    "LICENSE",
+    "package.json"
+  ]
+}