deboa 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Erik Moura
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,178 @@
+deboa
+===========
+
+deboa is a Node.js tool for creating .deb files (and .ar files, if you ever need one for some reason).
+
+It doesn't depend on any Unix-specific external binaries (I'm looking at you, dpkg and fakeroot), so you can create a
+.deb file in pretty much any platform you can run Node.js on: Windows (🔥), OS X, Linux (because why not), you name it.
+
+
+# Features
+
+deboa provides all the tools you need to create a .deb from scratch or from your own `control` and `data` files:
+- Create your .deb in any OS, no superuser privileges or external binaries required
+- Supports compression in .tar, .tar.gz or .tar.xz out of the box. If you need another format, you can easily provide your own compressed files and let deboa do the rest
+- Support for icon and desktop specification file
+- Ability to set chmod permissions for every packaged file and to create symlinks, even on Windows
+
+
+# About .deb files
+
+A .deb file is just an .ar file, which is made up by a file signature / magic number (the string `!<arch>`) followed by
+any number of metadata/file contents pairs.
+
+.debs have three files, the last two are usually compressed in .tar, .tar.gz or .tar.xz format:
+
+- the `debian-binary` file, containing just the string `2.0\n`
+- the `control` file, containing metadata about the software it contains and possibly some scripts to be executed
+  before/after the software is installed/uninstalled
+- the `data` file, which contains the actual software
+
+
+# API
+
+## Creating a .deb from scratch
+
+So you have a folder with the Linux version of your app ready to package. You can use the `Deboa` class to create
+the `control` file
+and compress the specified directory into the `data` file for you. The following code creates a .deb file with the bare
+minimum options:
+
+```ts
+import { Deboa } from 'deboa'
+
+const deboa = new Deboa({
+  controlFileOptions: {
+    maintainer: 'John Doe <john@example.com>',
+    packageName: 'my-awesome-app',
+    shortDescription: 'users will see this when installing your app',
+    version: '1.0.0',
+  },
+  sourceDir: './my-awesome-app-linux-x64',
+  targetDir: './out',
+})
+
+deboa.package().then(() => {
+  console.log('done')
+})
+```
+
+
+### Additional options
+
+For more details, please see the [IDeboa interface](https://github.com/erikian/deboa/blob/main/src/types/IDeboa.ts).
+
+- `additionalTarEntries`: runs after all source files are added to the .tar archive. You can use it to create any symbolic links you might need:
+
+  ```ts
+  const deboa = new Deboa({
+    additionalTarEntries: [
+      // creates a relative symlink from /usr/lib/my-awesome-app/some-executable-file
+      // to /usr/bin/my-awesome-app, equivalent to:
+      // cd /usr/bin && ln -s ../lib/my-awesome-app/some-executable-file some-executable-file
+      {
+        gname: 'root',
+        linkname: '../lib/my-awesome-app/some-executable-file', // link source
+        mode: parseInt('777', 8),
+        name: 'usr/bin/my-awesome-app', // link target
+        type: 'symlink',
+        uname: 'root',
+      }
+    ],
+    // other options
+  })
+  ```
+- `beforeCreateDesktopEntry`: runs before the desktop entry file is created. Allows you to modify the default entries and to add your own.
+- `beforePackage`: runs after the files are copied to the temporary directory and before they're packaged. You can use this to add/delete/rename any files before they're packaged.
+- `controlFileOptions`: additional control file fields. See the [IControlFileOptions interface](https://github.com/erikian/deboa/blob/main/src/types/IControlFileOptions.ts) for details.
+- `icon`: path to the image you want to use as your app icon.
+- `modifyTarHeader`: allows you to modify the header of a file before it's added to the `data` tar archive. The main use case
+  for this option is setting permissions in order to make files executable when creating a .deb on Windows:
+
+  ```ts
+  const deboa = new Deboa({
+    modifyTarHeader: header => {
+      if (header.name === 'usr/lib/my-awesome-app/some-executable-file') {
+        header.mode = parseInt('0755', 8)
+      }
+
+      return header
+    },
+    // other options
+  })
+  ```
+- `tarballFormat`: can be `tar`, `tar.gz` (default) or `tar.xz`.
+
+## Creating a .deb from existing `control` and `data` files
+
+If you have your `control` file handy and your `data` file already compressed and ready to go, you can use
+the `writeFromFile` method from the `DeboaFromFile` class to create the metadata and write them directly to the .deb
+file. This allows you to have your files compressed by your favorite tool in the format that is best for your case.
+
+```ts
+import { DeboaFromFile } from 'deboa'
+
+;(async () => {
+  const deboa = new DeboaFromFile({
+    outputFile: '/path/to/my-awesome-app_1.0.0_amd64.deb',
+  })
+
+  await deboa.writeFromFile('/path/to/control.tar.gz')
+  await deboa.writeFromFile('/path/to/data.tar.gz')
+
+  deboa.writeStream.close()
+
+  console.log('done')
+})()
+```
+
+If you need access to the underlying read streams, you can use the `createReadStream` method, which takes
+care of the metadata, then pass the returned stream to the `writeFromStream` method:
+
+```ts
+import { DeboaFromFile } from 'deboa'
+
+;(async () => {
+  const deboa = new DeboaFromFile({
+    outputFile: '/path/to/my-awesome-app_1.0.0_amd64.deb',
+  })
+
+  const controlStream = await deboa.createReadStream('/path/to/control.tar.gz')
+  await deboa.writeFromStream(controlStream)
+
+  const dataStream = await deboa.createReadStream('/path/to/data.tar.gz')
+  await deboa.writeFromStream(dataStream)
+
+  deboa.writeStream.close()
+
+  console.log('done')
+})()
+```
+
+Note that you need to write the `control` and `data` files **in that order**, otherwise the generated .deb will be
+invalid.
+
+### Creating an .ar file
+
+Same as above, just add the `isARFile: true` option to the constructor so the `debian-binary` file doesn't get
+created:
+
+```ts
+import { DeboaFromFile } from 'deboa'
+
+;(async() => {
+  const ar = new DeboaFromFile({
+    outputFile: '/path/to/output.ar',
+    isARFile: true,
+  })
+
+  await ar.writeFromFile('/path/to/some/file')
+
+  deboa.writeStream.close()
+
+  console.log('done')
+})()
+```
+
+I've added this option just because it was trivial. If you're here because of it, please leave a comment, I'm very
+interested in knowing what you've been working with.

package/dist/cjs/classes/Deboa.js

@@ -0,0 +1,490 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Deboa", {
+    enumerable: true,
+    get: ()=>Deboa
+});
+const _events = require("events");
+const _os = /*#__PURE__*/ _interopRequireDefault(require("os"));
+const _path = /*#__PURE__*/ _interopRequireDefault(require("path"));
+const _fs = /*#__PURE__*/ _interopRequireDefault(require("fs"));
+const _fsExtra = /*#__PURE__*/ _interopRequireDefault(require("fs-extra"));
+const _util = require("util");
+const _fastFolderSize = /*#__PURE__*/ _interopRequireDefault(require("fast-folder-size"));
+const _tarFs = /*#__PURE__*/ _interopRequireDefault(require("tar-fs"));
+const _writeFileFromLines = require("../utils/writeFileFromLines");
+const _deboaFromFile = require("./DeboaFromFile");
+const _stream = require("stream");
+const _addTarEntries = require("../utils/addTarEntries");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+/**
+ * @return IDeboa
+ */ class Deboa {
+    /** See {@link IDeboa.additionalTarEntries} */ additionalTarEntries = [];
+    /** See {@link IDeboa.beforeCreateDesktopEntry} */ beforeCreateDesktopEntry = null;
+    /** See {@link IDeboa.beforePackage} */ beforePackage = null;
+    /** See {@link IDeboa.controlFileOptions} */ controlFileOptions = {
+        /** See {@link IDeboa.architecture} */ architecture: null,
+        /** See {@link IDeboa.builtUsing} */ builtUsing: null,
+        /** See {@link IDeboa.conflicts} */ conflicts: null,
+        /** See {@link IDeboa.depends} */ depends: null,
+        /** See {@link IDeboa.essential} */ essential: null,
+        /** See {@link IDeboa.extendedDescription} */ extendedDescription: null,
+        /** See {@link IDeboa.homepage} */ homepage: null,
+        /** See {@link IDeboa.maintainer} */ maintainer: null,
+        /** See {@link IDeboa.maintainerScripts} */ maintainerScripts: {
+            preinst: null,
+            postinst: null,
+            prerm: null,
+            postrm: null
+        },
+        /** See {@link IDeboa.packageName} */ packageName: null,
+        /** See {@link IDeboa.preDepends} */ preDepends: null,
+        /** See {@link IDeboa.priority} */ priority: null,
+        /** See {@link IDeboa.recommends} */ recommends: null,
+        /** See {@link IDeboa.section} */ section: null,
+        /** See {@link IDeboa.shortDescription} */ shortDescription: null,
+        /** See {@link IDeboa.source} */ source: null,
+        /** See {@link IDeboa.suggests} */ suggests: null,
+        /** See {@link IDeboa.version} */ version: null
+    };
+    /** See {@link IDeboa.icon} */ icon = null;
+    /** See {@link IDeboa.modifyTarHeader} */ modifyTarHeader = null;
+    /** See {@link IDeboa.sourceDir} */ sourceDir = null;
+    /** See {@link IDeboa.tarballFormat} */ tarballFormat = null;
+    /** See {@link IDeboa.targetDir} */ targetDir = null;
+    #appFolderDestination = null;
+    #controlFolderDestination = null;
+    #dataFolderDestination = null;
+    #hooksLoaded = false;
+    #outputFile = null;
+    #tempDir = null;
+    constructor(options){
+        if (!Object.keys(options || {}).length) {
+            throw new Error('No configuration options provided');
+        }
+        const { sourceDir , targetDir  } = options;
+        if (!sourceDir) {
+            throw new Error('The `sourceDir` field is mandatory');
+        }
+        if (!targetDir) {
+            throw new Error('The `targetDir` field is mandatory');
+        }
+        Deboa.#validateOptions(options);
+        const { controlFileOptions  } = options;
+        const osArch = _os.default.arch();
+        // default values
+        options = {
+            ...options,
+            controlFileOptions: {
+                ...controlFileOptions,
+                ...!controlFileOptions.architecture && {
+                    architecture: osArch === 'x64' ? 'amd64' : osArch
+                },
+                ...!controlFileOptions.maintainerScripts && {
+                    maintainerScripts: {}
+                },
+                ...!controlFileOptions.priority && {
+                    priority: 'optional'
+                },
+                ...!controlFileOptions.extendedDescription && {
+                    extendedDescription: controlFileOptions.shortDescription
+                }
+            },
+            tarballFormat: [
+                'tar',
+                'tar.gz',
+                'tar.xz'
+            ].includes(options.tarballFormat) ? options.tarballFormat : 'tar.gz'
+        };
+        for (const [property, value] of Object.entries(options)){
+            this[property] = value;
+        }
+        this.#tempDir = _path.default.join(_os.default.tmpdir(), 'deboa_temp');
+        const { architecture , packageName , version  } = this.controlFileOptions;
+        this.#outputFile = _path.default.join(this.targetDir, `${packageName}_${version}_${architecture}.deb`);
+        this.#controlFolderDestination = _path.default.join(this.#tempDir, 'control');
+        this.#dataFolderDestination = _path.default.join(this.#tempDir, 'data');
+        this.#appFolderDestination = _path.default.join(this.#dataFolderDestination, 'usr', 'lib', packageName);
+    }
+    /**
+   * Ensures that all required options are present and that the `packageName`
+   * and `maintainer` fields are provided in the right format.
+   */ static  #validateOptions(options) {
+        console.log('Validating options...\n');
+        const { controlFileOptions: { shortDescription , maintainer , packageName , version ,  } ,  } = options;
+        if (!packageName) {
+            throw new Error('The controlFileOptions.`packageName` field is mandatory');
+        }
+        if (!version) {
+            throw new Error('The `controlFileOptions.version` field is mandatory');
+        }
+        if (!maintainer) {
+            throw new Error('The `controlFileOptions.maintainer` field is mandatory');
+        }
+        if (!shortDescription) {
+            throw new Error('The `controlFileOptions.description` field is mandatory');
+        }
+        if (packageName.length < 2) {
+            throw new Error('The `controlFileOptions.packageName` field must be at least two characters long');
+        }
+        if (packageName.replace(/[^a-z\d\-+.]/g, '').replace(/^[-+.]/g, '').toLowerCase() !== packageName) {
+            throw new Error('The `controlFileOptions.packageName` field contains illegal characters');
+        }
+        /*
+     if (!maintainer.match(/^(\p{L}+ ?)+ ?<(.*?)@(.*?)>$/u)) {
+     throw new Error(
+     'The `controlFileOptions.maintainer` field does not match the expected format `John Doe <johndoe@example.com>`',
+     )
+     }
+     */ const { postinst , prerm , postrm , preinst  } = options.controlFileOptions.maintainerScripts || {};
+        for (const [scriptName, scriptPath] of Object.entries({
+            postinst,
+            postrm,
+            preinst,
+            prerm
+        })){
+            if (scriptPath) {
+                try {
+                    _fs.default.accessSync(_path.default.resolve(scriptPath));
+                } catch (e) {
+                    throw new Error(`Error accessing \`${scriptPath}\` (provided in \`controlFileOptions.maintainerScripts.${scriptName}\`). Make sure that this file exists and is accessible by the current user.`);
+                }
+            }
+        }
+    }
+    /**
+   * Creates the .deb file.
+   * @return {Promise<string>} outputFile - Absolute path to the generated .deb
+   */ async package() {
+        const startTime = process.hrtime.bigint();
+        const tempDir = this.#tempDir;
+        await _fsExtra.default.ensureDir(tempDir);
+        if (!this.#hooksLoaded) {
+            await this.loadHooks();
+        }
+        await this.#copyFolderTree();
+        await this.#copyMaintainerScripts();
+        await this.#copyPackageFiles();
+        await this.#createControlFile();
+        await this.#copyIconAndDesktopEntryFile();
+        if (typeof this.beforePackage === 'function') {
+            await this.beforePackage(this.#dataFolderDestination);
+        }
+        await this.#createTarballs();
+        await this.#createDeb();
+        console.log('Removing temporary files...\n');
+        await _fs.default.promises.rm(this.#tempDir, {
+            recursive: true
+        });
+        const endTime = process.hrtime.bigint();
+        const duration = parseInt(String(endTime - startTime));
+        console.log(`.deb created in ${(duration / 1e9).toFixed(2)}s`);
+        return this.#outputFile;
+    }
+    /**
+   * Creates the tarballs for the control and data files.
+   */ async #createTarballs() {
+        console.log('Packaging files....\n');
+        const { tarballFormat  } = this;
+        const dataFileLocation = this.#dataFolderDestination + `.${tarballFormat}`;
+        const controlFileLocation = this.#controlFolderDestination + `.${tarballFormat}`;
+        let dataFileCompressor;
+        let controlFileCompressor;
+        switch(tarballFormat){
+            case 'tar':
+                {
+                    dataFileCompressor = new _stream.PassThrough();
+                    controlFileCompressor = new _stream.PassThrough();
+                    break;
+                }
+            case 'tar.gz':
+                {
+                    const zlib = (await Promise.resolve().then(()=>/*#__PURE__*/ _interopRequireWildcard(require("zlib")))).default;
+                    dataFileCompressor = zlib.createGzip();
+                    controlFileCompressor = zlib.createGzip();
+                    break;
+                }
+            case 'tar.xz':
+                {
+                    const lzma = (await Promise.resolve().then(()=>/*#__PURE__*/ _interopRequireWildcard(require("lzma-native")))).default;
+                    dataFileCompressor = lzma.createCompressor({
+                        threads: 0
+                    });
+                    controlFileCompressor = lzma.createCompressor({
+                        threads: 0
+                    });
+                    break;
+                }
+        }
+        const dataFileWriteStream = _fs.default.createWriteStream(dataFileLocation);
+        const controlFileWriteStream = _fs.default.createWriteStream(controlFileLocation);
+        _tarFs.default.pack(this.#dataFolderDestination, {
+            map: (header)=>{
+                // sensible defaults for Windows users
+                if (process.platform === 'win32') {
+                    const defaultFilePermission = parseInt('0644', 8);
+                    const defaultFolderPermission = parseInt('0755', 8);
+                    switch(header.type){
+                        case 'file':
+                            {
+                                header.mode = defaultFilePermission;
+                                break;
+                            }
+                        case 'directory':
+                            {
+                                header.mode = defaultFolderPermission;
+                                break;
+                            }
+                    }
+                }
+                if (typeof this.modifyTarHeader === 'function') {
+                    header = this.modifyTarHeader(header);
+                }
+                return header;
+            },
+            ...this.additionalTarEntries.length && {
+                finalize: false,
+                finish: async (pack)=>{
+                    await (0, _addTarEntries.addTarEntries)({
+                        entries: this.additionalTarEntries,
+                        pack
+                    });
+                    pack.finalize();
+                }
+            }
+        }).pipe(dataFileCompressor).pipe(dataFileWriteStream);
+        _tarFs.default.pack(this.#controlFolderDestination, {
+            map: (header)=>{
+                const maintainerScripts = [
+                    'postinst',
+                    'postrm',
+                    'preinst',
+                    'prerm', 
+                ];
+                // maintainer scripts must be executable
+                if (maintainerScripts.includes(header.name)) {
+                    header.mode = parseInt('0755', 8);
+                }
+                return header;
+            }
+        }).pipe(controlFileCompressor).pipe(controlFileWriteStream);
+        await Promise.all([
+            (0, _events.once)(dataFileWriteStream, 'finish'),
+            (0, _events.once)(controlFileWriteStream, 'finish'), 
+        ]);
+    }
+    /**
+   * Copies the empty folders to the temporary location.
+   */ async #copyFolderTree() {
+        console.log('Creating directory structure in the temporary folder...\n');
+        await _fsExtra.default.ensureDir(this.#appFolderDestination);
+        await _fsExtra.default.ensureDir(this.#controlFolderDestination);
+    }
+    /**
+   * Copies the source files to the temporary folder.
+   */ async #copyPackageFiles() {
+        console.log('Copying source directory...\n');
+        await _fsExtra.default.copy(this.sourceDir, this.#appFolderDestination);
+    }
+    /**
+   * Copies the maintainer scripts to the temporary folder.
+   */ async #copyMaintainerScripts() {
+        console.log('Copying maintainer scripts...\n');
+        const { controlFileOptions: { maintainerScripts: { postinst: postinst1 , postrm: postrm1 , preinst: preinst1 , prerm: prerm1  } = {} ,  } ,  } = this;
+        const scripts = Object.entries({
+            postinst: postinst1,
+            postrm: postrm1,
+            preinst: preinst1,
+            prerm: prerm1
+        }).filter(([, scriptPath])=>scriptPath);
+        for (const [scriptName1, scriptPath1] of scripts){
+            await _fs.default.promises.copyFile(_path.default.resolve(scriptPath1), _path.default.join(this.#controlFolderDestination, scriptName1));
+        }
+    }
+    /**
+   * Creates the control file and writes it to the temporary folder.
+   */ async #createControlFile() {
+        console.log('Creating control file...\n');
+        const { controlFileOptions: { packageName: packageName1 , version: version1 , section , priority , architecture , maintainer: maintainer1 , homepage , suggests =[] , depends =[] , recommends =[] , shortDescription: shortDescription1 , extendedDescription , builtUsing , conflicts =[] , essential , preDepends =[] ,  } ,  } = this;
+        const fastFolderSizeAsync = (0, _util.promisify)(_fastFolderSize.default);
+        const installedSize = await fastFolderSizeAsync(this.sourceDir);
+        const lines = [
+            `Package: ${packageName1}`,
+            `Version: ${version1}`,
+            section && `Section: ${section}`,
+            `Priority: ${priority}`,
+            `Architecture: ${architecture}`,
+            `Maintainer: ${maintainer1}`,
+            Array.isArray(depends) && depends.length && `Depends: ${depends.join(', ')}`,
+            preDepends.length && `Pre-Depends: ${preDepends.join(', ')}`,
+            recommends.length && `Recommends: ${recommends.join(', ')}`,
+            suggests.length && `Suggests: ${suggests.join(', ')}`,
+            conflicts.length && `Conflicts: ${conflicts.join(', ')}`,
+            `Installed-Size: ${Math.ceil(installedSize / 1024)}`,
+            homepage && `Homepage: ${homepage}`,
+            builtUsing && `Built-Using: ${builtUsing}`,
+            essential && `Essential: ${essential}`,
+            `Description: ${shortDescription1}`,
+            ` ${extendedDescription}`, 
+        ].filter(Boolean);
+        await (0, _writeFileFromLines.writeFileFromLines)({
+            filePath: _path.default.join(this.#controlFolderDestination, 'control'),
+            lines
+        });
+    }
+    /**
+   * Copies the provided icon to the temporary folder
+   * and writes the desktop entry file.
+   */ async #copyIconAndDesktopEntryFile() {
+        let iconFileExists = false;
+        let iconDestination = null;
+        const { packageName: packageName2 , shortDescription: shortDescription2  } = this.controlFileOptions;
+        if (this.icon) {
+            const iconPath = _path.default.resolve(this.icon);
+            iconFileExists = await _fsExtra.default.pathExists(iconPath);
+            const { ext: extension  } = _path.default.parse(iconPath);
+            if (iconFileExists) {
+                iconDestination = _path.default.join(this.#dataFolderDestination, 'usr/share/pixmaps', packageName2 + extension);
+                await _fsExtra.default.ensureDir(_path.default.resolve(iconDestination, '../'));
+                await _fsExtra.default.copy(iconPath, iconDestination);
+                console.log(`App icon saved to ${iconDestination}`);
+            } else {
+                console.warn(`\nWARNING: file \`${iconPath}\` not found, skipping app icon...\n`);
+            }
+        }
+        let desktopEntries = {
+            Comment: shortDescription2,
+            GenericName: packageName2,
+            Name: packageName2,
+            Type: 'Application',
+            ...iconFileExists && {
+                Icon: packageName2
+            }
+        };
+        if (typeof this.beforeCreateDesktopEntry === 'function') {
+            desktopEntries = await this.beforeCreateDesktopEntry(desktopEntries);
+        }
+        if (!Object.keys(desktopEntries).length) {
+            return;
+        }
+        const lines1 = Object.entries(desktopEntries).reduce((acc, entry)=>[
+                ...acc,
+                entry.join('=')
+            ], []);
+        const desktopFileDestination = _path.default.join(this.#dataFolderDestination, 'usr/share/applications', `${packageName2}.desktop`);
+        await _fsExtra.default.ensureDir(_path.default.resolve(desktopFileDestination, '../'));
+        await (0, _writeFileFromLines.writeFileFromLines)({
+            filePath: desktopFileDestination,
+            lines: [
+                '[Desktop Entry]',
+                ...lines1
+            ]
+        });
+        console.log(`Desktop entries file saved to ${desktopFileDestination}`);
+    }
+    /**
+   * Checks if the values provided to the hook options are file paths
+   * and imports the actual functions from them if necessary.
+   */ async loadHooks() {
+        const { beforePackage , modifyTarHeader , beforeCreateDesktopEntry  } = this;
+        const hooks = {
+            beforeCreateDesktopEntry,
+            beforePackage,
+            modifyTarHeader
+        };
+        for (const [hookName, hookValue] of Object.entries(hooks)){
+            if (hookValue) {
+                switch(typeof hookValue){
+                    case 'function':
+                        {
+                            this[hookName] = hookValue;
+                            break;
+                        }
+                    case 'string':
+                        {
+                            const filePath = _path.default.resolve(hookValue);
+                            const fileExists = await _fsExtra.default.pathExists(filePath);
+                            if (!fileExists) {
+                                throw new Error(`The file \`${hookValue}\` doesn't exist or cannot be accessed by the current user.`);
+                            }
+                            const importedFn = (await Promise.resolve(filePath).then((p)=>/*#__PURE__*/ _interopRequireWildcard(require(p)))).default;
+                            if (typeof importedFn === 'function') {
+                                this[hookName] = importedFn;
+                            } else {
+                                throw new Error(`The file \`${filePath}\` must have a function as its default export.`);
+                            }
+                            break;
+                        }
+                    default:
+                        {
+                            throw new Error(`Invalid type provided for the \`${hookName}\` option, expected a function or a path to a file that has a function as its default export.`);
+                        }
+                }
+            }
+        }
+        this.#hooksLoaded = true;
+    }
+    /**
+   * Writes the .deb to the output folder.
+   */ async #createDeb() {
+        console.log('Writing .deb file...\n');
+        await _fsExtra.default.ensureDir(this.targetDir);
+        const deBoaFromFile = new _deboaFromFile.DeboaFromFile({
+            outputFile: this.#outputFile
+        });
+        try {
+            await deBoaFromFile.writeFromFile(this.#controlFolderDestination + `.${this.tarballFormat}`);
+            await deBoaFromFile.writeFromFile(this.#dataFolderDestination + `.${this.tarballFormat}`);
+            deBoaFromFile.writeStream.close();
+        } catch (e1) {
+            console.log('ERROR: ', e1);
+            throw e1;
+        }
+    }
+}