electron-info 1.22.5 → 1.23.1

package/README.md

@@ -11,7 +11,7 @@ Get useful data about Electron releases. Uses [electron-releases](https://github
 
 ## Installation
 
-ℹ️ This is a hybrid [CommonJS](https://nodejs.org/docs/latest/api/modules.html#modules-commonjs-modules) / [ESM](https://nodejs.org/api/esm.html#introduction) module.
+ℹ️ This is a pure [ESM](https://nodejs.org/api/esm.html#introduction) module.
 
 Just run `npx electron-info`.
 

package/dist/{esm/ElectronInfo.test.js → ElectronInfo.test.js}

@@ -1,10 +1,10 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { randomUUID } from 'node:crypto';
 import { expect, describe, test, beforeEach, beforeAll, afterAll, afterEach } from 'vitest';
 import { StatusCodes as HTTP_STATUS } from 'http-status-codes';
 import nock from 'nock';
 import * as fs from 'fs-extra';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { randomUUID } from 'crypto';
 import { ElectronInfo } from './ElectronInfo.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);

package/dist/{esm/FileService.js → FileService.js}

@@ -1,9 +1,9 @@
+import { constants as fsConstants, promises as fs } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import URL from 'node:url';
 import { isAfter as isAfterDate, sub as subtractDate } from 'date-fns';
-import { constants as fsConstants, promises as fs } from 'fs';
-import parseUrl from 'parse-url';
 import logdown from 'logdown';
-import os from 'os';
-import path from 'path';
 import { HTTPService } from './HTTPService.js';
 export class FileService {
     constructor(options) {
@@ -23,7 +23,7 @@ export class FileService {
     }
     async getReleases() {
         this.logger.log('Parsing releases URL', { releasesUrl: this.options.releasesUrl });
-        const parsedUrl = parseUrl(this.options.releasesUrl);
+        const parsedUrl = URL.parse(this.options.releasesUrl);
         if (!parsedUrl.href) {
             throw new Error('Invalid releases URL provided');
         }

package/dist/{esm/HTTPService.js → HTTPService.js}

@@ -1,5 +1,5 @@
-import { promises as fs } from 'fs';
-import { inspect } from 'util';
+import { promises as fs } from 'node:fs';
+import { inspect } from 'node:util';
 import axios from 'axios';
 import logdown from 'logdown';
 export class HTTPService {

package/dist/{cjs/HTTPService.test.js → HTTPService.test.js}

@@ -23,7 +23,7 @@ describe('HTTPService', () => {
                 await httpService.downloadReleasesFile(mockUrl, '');
                 assert.fail('Should throw on timeout');
             }
-            catch (error) { }
+            catch (_error) { }
         });
     });
 });

package/dist/{cjs/cli.js → cli.js}

@@ -1,9 +1,13 @@
 #!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { program as commander } from 'commander';
-import { createRequire } from 'module';
-const require = createRequire(import.meta.url);
 import { ElectronInfo, SupportedDependencies } from './ElectronInfo.js';
-const { description, name, version } = require('../package.json');
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const packageJsonPath = path.join(__dirname, '../package.json');
+const { description, name, version } = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
 let matchedCommand = false;
 commander
     .name(name)
@@ -75,7 +79,9 @@ for (const [dependencyShortName, dependencyFullName] of Object.entries(Supported
                 ...(commanderOptions.force && { forceUpdate: true }),
                 ...(commanderOptions.latest && { latest: true }),
                 ...(commanderOptions.limit && { limit: parseInt(commanderOptions.limit, 10) }),
-                ...(typeof commanderOptions.prereleases !== 'undefined' && { electronPrereleases: commanderOptions.prereleases }),
+                ...(typeof commanderOptions.prereleases !== 'undefined' && {
+                    electronPrereleases: commanderOptions.prereleases,
+                }),
                 ...(commanderOptions.source && { releasesUrl: commanderOptions.source }),
                 ...(commanderOptions.timeout && { timeout: commanderOptions.timeout }),
             });

package/package.json

@@ -1,14 +1,13 @@
 {
   "author": "Florian Imdahl <git@ffflorian.de>",
-  "bin": "dist/cjs/cli.js",
+  "bin": "dist/cli.js",
   "dependencies": {
-    "axios": "1.7.2",
+    "axios": "1.7.3",
     "chalk": "5.3.0",
     "commander": "12.1.0",
     "date-fns": "3.6.0",
     "logdown": "3.3.1",
-    "parse-url": "8.1.0",
-    "semver": "7.6.2",
+    "semver": "7.6.3",
     "table": "6.8.2"
   },
   "description": "Get useful data about Electron releases.",
@@ -18,19 +17,14 @@
     "fs-extra": "11.2.0",
     "http-status-codes": "2.3.0",
     "nock": "13.5.4",
-    "rimraf": "5.0.7",
-    "typescript": "5.5.2",
-    "vitest": "1.6.0"
+    "rimraf": "6.0.1",
+    "typescript": "5.5.4",
+    "vitest": "2.0.5"
   },
   "engines": {
     "node": ">= 18.0"
   },
-  "exports": {
-    ".": {
-      "import": "./dist/esm/index.js",
-      "require": "./dist/cjs/index.js"
-    }
-  },
+  "exports": "./dist/index.js",
   "files": [
     "dist"
   ],
@@ -43,21 +37,17 @@
     "typescript"
   ],
   "license": "GPL-3.0",
-  "main": "dist/cjs/index.js",
-  "module": "dist/esm/index.js",
+  "module": "dist/index.js",
   "name": "electron-info",
   "repository": "https://github.com/ffflorian/node-packages/tree/main/packages/electron-info",
   "scripts": {
-    "build": "yarn build:cjs && yarn build:esm && yarn generate:packagejson",
-    "build:cjs": "tsc -p tsconfig.cjs.json",
-    "build:esm": "tsc -p tsconfig.json",
+    "build": "tsc -p tsconfig.json",
     "clean": "rimraf dist",
     "dist": "yarn clean && yarn build",
-    "generate:packagejson": "../../bin/generate-hybrid-package-json.sh",
     "start": "node --loader ts-node/esm src/cli.ts -d",
     "test": "vitest run"
   },
   "type": "module",
-  "version": "1.22.5",
-  "gitHead": "f7a6a79286e4eb85392b5f2d33942ab166142109"
+  "version": "1.23.1",
+  "gitHead": "aadf648655ecd0f6bea0c989542a16ff636c71a7"
 }

package/dist/cjs/ElectronInfo.test.js

@@ -1,140 +0,0 @@
-import { expect, describe, test, beforeEach, beforeAll, afterAll, afterEach } from 'vitest';
-import { StatusCodes as HTTP_STATUS } from 'http-status-codes';
-import nock from 'nock';
-import * as fs from 'fs-extra';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { randomUUID } from 'crypto';
-import { ElectronInfo } from './ElectronInfo.js';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const tempDir = path.resolve(__dirname, '.temp');
-const tempDirDownload = path.resolve(__dirname, '.temp/download');
-const mockUrl = 'http://example.com';
-const invalidUrl = 'http://invalid.inv';
-const fixturesDir = path.resolve(__dirname, '../fixtures');
-const fullReleasesFile = path.join(fixturesDir, 'electron-releases-full.json');
-const createRandomBody = () => [
-    {
-        name: 'electron v8.0.0-nightly.20190820',
-        node_id: randomUUID(),
-        npm_dist_tags: [],
-        prerelease: !!Math.round(Math.random()),
-        published_at: new Date().toUTCString(),
-        tag_name: 'v8.0.0-nightly.20190820',
-        // eslint-disable-next-line no-magic-numbers
-        total_downloads: Math.round(Math.random() * 1000),
-        version: '8.0.0-nightly.20190820',
-    },
-];
-const provideReleaseFile = async () => {
-    await fs.copy(fullReleasesFile, path.join(tempDirDownload, 'latest.json'));
-};
-describe('ElectronInfo', () => {
-    let releases;
-    beforeAll(async () => {
-        await fs.ensureDir(tempDir);
-        releases = await fs.readFile(fullReleasesFile, 'utf8');
-    });
-    beforeEach(() => {
-        nock(mockUrl).get('/').reply(HTTP_STATUS.OK, releases);
-    });
-    afterAll(() => fs.remove(tempDir));
-    afterEach(() => nock.cleanAll());
-    describe('getElectronReleases', () => {
-        test('parses Electron versions', async () => {
-            const result = await new ElectronInfo({
-                releasesUrl: mockUrl,
-                tempDirectory: tempDir,
-            }).getElectronReleases('5.0.8');
-            expect(result.length).toBe(1);
-            expect(result[0].version).toBe('5.0.8');
-        });
-        test('parses Electron SemVer', async () => {
-            const result = await new ElectronInfo({
-                releasesUrl: mockUrl,
-                tempDirectory: tempDir,
-            }).getElectronReleases('^5');
-            // eslint-disable-next-line no-magic-numbers
-            expect(result.length).toBe(23);
-        });
-        test('parses dist tags', async () => {
-            const result = await new ElectronInfo({
-                releasesUrl: mockUrl,
-                tempDirectory: tempDir,
-            }).getElectronReleases('5-0-x');
-            expect(result.length).toBe(1);
-        });
-        test('returns nothing for invalid versions', async () => {
-            const result = await new ElectronInfo({
-                releasesUrl: mockUrl,
-                tempDirectory: tempDir,
-            }).getElectronReleases('invalid');
-            expect(result.length).toBe(0);
-        });
-        test('forces downloading the release file', async () => {
-            const customBody = createRandomBody();
-            const customUrl = 'http://custom.com';
-            await provideReleaseFile();
-            nock(customUrl).get('/').reply(HTTP_STATUS.OK, customBody);
-            const result = await new ElectronInfo({
-                forceUpdate: true,
-                releasesUrl: customUrl,
-                tempDirectory: tempDirDownload,
-            }).getElectronReleases('all');
-            expect(result).toEqual(customBody);
-        });
-    });
-    describe('getDependencyReleases', () => {
-        test('parses Chrome versions', async () => {
-            const result = await new ElectronInfo({
-                releasesUrl: mockUrl,
-                tempDirectory: tempDir,
-            }).getDependencyReleases('chrome', '71.0.3578.98');
-            expect(result.length).toBe(2);
-            expect(result[0].deps).toBeDefined();
-            expect(result[0].deps.chrome).toBe('71.0.3578.98');
-        });
-        test('parses Chrome SemVer', async () => {
-            const result = await new ElectronInfo({
-                releasesUrl: mockUrl,
-                tempDirectory: tempDir,
-            }).getDependencyReleases('chrome', '~66');
-            // eslint-disable-next-line no-magic-numbers
-            expect(result.length).toBe(56);
-        });
-        test('returns nothing for invalid versions', async () => {
-            const result = await new ElectronInfo({
-                releasesUrl: mockUrl,
-                tempDirectory: tempDir,
-            }).getDependencyReleases('chrome', 'invalid');
-            expect(result.length).toBe(0);
-        });
-        test('limits releases', async () => {
-            const limit = 2;
-            const result = await new ElectronInfo({
-                limit,
-                releasesUrl: mockUrl,
-                tempDirectory: tempDir,
-            }).getDependencyReleases('chrome', 'all');
-            expect(result.length).toBe(limit);
-        });
-        test('uses a local copy of the releases', async () => {
-            nock(invalidUrl).get('/').reply(HTTP_STATUS.NOT_FOUND);
-            await provideReleaseFile();
-            await new ElectronInfo({
-                releasesUrl: invalidUrl,
-                tempDirectory: tempDirDownload,
-            }).getDependencyReleases('chrome', 'all');
-        });
-        test('uses latest as alias for limit=1', async () => {
-            const result = await new ElectronInfo({
-                latest: true,
-                releasesUrl: mockUrl,
-                tempDirectory: tempDir,
-            }).getElectronReleases('all');
-            expect(result.length).toBe(1);
-            expect(result[0].version).toBe('8.0.0-nightly.20190820');
-        });
-    });
-});

package/dist/cjs/FileService.js

@@ -1,93 +0,0 @@
-import { isAfter as isAfterDate, sub as subtractDate } from 'date-fns';
-import { constants as fsConstants, promises as fs } from 'fs';
-import parseUrl from 'parse-url';
-import logdown from 'logdown';
-import os from 'os';
-import path from 'path';
-import { HTTPService } from './HTTPService.js';
-export class FileService {
-    constructor(options) {
-        this.options = options;
-        this.logger = logdown('electron-info/FileService', {
-            logger: console,
-            markdown: false,
-        });
-        if (this.options.debug) {
-            this.logger.state.isEnabled = true;
-        }
-        this.logger.log('Initialized', this.options);
-        this.httpService = new HTTPService({
-            debug: this.options.debug,
-            timeout: this.options.timeout,
-        });
-    }
-    async getReleases() {
-        this.logger.log('Parsing releases URL', { releasesUrl: this.options.releasesUrl });
-        const parsedUrl = parseUrl(this.options.releasesUrl);
-        if (!parsedUrl.href) {
-            throw new Error('Invalid releases URL provided');
-        }
-        if (parsedUrl.protocol === 'file') {
-            this.logger.log('Releases URL points to a local file:', { releasesUrl: this.options.releasesUrl });
-            return this.loadReleasesFile(path.resolve(this.options.releasesUrl));
-        }
-        this.logger.log('Releases URL points to a URL:', { releasesUrl: this.options.releasesUrl });
-        const tempDirectory = await this.createTempDir();
-        const tempFile = path.join(tempDirectory, 'latest.json');
-        const tempFileExists = await this.isPathReadable(tempFile);
-        if (this.options.forceUpdate) {
-            this.logger.log(`Force download of the releases file requested`, {
-                forceUpdate: this.options.forceUpdate,
-                releasesUrl: this.options.releasesUrl,
-                tempFile,
-            });
-            return this.httpService.downloadReleasesFile(this.options.releasesUrl, tempFile);
-        }
-        if (tempFileExists) {
-            this.logger.log('Found a local copy of the releases file:', { tempFile });
-            const tempFileFromToday = await this.isFileFromToday(tempFile);
-            this.logger.log(`Releases file "${tempFile}" is less than 24 hours old:`, tempFileFromToday);
-            if (tempFileFromToday) {
-                return this.loadReleasesFile(tempFile);
-            }
-        }
-        return this.httpService.downloadReleasesFile(this.options.releasesUrl, tempFile);
-    }
-    async createTempDir() {
-        const tempDirectory = this.options.tempDirectory || path.join(os.tmpdir(), 'electron-info');
-        const tempDirectoryExists = await this.isPathReadable(tempDirectory);
-        if (!tempDirectoryExists) {
-            this.logger.log('Creating temp directory', { tempDirectory });
-            await fs.mkdir(tempDirectory);
-        }
-        else {
-            this.logger.log('Temp directory exists', { tempDirectory });
-        }
-        return tempDirectory;
-    }
-    async isFileFromToday(fileName) {
-        const { mtime: fileModifiedDate } = await fs.stat(fileName);
-        this.logger.log(`File "${fileName}" is from "${fileModifiedDate.toString()}"`);
-        const yesterday = subtractDate(new Date(), { days: 1 });
-        return isAfterDate(fileModifiedDate, yesterday);
-    }
-    async isPathReadable(filePath) {
-        try {
-            await fs.access(filePath, fsConstants.F_OK | fsConstants.R_OK);
-            return true;
-        }
-        catch (error) {
-            this.logger.log('File is not readable:', { errorMessage: error.message });
-            return false;
-        }
-    }
-    async loadReleasesFile(localPath) {
-        this.logger.log('Loading local releases file:', { localPath });
-        const rawData = await fs.readFile(localPath, 'utf8');
-        const releases = JSON.parse(rawData);
-        if (!Array.isArray(releases)) {
-            throw new Error('Invalid data in releases file');
-        }
-        return releases;
-    }
-}

package/dist/cjs/HTTPService.js

@@ -1,35 +0,0 @@
-import { promises as fs } from 'fs';
-import { inspect } from 'util';
-import axios from 'axios';
-import logdown from 'logdown';
-export class HTTPService {
-    constructor(options) {
-        this.options = options;
-        this.logger = logdown('electron-info/HTTPService', {
-            logger: console,
-            markdown: false,
-        });
-        if (this.options.debug) {
-            this.logger.state.isEnabled = true;
-        }
-        this.logger.log('Initialized', this.options);
-    }
-    async downloadReleasesFile(downloadUrl, targetFile) {
-        this.logger.log('Downloading releases file:', { downloadUrl, targetFile });
-        let releases = [];
-        try {
-            const response = await axios.get(downloadUrl, { timeout: this.options.timeout });
-            releases = response.data;
-        }
-        catch (error) {
-            throw new Error(`Request failed: "${error.message}"`);
-        }
-        // eslint-disable-next-line no-magic-numbers
-        this.logger.info('Received data from server:', inspect(releases).toString().slice(0, 40), '...');
-        if (!Array.isArray(releases)) {
-            throw new Error('Invalid data received from server');
-        }
-        await fs.writeFile(targetFile, JSON.stringify(releases));
-        return releases;
-    }
-}

package/dist/cjs/package.json

@@ -1,3 +0,0 @@
-{
-  "type": "commonjs"
-}

package/dist/esm/ElectronInfo.d.ts

@@ -1,70 +0,0 @@
-export interface RawDeps {
-    chrome: string;
-    modules: string;
-    node: string;
-    openssl: string;
-    uv: string;
-    v8: string;
-    zlib: string;
-}
-export interface RawReleaseInfo {
-    deps?: RawDeps;
-    name: string;
-    node_id: string;
-    npm_dist_tags: string[];
-    npm_package_name?: string;
-    prerelease: boolean;
-    published_at: string;
-    tag_name: string;
-    total_downloads: number;
-    version: string;
-}
-export interface Options {
-    /** Enable debug logging. Default: `false`. */
-    debug?: boolean;
-    /** If Electron prereleases should be included. Default: `true`. */
-    electronPrereleases?: boolean;
-    /** Force downloading the latest release file. Default: `false`. */
-    forceUpdate?: boolean;
-    /**
-     * Include only the latest release. Alias for `limit=1`. Ignores `limit`.
-     * Default: `false`.
-     */
-    latest?: boolean;
-    /**
-     * Limit output of releases. Everything below 1 will be treated as no limit.
-     * Default: 0.
-     */
-    limit?: number;
-    /**
-     * Can be a URL or a local path. Default:
-     * https://raw.githubusercontent.com/electron/releases/master/lite.json.
-     */
-    releasesUrl?: string;
-    /**
-     * Use a custom temporary directory. If not defined, the system's temporary
-     * directory will be used.
-     */
-    tempDirectory?: string;
-    /** Use a custom HTTP timeout in milliseconds. Default is `2000`. */
-    timeout?: number;
-}
-export declare const SupportedDependencies: RawDeps;
-export declare class ElectronInfo {
-    private readonly fileService;
-    private readonly logger;
-    private readonly options;
-    constructor(options?: Options);
-    getAllReleases(formatted: true, colored?: boolean): Promise<string>;
-    getAllReleases(formatted?: false): Promise<RawReleaseInfo[]>;
-    getDependencyReleases(dependency: keyof RawDeps, version: string, formatted?: false): Promise<RawReleaseInfo[]>;
-    getDependencyReleases(dependency: keyof RawDeps, version: string, formatted: true, colored?: boolean): Promise<RawReleaseInfo[] | string>;
-    getElectronReleases(version: string, formatted: true, colored?: boolean): Promise<string>;
-    getElectronReleases(version: string, formatted?: false): Promise<RawReleaseInfo[]>;
-    private buildFoundString;
-    private buildRawTables;
-    private formatDependencyReleases;
-    private formatReleases;
-    private getVersions;
-    private limitReleases;
-}

package/dist/esm/ElectronInfo.js

@@ -1,155 +0,0 @@
-import chalk from 'chalk';
-import { format as formatDate } from 'date-fns';
-import { table as createTable } from 'table';
-import logdown from 'logdown';
-import semver from 'semver';
-import { FileService } from './FileService.js';
-const defaultOptions = {
-    debug: false,
-    electronPrereleases: true,
-    forceUpdate: false,
-    latest: false,
-    limit: 0,
-    releasesUrl: 'https://raw.githubusercontent.com/electron/releases/master/lite.json',
-    tempDirectory: '',
-    timeout: 2000,
-};
-export const SupportedDependencies = {
-    chrome: 'Chrome',
-    modules: 'Modules (Node ABI)',
-    node: 'Node.js',
-    openssl: 'OpenSSL',
-    uv: 'uv',
-    v8: 'V8',
-    zlib: 'zlib',
-};
-export class ElectronInfo {
-    constructor(options) {
-        this.options = { ...defaultOptions, ...options };
-        this.options.limit = Math.max(0, this.options.limit);
-        this.logger = logdown('electron-info/ElectronInfo', {
-            logger: console,
-            markdown: false,
-        });
-        if (this.options.debug) {
-            this.logger.state.isEnabled = true;
-        }
-        this.fileService = new FileService(this.options);
-        this.logger.log('Initialized', this.options);
-    }
-    async getAllReleases(formatted, colored) {
-        this.logger.log('Getting all releases:', { colored, formatted });
-        const allReleases = await this.fileService.getReleases();
-        const limitedReleases = this.limitReleases(allReleases);
-        return formatted ? this.formatReleases(limitedReleases, colored) : limitedReleases;
-    }
-    async getDependencyReleases(dependency, version, formatted, colored) {
-        this.logger.log('Getting dependency releases:', { colored, dependency, formatted, version });
-        const allReleases = await this.fileService.getReleases();
-        const dependencyVersions = await this.getVersions(allReleases, dependency, version);
-        const filteredReleases = allReleases.filter(release => release.deps && dependencyVersions.includes(release.deps[dependency]));
-        const limitedReleases = this.limitReleases(filteredReleases);
-        return formatted ? this.formatDependencyReleases(limitedReleases, colored) : limitedReleases;
-    }
-    async getElectronReleases(version, formatted, colored) {
-        this.logger.log('Getting Electron releases:', { colored, formatted, version });
-        const allReleases = await this.fileService.getReleases();
-        const electronVersions = await this.getVersions(allReleases, 'electron', version);
-        const filteredReleases = allReleases.filter(release => electronVersions.includes(release.version));
-        const limitedReleases = this.limitReleases(filteredReleases);
-        return formatted ? this.formatReleases(limitedReleases, colored) : limitedReleases;
-    }
-    buildFoundString(releases) {
-        this.logger.log('Building found string:', { releasesLength: releases.length });
-        return `Found ${releases.length} release${releases.length === 1 ? '' : 's'}.`;
-    }
-    buildRawTables(releases, colored) {
-        this.logger.log('Building raw tables:', { colored, releasesLength: releases.length });
-        const coloredOrNot = (text, style) => (colored ? style(text) : text);
-        return releases.map(release => {
-            const electronVersion = `${release.version}${release.prerelease ? ' (prerelease)' : ''}`;
-            const parsedDate = new Date(release.published_at);
-            const releaseDate = formatDate(parsedDate, 'yyyy-MM-dd');
-            const table = [
-                [coloredOrNot('Electron', chalk.bold), electronVersion],
-                [coloredOrNot('Published on', chalk.bold), releaseDate],
-            ];
-            if (release.deps) {
-                table.push([coloredOrNot(SupportedDependencies.node, chalk.bold.red), release.deps.node], [coloredOrNot(SupportedDependencies.chrome, chalk.bold.green), release.deps.chrome], [coloredOrNot(SupportedDependencies.openssl, chalk.bold.blue), release.deps.openssl], [coloredOrNot(SupportedDependencies.modules, chalk.bold.yellow), release.deps.modules], [coloredOrNot(SupportedDependencies.uv, chalk.bold.cyan), release.deps.uv], 
-                // eslint-disable-next-line no-magic-numbers
-                [coloredOrNot(SupportedDependencies.v8, chalk.bold.rgb(150, 150, 150)), release.deps.v8], [coloredOrNot(SupportedDependencies.zlib, chalk.bold.magenta), release.deps.zlib]);
-            }
-            return table;
-        });
-    }
-    formatDependencyReleases(releases, colored) {
-        this.logger.log('Formatting dependency releases:', { colored, releasesLength: releases.length });
-        releases = releases.filter(release => !!release.deps);
-        if (!releases.length) {
-            return this.buildFoundString(releases);
-        }
-        const joinedReleases = this.buildRawTables(releases, colored)
-            .map(table => createTable(table))
-            .join('\n');
-        return `${joinedReleases}\n${this.buildFoundString(releases)}`;
-    }
-    formatReleases(releases, colored) {
-        this.logger.log('Formatting releases:', { colored, releasesLength: releases.length });
-        if (!releases.length) {
-            return this.buildFoundString(releases);
-        }
-        const joinedReleases = this.buildRawTables(releases, colored)
-            .map(table => createTable(table))
-            .join('\n');
-        return `${joinedReleases}\n${this.buildFoundString(releases)}`;
-    }
-    async getVersions(releases, key, inputVersion) {
-        this.logger.log('Getting versions:', { inputVersion, key });
-        const satisfiesVersion = (dependencyVersion, inputVersion) => {
-            const dependencyVersionClean = semver.clean(dependencyVersion, { loose: true }) || '';
-            return semver.satisfies(dependencyVersionClean, inputVersion, {
-                includePrerelease: true,
-                loose: true,
-            });
-        };
-        let dependencyVersions = [];
-        if (!this.options.electronPrereleases) {
-            const tempReleaseNumber = releases.length;
-            releases = releases.filter(release => semver.prerelease(release.version) === null);
-            this.logger.log('Removing electron prereleases from found versions', {
-                after: releases.length,
-                before: tempReleaseNumber,
-            });
-        }
-        dependencyVersions = releases
-            .filter(release => {
-            if (key !== 'electron' && !release.deps) {
-                return false;
-            }
-            if (inputVersion === 'all') {
-                return true;
-            }
-            if (key === 'electron' && release.npm_dist_tags && release.npm_dist_tags.includes(inputVersion)) {
-                return true;
-            }
-            return key === 'electron'
-                ? satisfiesVersion(release.version, inputVersion)
-                : satisfiesVersion(release.deps[key], inputVersion);
-        })
-            .map(release => (key === 'electron' ? release.version : release.deps[key]));
-        return dependencyVersions;
-    }
-    limitReleases(releases) {
-        const limit = this.options.limit || (this.options.latest ? 1 : undefined);
-        if (limit) {
-            const slicedArray = releases.slice(0, limit);
-            this.logger.log('Limiting found versions', {
-                after: slicedArray.length,
-                before: releases.length,
-                limit,
-            });
-            return slicedArray;
-        }
-        return releases;
-    }
-}

package/dist/esm/ElectronInfo.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/esm/FileService.d.ts

@@ -1,12 +0,0 @@
-import type { Options, RawReleaseInfo } from './ElectronInfo.js';
-export declare class FileService {
-    private readonly httpService;
-    private readonly logger;
-    private readonly options;
-    constructor(options: Required<Options>);
-    getReleases(): Promise<RawReleaseInfo[]>;
-    private createTempDir;
-    private isFileFromToday;
-    private isPathReadable;
-    private loadReleasesFile;
-}

package/dist/esm/HTTPService.d.ts

@@ -1,8 +0,0 @@
-import type { Options, RawReleaseInfo } from './ElectronInfo.js';
-export type HTTPOptions = Pick<Options, 'debug' | 'timeout'>;
-export declare class HTTPService {
-    private readonly logger;
-    private readonly options;
-    constructor(options: Required<HTTPOptions>);
-    downloadReleasesFile(downloadUrl: string, targetFile: string): Promise<RawReleaseInfo[]>;
-}

package/dist/esm/HTTPService.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/esm/HTTPService.test.js

@@ -1,29 +0,0 @@
-import { assert, describe, test, beforeEach, afterEach } from 'vitest';
-import { StatusCodes as HTTP_STATUS } from 'http-status-codes';
-import nock from 'nock';
-import { HTTPService } from './HTTPService.js';
-const mockUrl = 'http://example.com';
-const FIVE_SECONDS_IN_MILLIS = 5000;
-const HALF_SECOND_IN_MILLIS = 500;
-describe('HTTPService', () => {
-    const httpService = new HTTPService({
-        debug: false,
-        timeout: HALF_SECOND_IN_MILLIS,
-    });
-    beforeEach(() => {
-        nock(mockUrl)
-            .get('/')
-            .delayConnection(FIVE_SECONDS_IN_MILLIS)
-            .reply(HTTP_STATUS.OK, [{ data: 'invalid' }]);
-    });
-    afterEach(() => nock.cleanAll());
-    describe('downloadReleasesFile', () => {
-        test('honors a custom timeout', async () => {
-            try {
-                await httpService.downloadReleasesFile(mockUrl, '');
-                assert.fail('Should throw on timeout');
-            }
-            catch (error) { }
-        });
-    });
-});

package/dist/esm/cli.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/esm/cli.js

@@ -1,123 +0,0 @@
-#!/usr/bin/env node
-import { program as commander } from 'commander';
-import { createRequire } from 'module';
-const require = createRequire(import.meta.url);
-import { ElectronInfo, SupportedDependencies } from './ElectronInfo.js';
-const { description, name, version } = require('../package.json');
-let matchedCommand = false;
-commander
-    .name(name)
-    .description(`${description}
-
-Allowed version argument inputs:
-  - SemVer versions (e.g. "~7")
-  - npm dist tags (e.g. "5-0-x", only Electron)
-  - "all"`)
-    .option('-d, --debug', 'enable debug logging')
-    .option('-f, --force', 'force downloading the latest release file')
-    .option('-L, --latest', 'list only the latest release (alias for --limit 1, ignores limit)')
-    .option('-l, --limit <number>', 'limit output of releases')
-    .option('-r, --raw', 'output raw JSON')
-    .option('-s, --source <url>', 'use a custom releases source URL or path')
-    .option('-t, --timeout <number>', 'use a custom HTTP timeout')
-    .version(version, '-v, --version')
-    .option('--no-colors', `don't use colors for displaying`)
-    .option('--no-prereleases', `don't include Electron prereleases`);
-const commanderOptions = commander.opts();
-commander
-    .command('electron')
-    .alias('e')
-    .description('show data for Electron releases')
-    .arguments('[version]')
-    .action(async (input) => {
-    matchedCommand = true;
-    if (!input) {
-        console.error('No version specified.');
-        commander.outputHelp();
-        process.exit();
-    }
-    try {
-        const electronInfo = new ElectronInfo({
-            ...(commanderOptions.debug && { debug: true }),
-            ...(commanderOptions.force && { forceUpdate: true }),
-            ...(commanderOptions.latest && { latest: true }),
-            ...(commanderOptions.limit && { limit: parseInt(commanderOptions.limit, 10) }),
-            ...(typeof commanderOptions.prereleases !== 'undefined' && { electronPrereleases: commanderOptions.prereleases }),
-            ...(commanderOptions.source && { releasesUrl: commanderOptions.source }),
-            ...(commanderOptions.timeout && { timeout: parseInt(commanderOptions.timeout, 10) }),
-        });
-        const releases = commanderOptions.raw
-            ? await electronInfo.getElectronReleases(input)
-            : await electronInfo.getElectronReleases(input, true, commanderOptions.colors);
-        console.info(releases);
-    }
-    catch (error) {
-        console.error(error);
-        process.exit(1);
-    }
-});
-for (const [dependencyShortName, dependencyFullName] of Object.entries(SupportedDependencies)) {
-    commander
-        .command(dependencyShortName)
-        .alias(dependencyShortName[0])
-        .description(`show data for ${dependencyFullName} releases`)
-        .arguments('[version]')
-        .action(async (version) => {
-        matchedCommand = true;
-        if (!version) {
-            console.error('No version specified.');
-            commander.outputHelp();
-            process.exit();
-        }
-        try {
-            const electronInfo = new ElectronInfo({
-                ...(commanderOptions.debug && { debug: true }),
-                ...(commanderOptions.force && { forceUpdate: true }),
-                ...(commanderOptions.latest && { latest: true }),
-                ...(commanderOptions.limit && { limit: parseInt(commanderOptions.limit, 10) }),
-                ...(typeof commanderOptions.prereleases !== 'undefined' && { electronPrereleases: commanderOptions.prereleases }),
-                ...(commanderOptions.source && { releasesUrl: commanderOptions.source }),
-                ...(commanderOptions.timeout && { timeout: commanderOptions.timeout }),
-            });
-            const releases = commanderOptions.raw
-                ? await electronInfo.getDependencyReleases(dependencyShortName, version)
-                : await electronInfo.getDependencyReleases(dependencyShortName, version, true, commanderOptions.colors);
-            console.info(releases);
-        }
-        catch (error) {
-            console.error(error);
-            process.exit(1);
-        }
-    });
-}
-commander
-    .command('all', { isDefault: true })
-    .alias('a')
-    .description('show data for all kinds of releases')
-    .action(async () => {
-    matchedCommand = true;
-    try {
-        const electronInfo = new ElectronInfo({
-            ...(commanderOptions.debug && { debug: true }),
-            ...(commanderOptions.force && { forceUpdate: true }),
-            ...(commanderOptions.latest && { latest: true }),
-            ...(commanderOptions.limit && { limit: parseInt(commanderOptions.limit, 10) }),
-            ...(typeof commanderOptions.prereleases !== 'undefined' && { electronPrereleases: commanderOptions.prereleases }),
-            ...(commanderOptions.source && { releasesUrl: commanderOptions.source }),
-            ...(commanderOptions.timeout && { timeout: commanderOptions.timeout }),
-        });
-        const releases = commanderOptions.raw
-            ? await electronInfo.getAllReleases()
-            : await electronInfo.getAllReleases(true, commanderOptions.colors);
-        console.info(releases);
-    }
-    catch (error) {
-        console.error(error);
-        process.exit(1);
-    }
-});
-commander.parse(process.argv);
-if (!commander.args.length || !matchedCommand) {
-    console.error('Invalid or no command specified.');
-    commander.help();
-}

package/dist/esm/index.d.ts

@@ -1 +0,0 @@
-export * from './ElectronInfo.js';

package/dist/esm/index.js

@@ -1 +0,0 @@
-export * from './ElectronInfo.js';

package/dist/esm/package.json

@@ -1,3 +0,0 @@
-{
-  "type": "module"
-}