@ctrl/transmission 2.5.0 → 4.1.0

package/dist/src/index.d.ts

@@ -0,0 +1,2 @@
+export * from './transmission.js';
+export * from './types.js';

package/dist/src/index.js

@@ -0,0 +1,2 @@
+export * from './transmission.js';
+export * from './types.js';

package/dist/{transmission.d.ts → src/transmission.d.ts}

@@ -1,45 +1,38 @@
-/// <reference types="node" />
+/// <reference types="node" resolution-mode="require"/>
 import { Response } from 'got';
 import { AddTorrentOptions as NormalizedAddTorrentOptions, AllClientData, NormalizedTorrent, TorrentClient, TorrentSettings } from '@ctrl/shared-torrent';
-import { AddTorrentOptions, AddTorrentResponse, DefaultResponse, FreeSpaceResponse, GetTorrentRepsonse, RenamePathOptions, SessionArguments, SessionResponse, SetTorrentOptions, TorrentIds } from './types';
-/**
- * TODO: remove when hash is available on normalized torrent
- * @deprecated
- */
-export declare type TransmissionNormalizedTorrent = NormalizedTorrent & {
-    hash: string;
-};
+import { AddTorrentOptions, AddTorrentResponse, DefaultResponse, FreeSpaceResponse, GetTorrentRepsonse, NormalizedTorrentIds, RenamePathOptions, SessionArguments, SessionResponse, SetTorrentOptions } from './types.js';
 export declare class Transmission implements TorrentClient {
     config: TorrentSettings;
     sessionId?: string;
     constructor(options?: Partial<TorrentSettings>);
     getSession(): Promise<SessionResponse>;
     setSession(args: Partial<SessionArguments>): Promise<SessionResponse>;
-    queueTop(ids: TorrentIds): Promise<DefaultResponse>;
-    queueBottom(ids: TorrentIds): Promise<DefaultResponse>;
-    queueUp(ids: TorrentIds): Promise<DefaultResponse>;
-    queueDown(ids: TorrentIds): Promise<DefaultResponse>;
+    queueTop(id: NormalizedTorrentIds): Promise<DefaultResponse>;
+    queueBottom(id: NormalizedTorrentIds): Promise<DefaultResponse>;
+    queueUp(id: NormalizedTorrentIds): Promise<DefaultResponse>;
+    queueDown(id: NormalizedTorrentIds): Promise<DefaultResponse>;
     freeSpace(path?: string): Promise<FreeSpaceResponse>;
-    pauseTorrent(ids: TorrentIds): Promise<DefaultResponse>;
-    resumeTorrent(ids: TorrentIds): Promise<DefaultResponse>;
-    verifyTorrent(ids: TorrentIds): Promise<DefaultResponse>;
+    pauseTorrent(id: NormalizedTorrentIds): Promise<DefaultResponse>;
+    resumeTorrent(id: NormalizedTorrentIds): Promise<DefaultResponse>;
+    verifyTorrent(id: NormalizedTorrentIds): Promise<DefaultResponse>;
     /**
      * ask tracker for more peers
      */
-    reannounceTorrent(ids: TorrentIds): Promise<DefaultResponse>;
-    moveTorrent(ids: TorrentIds, location: string): Promise<DefaultResponse>;
+    reannounceTorrent(id: NormalizedTorrentIds): Promise<DefaultResponse>;
+    moveTorrent(id: NormalizedTorrentIds, location: string): Promise<DefaultResponse>;
     /**
      * Torrent Mutators
      */
-    setTorrent(ids: TorrentIds, options?: Partial<SetTorrentOptions>): Promise<DefaultResponse>;
+    setTorrent(id: NormalizedTorrentIds, options?: Partial<SetTorrentOptions>): Promise<DefaultResponse>;
     /**
      * Renaming a Torrent's Path
      */
-    renamePath(ids: TorrentIds, options?: Partial<RenamePathOptions>): Promise<DefaultResponse>;
+    renamePath(id: NormalizedTorrentIds, options?: Partial<RenamePathOptions>): Promise<DefaultResponse>;
     /**
      * Removing a Torrent
      */
-    removeTorrent(ids: TorrentIds, removeData?: boolean): Promise<AddTorrentResponse>;
+    removeTorrent(id: NormalizedTorrentIds, removeData?: boolean): Promise<AddTorrentResponse>;
     /**
      * An alias for {@link Transmission.addMagnet}
      */
@@ -56,10 +49,11 @@ export declare class Transmission implements TorrentClient {
      * @param torrent a string of file path or contents of the file as base64 string
      */
     addTorrent(torrent: string | Buffer, options?: Partial<AddTorrentOptions>): Promise<AddTorrentResponse>;
-    normalizedAddTorrent(torrent: string | Buffer, options?: Partial<NormalizedAddTorrentOptions>): Promise<TransmissionNormalizedTorrent>;
-    getTorrent(id: TorrentIds): Promise<TransmissionNormalizedTorrent>;
+    normalizedAddTorrent(torrent: string | Buffer, options?: Partial<NormalizedAddTorrentOptions>): Promise<NormalizedTorrent>;
+    getTorrent(id: NormalizedTorrentIds): Promise<NormalizedTorrent>;
     getAllData(): Promise<AllClientData>;
-    listTorrents(ids?: TorrentIds, additionalFields?: string[]): Promise<GetTorrentRepsonse>;
+    listTorrents(id?: NormalizedTorrentIds, additionalFields?: string[]): Promise<GetTorrentRepsonse>;
     request<T>(method: string, args?: any): Promise<Response<T>>;
+    private _handleNormalizedIds;
     private _normalizeTorrentData;
 }

package/dist/{transmission.js → src/transmission.js}

@@ -1,13 +1,8 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Transmission = void 0;
-const fs_1 = require("fs");
-const got_1 = __importDefault(require("got"));
-const shared_torrent_1 = require("@ctrl/shared-torrent");
-const url_join_1 = require("@ctrl/url-join");
+import { existsSync, readFileSync } from 'fs';
+import got from 'got';
+import { magnetDecode } from '@ctrl/magnet-link';
+import { TorrentState, } from '@ctrl/shared-torrent';
+import { urlJoin } from '@ctrl/url-join';
 const defaults = {
     baseUrl: 'http://localhost:9091/',
     path: '/transmission/rpc',
@@ -15,8 +10,20 @@ const defaults = {
     password: '',
     timeout: 5000,
 };
-class Transmission {
+export class Transmission {
     constructor(options = {}) {
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "sessionId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.config = { ...defaults, ...options };
     }
     async getSession() {
@@ -27,19 +34,23 @@ class Transmission {
         const res = await this.request('session-set', args);
         return res.body;
     }
-    async queueTop(ids) {
+    async queueTop(id) {
+        const ids = this._handleNormalizedIds(id);
         const res = await this.request('queue-move-top', { ids });
         return res.body;
     }
-    async queueBottom(ids) {
+    async queueBottom(id) {
+        const ids = this._handleNormalizedIds(id);
         const res = await this.request('queue-move-bottom', { ids });
         return res.body;
     }
-    async queueUp(ids) {
+    async queueUp(id) {
+        const ids = this._handleNormalizedIds(id);
         const res = await this.request('queue-move-up', { ids });
         return res.body;
     }
-    async queueDown(ids) {
+    async queueDown(id) {
+        const ids = this._handleNormalizedIds(id);
         const res = await this.request('queue-move-down', { ids });
         return res.body;
     }
@@ -47,26 +58,31 @@ class Transmission {
         const res = await this.request('free-space', { path });
         return res.body;
     }
-    async pauseTorrent(ids) {
+    async pauseTorrent(id) {
+        const ids = this._handleNormalizedIds(id);
         const res = await this.request('torrent-stop', { ids });
         return res.body;
     }
-    async resumeTorrent(ids) {
+    async resumeTorrent(id) {
+        const ids = this._handleNormalizedIds(id);
         const res = await this.request('torrent-start', { ids });
         return res.body;
     }
-    async verifyTorrent(ids) {
+    async verifyTorrent(id) {
+        const ids = this._handleNormalizedIds(id);
         const res = await this.request('torrent-verify', { ids });
         return res.body;
     }
     /**
      * ask tracker for more peers
      */
-    async reannounceTorrent(ids) {
+    async reannounceTorrent(id) {
+        const ids = this._handleNormalizedIds(id);
         const res = await this.request('torrent-reannounce', { ids });
         return res.body;
     }
-    async moveTorrent(ids, location) {
+    async moveTorrent(id, location) {
+        const ids = this._handleNormalizedIds(id);
         const res = await this.request('torrent-set-location', {
             ids,
             move: true,
@@ -77,7 +93,8 @@ class Transmission {
     /**
      * Torrent Mutators
      */
-    async setTorrent(ids, options = {}) {
+    async setTorrent(id, options = {}) {
+        const ids = this._handleNormalizedIds(id);
         options.ids = ids;
         const res = await this.request('torrent-set', options);
         return res.body;
@@ -85,7 +102,8 @@ class Transmission {
     /**
      * Renaming a Torrent's Path
      */
-    async renamePath(ids, options = {}) {
+    async renamePath(id, options = {}) {
+        const ids = this._handleNormalizedIds(id);
         options.ids = ids;
         const res = await this.request('torrent-rename-path', options);
         return res.body;
@@ -93,7 +111,8 @@ class Transmission {
     /**
      * Removing a Torrent
      */
-    async removeTorrent(ids, removeData = true) {
+    async removeTorrent(id, removeData = true) {
+        const ids = this._handleNormalizedIds(id);
         const res = await this.request('torrent-remove', {
             ids,
             'delete-local-data': removeData,
@@ -133,8 +152,8 @@ class Transmission {
             ...options,
         };
         if (typeof torrent === 'string') {
-            args.metainfo = (0, fs_1.existsSync)(torrent)
-                ? Buffer.from((0, fs_1.readFileSync)(torrent)).toString('base64')
+            args.metainfo = existsSync(torrent)
+                ? Buffer.from(readFileSync(torrent)).toString('base64')
                 : Buffer.from(torrent, 'base64').toString('base64');
         }
         else {
@@ -148,15 +167,25 @@ class Transmission {
         if (options.startPaused) {
             torrentOptions.paused = true;
         }
-        if (!Buffer.isBuffer(torrent)) {
-            torrent = Buffer.from(torrent);
+        let torrentHash;
+        if (typeof torrent === 'string' && torrent.startsWith('magnet:')) {
+            torrentHash = magnetDecode(torrent).infoHash;
+            if (!torrentHash) {
+                throw new Error('Magnet did not contain hash');
+            }
+            await this.addMagnet(torrent, torrentOptions);
+        }
+        else {
+            if (!Buffer.isBuffer(torrent)) {
+                torrent = Buffer.from(torrent);
+            }
+            const res = await this.addTorrent(torrent, torrentOptions);
+            torrentHash = res.arguments['torrent-added'].hashString;
         }
-        const res = await this.addTorrent(torrent, torrentOptions);
-        const torrentId = res.arguments['torrent-added'].id;
         if (options.label) {
-            await this.setTorrent(torrentId, { labels: [options.label] });
+            await this.setTorrent(torrentHash, { labels: [options.label] });
         }
-        return this.getTorrent(torrentId);
+        return this.getTorrent(torrentHash);
     }
     async getTorrent(id) {
         const result = await this.listTorrents(id);
@@ -186,7 +215,7 @@ class Transmission {
         };
         return results;
     }
-    async listTorrents(ids, additionalFields = []) {
+    async listTorrents(id, additionalFields = []) {
         const fields = [
             'id',
             'addedDate',
@@ -249,14 +278,14 @@ class Transmission {
             ...additionalFields,
         ];
         const args = { fields };
-        if (ids) {
+        if (id) {
+            const ids = this._handleNormalizedIds(id);
             args.ids = ids;
         }
         const res = await this.request('torrent-get', args);
         return res.body;
     }
     async request(method, args = {}) {
-        var _a, _b, _c;
         if (!this.sessionId && method !== 'session-get') {
             await this.getSession();
         }
@@ -264,27 +293,27 @@ class Transmission {
             'X-Transmission-Session-Id': this.sessionId,
         };
         if (this.config.username || this.config.password) {
-            const str = `${(_a = this.config.username) !== null && _a !== void 0 ? _a : ''}:${(_b = this.config.password) !== null && _b !== void 0 ? _b : ''}`;
+            const str = `${this.config.username ?? ''}:${this.config.password ?? ''}`;
             headers.Authorization = 'Basic ' + Buffer.from(str).toString('base64');
         }
-        const url = (0, url_join_1.urlJoin)(this.config.baseUrl, this.config.path);
+        const url = urlJoin(this.config.baseUrl, this.config.path);
         try {
-            const res = await got_1.default.post(url, {
+            const res = await got.post(url, {
                 json: {
                     method,
                     arguments: args,
                 },
                 headers,
-                retry: 0,
+                retry: { limit: 0 },
                 // allow proxy agent
-                agent: this.config.agent,
-                timeout: this.config.timeout,
+                timeout: { request: this.config.timeout },
                 responseType: 'json',
+                ...(this.config.agent ? { agent: this.config.agent } : {}),
             });
             return res;
         }
         catch (error) {
-            if (((_c = error === null || error === void 0 ? void 0 : error.response) === null || _c === void 0 ? void 0 : _c.statusCode) === 409) {
+            if (error?.response?.statusCode === 409) {
                 this.sessionId = error.response.headers['x-transmission-session-id'];
                 // eslint-disable-next-line no-return-await
                 return await this.request(method, args);
@@ -293,31 +322,35 @@ class Transmission {
             throw error;
         }
     }
+    _handleNormalizedIds(ids) {
+        if (typeof ids === 'string' && ids !== 'recently-active') {
+            return [ids];
+        }
+        return ids;
+    }
     _normalizeTorrentData(torrent) {
-        var _a;
         const dateAdded = new Date(torrent.addedDate * 1000).toISOString();
         const dateCompleted = new Date(torrent.doneDate * 1000).toISOString();
         // normalize state to enum
         // https://github.com/transmission/transmission/blob/c11f2870fd18ff781ca06ce84b6d43541f3293dd/web/javascript/torrent.js#L18
-        let state = shared_torrent_1.TorrentState.unknown;
+        let state = TorrentState.unknown;
         if (torrent.status === 6) {
-            state = shared_torrent_1.TorrentState.seeding;
+            state = TorrentState.seeding;
         }
         else if (torrent.status === 4) {
-            state = shared_torrent_1.TorrentState.downloading;
+            state = TorrentState.downloading;
         }
         else if (torrent.status === 0) {
-            state = shared_torrent_1.TorrentState.paused;
+            state = TorrentState.paused;
         }
         else if (torrent.status === 2) {
-            state = shared_torrent_1.TorrentState.checking;
+            state = TorrentState.checking;
         }
         else if (torrent.status === 3 || torrent.status === 5) {
-            state = shared_torrent_1.TorrentState.queued;
+            state = TorrentState.queued;
         }
         return {
-            id: torrent.id,
-            hash: torrent.hashString,
+            id: torrent.hashString,
             name: torrent.name,
             state,
             isCompleted: torrent.leftUntilDone < 1,
@@ -326,7 +359,7 @@ class Transmission {
             ratio: torrent.uploadRatio,
             dateAdded,
             dateCompleted,
-            label: ((_a = torrent.labels) === null || _a === void 0 ? void 0 : _a.length) ? torrent.labels[0] : undefined,
+            label: torrent.labels?.length ? torrent.labels[0] : undefined,
             savePath: torrent.downloadDir,
             uploadSpeed: torrent.rateUpload,
             downloadSpeed: torrent.rateDownload,
@@ -343,4 +376,3 @@ class Transmission {
         };
     }
 }
-exports.Transmission = Transmission;

package/dist/{types.d.ts → src/types.d.ts}

@@ -39,12 +39,17 @@ export interface FreeSpaceResponse extends DefaultResponse {
 /**
  * "ids", which specifies which torrents to use.
  * All torrents are used if the "ids" argument is omitted.
+ *
  * "ids" should be one of the following:
- * (1) an integer referring to a torrent id
- * (2) a list of torrent id numbers, sha1 hash strings, or both
- * (3) a string, "recently-active", for recently-active torrents
+ * 1. an integer referring to a torrent id
+ * 2. a list of torrent id numbers, sha1 hash strings, or both
+ * 3. a string, "recently-active", for recently-active torrents
  */
 export declare type TorrentIds = number | 'recently-active' | Array<number | string>;
+/**
+ * Allows the user to pass a single hash, this will be converted to an array
+ */
+export declare type NormalizedTorrentIds = TorrentIds | string;
 export interface GetTorrentRepsonse extends DefaultResponse {
     arguments: {
         removed: Torrent[];

package/dist/src/types.js

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

package/dist/test/transmission.spec.d.ts

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

package/dist/test/transmission.spec.js

@@ -0,0 +1,136 @@
+import fs from 'fs';
+import path from 'path';
+import pWaitFor from 'p-wait-for';
+import { afterEach, describe, expect, it } from 'vitest';
+import { TorrentState } from '@ctrl/shared-torrent';
+import { Transmission } from '../src/index.js';
+const baseUrl = 'http://localhost:9091/';
+const torrentName = 'ubuntu-18.04.1-desktop-amd64.iso';
+const torrentFile = path.join(__dirname, '/ubuntu-18.04.1-desktop-amd64.iso.torrent');
+async function setupTorrent(transmission) {
+    const res = await transmission.addTorrent(torrentFile);
+    await pWaitFor(async () => {
+        const r = await transmission.listTorrents(undefined, ['id']);
+        return r.arguments.torrents.length === 1;
+    }, { timeout: 10000, interval: 200 });
+    return res.arguments['torrent-added'].hashString;
+}
+describe('Transmission', () => {
+    afterEach(async () => {
+        const transmission = new Transmission({ baseUrl });
+        const res = await transmission.listTorrents();
+        // clean up all torrents
+        for (const torrent of res.arguments.torrents) {
+            // eslint-disable-next-line no-await-in-loop
+            await transmission.removeTorrent(torrent.id, false);
+        }
+    });
+    it('should be instantiable', () => {
+        const transmission = new Transmission({ baseUrl });
+        expect(transmission).toBeTruthy();
+    });
+    it('should add torrent from file path string', async () => {
+        const transmission = new Transmission({ baseUrl });
+        const res = await transmission.addTorrent(torrentFile);
+        expect(res.result).toBe('success');
+    });
+    it('should add magnet link', async () => {
+        const magnet = 'magnet:?xt=urn:btih:B0B81206633C42874173D22E564D293DAEFC45E2&dn=Ubuntu+11+10+Alternate+Amd64+Iso&tr=udp%3A%2F%2Ftracker.coppersurfer.tk%3A6969%2Fannounce&tr=udp%3A%2F%2F9.rarbg.to%3A2710%2Fannounce&tr=udp%3A%2F%2Ftracker.opentrackr.org%3A1337%2Fannounce&tr=udp%3A%2F%2Ftracker.leechers-paradise.org%3A6969%2Fannounce&tr=udp%3A%2F%2Ftracker.open-internet.nl%3A6969%2Fannounce&tr=udp%3A%2F%2Fopen.demonii.si%3A1337%2Fannounce&tr=udp%3A%2F%2Ftracker.pirateparty.gr%3A6969%2Fannounce&tr=udp%3A%2F%2Fdenis.stalker.upeer.me%3A6969%2Fannounce&tr=udp%3A%2F%2Fp4p.arenabg.com%3A1337%2Fannounce&tr=udp%3A%2F%2Fexodus.desync.com%3A6969%2Fannounce';
+        const client = new Transmission({ baseUrl });
+        const res = await client.addMagnet(magnet);
+        expect(res.result).toBe('success');
+    });
+    it('should add normalized magnet link', async () => {
+        const magnet = 'magnet:?xt=urn:btih:B0B81206633C42874173D22E564D293DAEFC45E2&dn=Ubuntu+11+10+Alternate+Amd64+Iso&tr=udp%3A%2F%2Ftracker.coppersurfer.tk%3A6969%2Fannounce&tr=udp%3A%2F%2F9.rarbg.to%3A2710%2Fannounce&tr=udp%3A%2F%2Ftracker.opentrackr.org%3A1337%2Fannounce&tr=udp%3A%2F%2Ftracker.leechers-paradise.org%3A6969%2Fannounce&tr=udp%3A%2F%2Ftracker.open-internet.nl%3A6969%2Fannounce&tr=udp%3A%2F%2Fopen.demonii.si%3A1337%2Fannounce&tr=udp%3A%2F%2Ftracker.pirateparty.gr%3A6969%2Fannounce&tr=udp%3A%2F%2Fdenis.stalker.upeer.me%3A6969%2Fannounce&tr=udp%3A%2F%2Fp4p.arenabg.com%3A1337%2Fannounce&tr=udp%3A%2F%2Fexodus.desync.com%3A6969%2Fannounce';
+        const client = new Transmission({ baseUrl });
+        const res = await client.normalizedAddTorrent(magnet);
+        expect(res.id).toBeTruthy();
+    });
+    it('should add torrent from file buffer', async () => {
+        const transmission = new Transmission({ baseUrl });
+        const res = await transmission.addTorrent(fs.readFileSync(torrentFile));
+        expect(res.result).toBe('success');
+    });
+    it('should add torrent from file contents base64', async () => {
+        const transmission = new Transmission({ baseUrl });
+        const contents = Buffer.from(fs.readFileSync(torrentFile)).toString('base64');
+        const res = await transmission.addTorrent(contents);
+        expect(res.result).toBe('success');
+    });
+    it('should get torrents', async () => {
+        const transmission = new Transmission({ baseUrl });
+        await setupTorrent(transmission);
+        const res = await transmission.listTorrents(undefined, ['id']);
+        expect(res.arguments.torrents).toHaveLength(1);
+    });
+    it('should get normalized all torrent data', async () => {
+        const transmission = new Transmission({ baseUrl });
+        await setupTorrent(transmission);
+        const res = await transmission.getAllData();
+        expect(res.torrents).toHaveLength(1);
+        expect(res.torrents[0].name).toBe(torrentName);
+    });
+    it('should get normalized torrent data', async () => {
+        const transmission = new Transmission({ baseUrl });
+        const id = await setupTorrent(transmission);
+        const res = await transmission.getTorrent(id);
+        expect(res.name).toBe(torrentName);
+    });
+    it('should remove torrent', async () => {
+        const transmission = new Transmission({ baseUrl });
+        const key = await setupTorrent(transmission);
+        await transmission.removeTorrent(key, false);
+    });
+    it('should verify torrent', async () => {
+        const transmission = new Transmission({ baseUrl });
+        const key = await setupTorrent(transmission);
+        await transmission.verifyTorrent(key);
+    });
+    it('should move in queue', async () => {
+        const transmission = new Transmission({ baseUrl });
+        const key = await setupTorrent(transmission);
+        await transmission.queueUp(key);
+        await transmission.queueDown(key);
+        await transmission.queueTop(key);
+        await transmission.queueBottom(key);
+    });
+    it('should report free space', async () => {
+        const transmission = new Transmission({ baseUrl });
+        const p = '/downloads';
+        const res = await transmission.freeSpace(p);
+        expect(res.result).toBe('success');
+        expect(res.arguments.path).toBe(p);
+        expect(typeof res.arguments['size-bytes']).toBe('number');
+    });
+    it('should add from url', async () => {
+        const transmission = new Transmission({ baseUrl });
+        const res = await transmission.addUrl('https://releases.ubuntu.com/20.10/ubuntu-20.10-desktop-amd64.iso.torrent');
+        expect(res.result).toBe('success');
+    });
+    it('should add torrent with normalized response', async () => {
+        const client = new Transmission({ baseUrl });
+        const torrent = await client.normalizedAddTorrent(fs.readFileSync(torrentFile), {
+            label: 'test',
+        });
+        expect(torrent.connectedPeers).toBe(0);
+        expect(torrent.connectedSeeds).toBe(0);
+        expect(torrent.downloadSpeed).toBe(0);
+        expect(torrent.eta).toBe(-1);
+        expect(torrent.isCompleted).toBe(false);
+        expect(torrent.label).toBe('test');
+        expect(torrent.name).toBe(torrentName);
+        expect(torrent.progress).toBeGreaterThanOrEqual(0);
+        expect(torrent.queuePosition).toBe(0);
+        // expect(torrent.ratio).toBe(0);
+        expect(torrent.savePath).toBe('/downloads');
+        expect(torrent.state).toBe(TorrentState.checking);
+        expect(torrent.stateMessage).toBe('');
+        expect(torrent.totalDownloaded).toBe(0);
+        expect(torrent.totalPeers).toBe(0);
+        expect(torrent.totalSeeds).toBe(0);
+        expect(torrent.totalSelected).toBe(1953349632);
+        // expect(torrent.totalSize).toBe(undefined);
+        expect(torrent.totalUploaded).toBe(0);
+        expect(torrent.uploadSpeed).toBe(0);
+    });
+});

package/dist/vitest.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/vitest.config.js

@@ -0,0 +1,7 @@
+// @ts-expect-error
+import { defineConfig } from 'vitest/config';
+export default defineConfig({
+    test: {
+        threads: false,
+    },
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ctrl/transmission",
-  "version": "2.5.0",
+  "version": "4.1.0",
   "description": "TypeScript api wrapper for transmission using got",
   "author": "Scott Cooper <scttcper@gmail.com>",
   "license": "MIT",
@@ -9,8 +9,9 @@
     "transmission",
     "typescript"
   ],
-  "main": "dist/index.js",
-  "typings": "dist/index.d.ts",
+  "type": "module",
+  "main": "./dist/src/index.js",
+  "typings": "./dist/src/index.d.ts",
   "files": [
     "dist"
   ],
@@ -19,48 +20,41 @@
     "lint": "eslint --ext .ts .",
     "lint:fix": "eslint --fix --ext .ts .",
     "prepare": "npm run build",
-    "build": "tsc -p tsconfig.build.json",
+    "build": "tsc",
     "build:docs": "typedoc",
-    "test": "jest --runInBand",
-    "test:watch": "jest --watch --runInBand",
-    "test:ci": "jest --ci --runInBand --reporters=default --reporters=jest-junit --coverage"
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:ci": "vitest run --coverage"
   },
   "dependencies": {
-    "@ctrl/shared-torrent": "^3.0.5",
-    "got": "^11.8.3",
-    "@ctrl/url-join": "^1.0.4"
+    "@ctrl/magnet-link": "^3.1.0",
+    "@ctrl/shared-torrent": "^4.1.1",
+    "@ctrl/url-join": "^2.0.0",
+    "got": "^12.1.0"
   },
   "devDependencies": {
-    "@babel/plugin-transform-modules-commonjs": "7.16.8",
-    "@babel/preset-typescript": "7.16.7",
-    "@ctrl/eslint-config": "3.3.1",
-    "@jest/globals": "27.4.6",
-    "@types/node": "17.0.14",
-    "jest": "27.4.7",
-    "jest-junit": "13.0.0",
-    "p-wait-for": "3.2.0",
-    "typedoc": "0.22.11",
-    "typescript": "4.5.5"
+    "@ctrl/eslint-config": "3.4.4",
+    "@sindresorhus/tsconfig": "3.0.1",
+    "@types/node": "17.0.38",
+    "c8": "7.11.3",
+    "p-wait-for": "4.1.0",
+    "typedoc": "0.22.17",
+    "typescript": "4.7.2",
+    "vitest": "0.13.1"
   },
   "jest": {
     "testEnvironment": "node",
     "coverageProvider": "v8"
   },
-  "babel": {
-    "presets": [
-      "@babel/preset-typescript"
-    ],
-    "plugins": [
-      "@babel/plugin-transform-modules-commonjs"
-    ]
-  },
   "publishConfig": {
     "access": "public"
   },
   "release": {
-    "branch": "master"
+    "branches": [
+      "master"
+    ]
   },
   "engines": {
-    "node": ">=10.19.0"
+    "node": ">=14.16"
   }
 }

package/dist/index.d.ts

@@ -1,2 +0,0 @@
-export * from './transmission';
-export * from './types';

package/dist/index.js

@@ -1,14 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./transmission"), exports);
-__exportStar(require("./types"), exports);

package/dist/types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });