@ctrl/plex 1.5.3 → 2.0.0

package/dist/src/playlist.d.ts

@@ -0,0 +1,75 @@
+import { Playable } from './base/playable.js';
+import type { Section } from './library.js';
+import { PlaylistResponse } from './playlist.types.js';
+import type { PlexServer } from './server.js';
+import { Episode, Movie, VideoType } from './video.js';
+interface CreateRegularPlaylistOptions {
+    /** True to create a smart playlist */
+    smart?: false;
+    /** Regular playlists only */
+    items?: VideoType[];
+}
+interface CreateSmartPlaylistOptions {
+    /** True to create a smart playlist */
+    smart: true;
+    /** Smart playlists only, the library section to create the playlist in. */
+    section?: Section;
+    /** Smart playlists only, limit the number of items in the playlist. */
+    limit?: number;
+    /**
+     * Smart playlists only, a string of comma separated sort fields
+     * or a list of sort fields in the format ``column:dir``.
+     * See {@link Section.search}  for more info.
+     */
+    sort?: string;
+    /**
+     * Smart playlists only, a dictionary of advanced filters.
+     * See {@link Section.search}  for more info.
+     */
+    filters?: Record<string, any>;
+}
+type CreatePlaylistOptions = CreateRegularPlaylistOptions | CreateSmartPlaylistOptions;
+type PlaylistContent = Episode | Movie;
+export declare class Playlist extends Playable {
+    static TAG: string;
+    static create(server: PlexServer, title: string, options: CreatePlaylistOptions): Promise<Playlist>;
+    /** Create a smart playlist. */
+    private static _create;
+    TYPE: string;
+    addedAt: Date;
+    updatedAt: Date;
+    composite: string;
+    guid: string;
+    leafCount: number;
+    playlistType: string;
+    smart: boolean;
+    summary: string;
+    allowSync?: boolean;
+    duration?: number;
+    durationInSeconds?: number;
+    /** Cache of playlist items */
+    private _items;
+    _edit(args: {
+        title?: string;
+        summary?: string;
+    }): Promise<void>;
+    edit(changeObj: {
+        title?: string;
+        summary?: string;
+    }): Promise<void>;
+    /**
+     * @returns the item in the playlist that matches the specified title.
+     */
+    item(title: string): Promise<PlaylistContent | null>;
+    items(): Promise<PlaylistContent[]>;
+    /** Add items to a playlist. */
+    addItems(items: PlaylistContent[]): Promise<void>;
+    /** Remove an item from a playlist. */
+    removeItems(items: PlaylistContent[]): Promise<void>;
+    /** Delete the playlist. */
+    delete(): Promise<void>;
+    protected _loadData(data: PlaylistResponse): void;
+    protected _loadFullData(data: any): void;
+    private _getPlaylistItemID;
+}
+export {};

package/dist/src/playlist.js

@@ -0,0 +1,142 @@
+import { URLSearchParams } from 'url';
+import { Playable } from './base/playable.js';
+import { fetchItems } from './baseFunctionality.js';
+import { BadRequest, NotFound } from './exceptions.js';
+import { Episode, Movie } from './video.js';
+/**
+ * Map media types to their respective class
+ */
+function contentClass(data) {
+    switch (data.type) {
+        case 'episode':
+            return Episode;
+        case 'movie':
+            return Movie;
+        default:
+            throw new Error('Media type not implemented');
+    }
+}
+export class Playlist extends Playable {
+    constructor() {
+        super(...arguments);
+        this.TYPE = 'playlist';
+        /** Cache of playlist items */
+        this._items = null;
+    }
+    static { this.TAG = 'Playlist'; }
+    static async create(server, title, options) {
+        if (options.smart) {
+            throw new Error('not yet supported');
+            // return this._createSmart(server, title, options);
+        }
+        return this._create(server, title, options.items);
+    }
+    /** Create a smart playlist. */
+    // private static _createSmart(server: PlexServer, title: string, options: CreatePlaylistOptions) {}
+    static async _create(server, title, items) {
+        if (!items || items.length === 0) {
+            throw new BadRequest('Must include items to add when creating new playlist.');
+        }
+        const { listType } = items[0];
+        const ratingKeys = items ? items.map(x => x.ratingKey) : [];
+        const uri = `${server._uriRoot()}/library/metadata/${ratingKeys.join(',')}`;
+        const params = new URLSearchParams({
+            uri,
+            type: listType,
+            title,
+            smart: '0',
+        });
+        const key = `/playlists?${params.toString()}`;
+        const data = await server.query(key, 'post');
+        return new Playlist(server, data.MediaContainer.Metadata[0], key);
+    }
+    async _edit(args) {
+        const searchparams = new URLSearchParams(args);
+        const key = `${this.key}?${searchparams.toString()}`;
+        await this.server.query(key, 'put');
+    }
+    async edit(changeObj) {
+        await this._edit(changeObj);
+    }
+    /**
+     * @returns the item in the playlist that matches the specified title.
+     */
+    async item(title) {
+        const items = await this.items();
+        const matched = items.find(item => item.title.toLowerCase() === title.toLowerCase());
+        return matched ?? null;
+    }
+    async items() {
+        if (this._items === null) {
+            const key = `/playlists/${this.ratingKey}/items`;
+            const items = await fetchItems(this.server, key);
+            this._items = items.map(data => {
+                const Cls = contentClass(data);
+                return new Cls(this.server, data, key, this);
+            });
+        }
+        return this._items;
+    }
+    /** Add items to a playlist. */
+    async addItems(items) {
+        if (this.smart) {
+            throw new BadRequest('Cannot add items to a smart playlist.');
+        }
+        const isInvalidType = items.some(x => x.listType !== this.playlistType);
+        if (isInvalidType) {
+            throw new BadRequest('Can not mix media types when building a playlist');
+        }
+        const ratingKeys = items.map(x => x.ratingKey);
+        const params = new URLSearchParams({
+            uri: `${this.server._uriRoot()}/library/metadata/${ratingKeys.join(',')}`,
+        });
+        const key = `${this.key}/items?${params.toString()}`;
+        await this.server.query(key, 'put');
+    }
+    /** Remove an item from a playlist. */
+    async removeItems(items) {
+        if (this.smart) {
+            throw new BadRequest('Cannot remove items to a smart playlist.');
+        }
+        for (const item of items) {
+            // eslint-disable-next-line no-await-in-loop
+            const playlistItemId = await this._getPlaylistItemID(item);
+            const key = `${this.key}/items/${playlistItemId}`;
+            // eslint-disable-next-line no-await-in-loop
+            await this.server.query(key, 'delete');
+        }
+    }
+    /** Delete the playlist. */
+    async delete() {
+        await this.server.query(this.key, 'delete');
+    }
+    _loadData(data) {
+        this.key = data.key.replace('/items', '');
+        this.ratingKey = data.ratingKey;
+        this.title = data.title;
+        this.type = data.type;
+        this.addedAt = new Date(data.addedAt);
+        this.updatedAt = new Date(data.updatedAt);
+        this.composite = data.composite;
+        this.guid = data.guid;
+        this.playlistType = data.playlistType;
+        this.summary = data.summary;
+        this.smart = data.smart;
+        this.leafCount = data.leafCount;
+        // TODO: verify these. Possibly audio playlist related
+        this.allowSync = data.allowSync;
+        this.duration = data.duration;
+        this.durationInSeconds = data.durationInSeconds;
+    }
+    _loadFullData(data) {
+        this._loadData(data.Metadata[0]);
+    }
+    async _getPlaylistItemID(item) {
+        const items = await this.items();
+        const playlistItem = items.find(i => i.ratingKey === item.ratingKey);
+        if (!playlistItem) {
+            throw new NotFound(`Item with title "${item.title}" not found in the playlist`);
+        }
+        return playlistItem.playlistItemID;
+    }
+}

package/dist/src/playlist.types.d.ts

@@ -0,0 +1,17 @@
+export interface PlaylistResponse {
+    ratingKey: string;
+    key: string;
+    guid: string;
+    type: string;
+    title: string;
+    summary: string;
+    smart: boolean;
+    playlistType: string;
+    composite: string;
+    leafCount: number;
+    addedAt: number;
+    updatedAt: number;
+    allowSync?: boolean;
+    duration?: number;
+    durationInSeconds?: number;
+}

package/dist/src/playlist.types.js

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

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

@@ -1,6 +1,6 @@
 import { ValueOf } from 'type-fest';
-import { PlexObject } from './base/plexObject';
-import { MatchSearchResult } from './search.types';
+import { PlexObject } from './base/plexObject.js';
+import { MatchSearchResult } from './search.types.js';
 export declare class SearchResult extends PlexObject {
     static TAG: string;
     guid: string;
@@ -41,9 +41,10 @@ export declare const SEARCHTYPES: {
     readonly playlist: 15;
     readonly playlistFolder: 16;
     readonly collection: 18;
+    readonly optimizedVersion: 42;
     readonly userPlaylistItem: 1001;
 };
-declare type SearchTypesValues = ValueOf<typeof SEARCHTYPES>;
+type SearchTypesValues = ValueOf<typeof SEARCHTYPES>;
 /**
  * Returns the integer value of the library string type.
  * @param libtype to lookup (movie, show, season, episode, artist, album, track, collection)

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

@@ -1,9 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.searchType = exports.SEARCHTYPES = exports.Agent = exports.SearchResult = void 0;
-const plexObject_1 = require("./base/plexObject");
-const util_1 = require("./util");
-class SearchResult extends plexObject_1.PlexObject {
+import { PlexObject } from './base/plexObject.js';
+import { rsplit } from './util.js';
+export class SearchResult extends PlexObject {
+    static { this.TAG = 'SearchResult'; }
     _loadData(data) {
         this.guid = data.guid;
         this.lifespanEnded = data.lifespanEnded;
@@ -12,19 +10,18 @@ class SearchResult extends plexObject_1.PlexObject {
         this.year = data.year;
     }
 }
-exports.SearchResult = SearchResult;
-SearchResult.TAG = 'SearchResult';
 /**
  * Represents a single Agent
  */
-class Agent extends plexObject_1.PlexObject {
+export class Agent extends PlexObject {
+    static { this.TAG = 'Agent'; }
     // languageCode: any[] = [];
     _loadData(data) {
         this.hasAttribution = data.hasAttribution;
         this.hasPrefs = data.hasPrefs;
         this.identifier = data.identifier;
         this.primary = data.primary;
-        this.shortIdentifier = util_1.rsplit(this.identifier, '.', 1)[1];
+        this.shortIdentifier = rsplit(this.identifier, '.', 1)[1];
         if (this.initpath.includes('mediaType')) {
             this.name = data.name;
             // this.languageCode = [];
@@ -32,9 +29,7 @@ class Agent extends plexObject_1.PlexObject {
         }
     }
 }
-exports.Agent = Agent;
-Agent.TAG = 'Agent';
-exports.SEARCHTYPES = {
+export const SEARCHTYPES = {
     movie: 1,
     show: 2,
     season: 3,
@@ -52,23 +47,22 @@ exports.SEARCHTYPES = {
     playlist: 15,
     playlistFolder: 16,
     collection: 18,
+    optimizedVersion: 42,
     userPlaylistItem: 1001,
 };
 /**
  * Returns the integer value of the library string type.
  * @param libtype to lookup (movie, show, season, episode, artist, album, track, collection)
  */
-function searchType(libtype) {
+export function searchType(libtype) {
     if (libtype &&
-        Object.values(exports.SEARCHTYPES)
+        Object.values(SEARCHTYPES)
             .map(num => num.toString())
             .includes(`${libtype}`)) {
         return Number(libtype);
     }
-    if (libtype && exports.SEARCHTYPES[libtype] !== undefined) {
-        return exports.SEARCHTYPES[libtype];
+    if (libtype && SEARCHTYPES[libtype] !== undefined) {
+        return SEARCHTYPES[libtype];
     }
-    // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
     throw new Error(`Unknown libtype: ${libtype}`);
 }
-exports.searchType = searchType;

package/dist/src/search.types.js

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

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

@@ -1,11 +1,12 @@
-/// <reference types="node" />
+/// <reference types="node" resolution-mode="require"/>
 import { URL, URLSearchParams } from 'url';
-import { HistoryMetadatum } from './server.types';
-import { Library, Hub } from './library';
-import { Optimized } from './media';
-import { Agent, SEARCHTYPES } from './search';
-import { PlexClient } from './client';
-import { MyPlexAccount } from './myplex';
+import { PlexClient } from './client.js';
+import { Hub, Library } from './library.js';
+import { Optimized } from './media.js';
+import { MyPlexAccount } from './myplex.js';
+import { Agent, SEARCHTYPES } from './search.js';
+import { HistoryMetadatum } from './server.types.js';
+import { Settings } from './settings.js';
 /**
  * This is the main entry point to interacting with a Plex server. It allows you to
  * list connected clients, browse your library sections and perform actions such as
@@ -16,7 +17,7 @@ import { MyPlexAccount } from './myplex';
 export declare class PlexServer {
     readonly baseurl: string;
     readonly token: string;
-    readonly timeout?: number | undefined;
+    readonly timeout?: number;
     key: string;
     /** True if server allows camera upload */
     allowCameraUpload: boolean;
@@ -51,7 +52,7 @@ export declare class PlexServer {
      */
     hubSearch: boolean;
     /** Unique ID for this server (looks like an md5) */
-    machineIdentifier: string;
+    machineIdentifier?: string;
     /**
      * True if `multiusers <https!://support.plex.tv/hc/en-us/articles/200250367-Multi-User-Support>`_ are enabled.
      */
@@ -128,8 +129,9 @@ export declare class PlexServer {
     /** Unknown */
     pushNotifications: boolean;
     _library?: Library;
+    _settings?: Settings;
     private _myPlexAccount?;
-    constructor(baseurl: string, token: string, timeout?: number | undefined);
+    constructor(baseurl: string, token: string, timeout?: number);
     agents(mediaType?: number | string): Promise<Agent[]>;
     connect(): Promise<void>;
     /**
@@ -175,6 +177,7 @@ export declare class PlexServer {
      * @param librarySectionId request history for a specific library section ID.
      */
     history(maxresults?: number, mindate?: Date, ratingKey?: number | string, accountId?: number | string, librarySectionId?: number | string): Promise<HistoryMetadatum[]>;
+    settings(): Promise<Settings>;
     /**
      * Returns a :class:`~plexapi.myplex.MyPlexAccount` object using the same
      * token to access this server. If you are not the owner of this PlexServer
@@ -189,6 +192,15 @@ export declare class PlexServer {
      * if either includeToken is True or TODO: CONFIG.log.show_secrets is 'true'.
      */
     url(key: string, includeToken?: boolean, params?: URLSearchParams): URL;
+    /**
+     * Build the Plex Web URL for the object.
+     * @param base The base URL before the fragment (``#!``).
+     *    Default is https://app.plex.tv/desktop.
+     * @param endpoint The Plex Web URL endpoint.
+     *    None for server, 'playlist' for playlists, 'details' for all other media types.
+     */
+    _buildWebURL(base?: string, endpoint?: string, params?: URLSearchParams): string;
+    _uriRoot(): string;
     private _headers;
     private _loadData;
     /**

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

@@ -1,18 +1,13 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PlexServer = void 0;
-const got_1 = __importDefault(require("got"));
-const url_1 = require("url");
-const config_1 = require("./config");
-const library_1 = require("./library");
-const baseFunctionality_1 = require("./baseFunctionality");
-const media_1 = require("./media");
-const search_1 = require("./search");
-const client_1 = require("./client");
-const myplex_1 = require("./myplex");
+import { URL, URLSearchParams } from 'url';
+import got from 'got';
+import { fetchItem, fetchItems } from './baseFunctionality.js';
+import { PlexClient } from './client.js';
+import { BASE_HEADERS, TIMEOUT, X_PLEX_CONTAINER_SIZE } from './config.js';
+import { Hub, Library } from './library.js';
+import { Optimized } from './media.js';
+import { MyPlexAccount } from './myplex.js';
+import { Agent, SEARCHTYPES } from './search.js';
+import { Settings } from './settings.js';
 /**
  * This is the main entry point to interacting with a Plex server. It allows you to
  * list connected clients, browse your library sections and perform actions such as
@@ -20,7 +15,7 @@ const myplex_1 = require("./myplex");
  * server, or simply want to access your server with your username and password, you
  * can also create an PlexServer instance from :class:`~plexapi.myplex.MyPlexAccount`.
  */
-class PlexServer {
+export class PlexServer {
     constructor(baseurl, token, timeout) {
         this.baseurl = baseurl;
         this.token = token;
@@ -32,7 +27,7 @@ class PlexServer {
         if (mediaType) {
             key += `?mediaType=${mediaType}`;
         }
-        return baseFunctionality_1.fetchItems(this, key, undefined, search_1.Agent, this);
+        return fetchItems(this, key, undefined, Agent, this);
     }
     async connect() {
         const data = await this.query(this.key, undefined, undefined, this.timeout);
@@ -53,13 +48,13 @@ class PlexServer {
             return this._library;
         }
         try {
-            const data = await this.query(library_1.Library.key);
-            this._library = new library_1.Library(this, data.MediaContainer);
+            const data = await this.query(Library.key);
+            this._library = new Library(this, data.MediaContainer);
         }
-        catch (_a) {
+        catch {
             // TODO: validate error type, also TODO figure out how this is used
             const data = await this.query('/library/sections/');
-            this._library = new library_1.Library(this, data.MediaContainer);
+            this._library = new Library(this, data.MediaContainer);
         }
         return this._library;
     }
@@ -81,13 +76,13 @@ class PlexServer {
     async search(query, mediatype, limit) {
         const params = { query };
         if (mediatype) {
-            params.section = search_1.SEARCHTYPES[mediatype].toString();
+            params.section = SEARCHTYPES[mediatype].toString();
         }
         if (limit) {
             params.limit = limit.toString();
         }
-        const key = '/hubs/search?' + new url_1.URLSearchParams(params).toString();
-        const hubs = await baseFunctionality_1.fetchItems(this, key, undefined, library_1.Hub, this);
+        const key = '/hubs/search?' + new URLSearchParams(params).toString();
+        const hubs = await fetchItems(this, key, undefined, Hub, this);
         return hubs;
     }
     /**
@@ -107,14 +102,14 @@ class PlexServer {
             requestHeaders.Authorization = `Basic ${credentials}`;
         }
         const url = this.url(path);
-        const response = await got_1.default({
+        const response = await got({
             method,
             url,
             headers: requestHeaders,
-            timeout: timeout !== null && timeout !== void 0 ? timeout : config_1.TIMEOUT,
-            username,
-            password,
-            retry: 0,
+            timeout: { request: timeout ?? TIMEOUT },
+            ...(username ? { username } : {}),
+            ...(password ? { password } : {}),
+            retry: { limit: 0 },
         }).json();
         return response;
     }
@@ -144,23 +139,30 @@ class PlexServer {
             args['viewedAt>'] = mindate.getTime().toString();
         }
         args['X-Plex-Container-Start'] = '0';
-        args['X-Plex-Container-Size'] = Math.min(config_1.X_PLEX_CONTAINER_SIZE, maxresults).toString();
+        args['X-Plex-Container-Size'] = Math.min(X_PLEX_CONTAINER_SIZE, maxresults).toString();
         let results = [];
-        let key = '/status/sessions/history/all?' + new url_1.URLSearchParams(args).toString();
+        let key = '/status/sessions/history/all?' + new URLSearchParams(args).toString();
         let raw = await this.query(key);
         const totalResults = raw.MediaContainer.totalSize;
         results = results.concat(raw.MediaContainer.Metadata);
         while (results.length <= totalResults &&
-            config_1.X_PLEX_CONTAINER_SIZE === raw.MediaContainer.size &&
+            X_PLEX_CONTAINER_SIZE === raw.MediaContainer.size &&
             maxresults > results.length) {
             args['X-Plex-Container-Start'] = (Number(args['X-Plex-Container-Start']) + Number(args['X-Plex-Container-Size'])).toString();
-            key = '/status/sessions/history/all?' + new url_1.URLSearchParams(args).toString();
+            key = '/status/sessions/history/all?' + new URLSearchParams(args).toString();
             // eslint-disable-next-line no-await-in-loop
             raw = await this.query(key);
             results = results.concat(raw.MediaContainer.Metadata);
         }
         return results;
     }
+    async settings() {
+        if (!this._settings) {
+            const data = await this.query(Settings.key);
+            this._settings = new Settings(this, data.MediaContainer.Setting);
+        }
+        return this._settings;
+    }
     // TODO: not sure if this works
     // /**
     //  * Returns a list of all playlist objects saved on the server.
@@ -178,38 +180,37 @@ class PlexServer {
      */
     myPlexAccount() {
         if (!this._myPlexAccount) {
-            this._myPlexAccount = new myplex_1.MyPlexAccount(this.baseurl, undefined, undefined, this.token, this.timeout, this);
+            this._myPlexAccount = new MyPlexAccount(this.baseurl, undefined, undefined, this.token, this.timeout, this);
         }
         return this._myPlexAccount;
     }
     // Returns list of all :class:`~plexapi.client.PlexClient` objects connected to server.
     async clients() {
-        var _a, _b;
         const items = [];
         const response = await this.query('/clients');
-        if (((_a = response.MediaContainer) === null || _a === void 0 ? void 0 : _a.Server) === undefined) {
+        if (response.MediaContainer?.Server === undefined) {
             return [];
         }
         const shouldFetchPorts = response.MediaContainer.Server.some(server => server.port === null || server.port === undefined);
-        let ports;
+        let ports = {};
         if (shouldFetchPorts) {
             ports = await this._myPlexClientPorts();
         }
         for (const server of response.MediaContainer.Server) {
-            let port = server.port;
+            let { port } = server;
             if (!port) {
                 // TODO: print warning about doing weird port stuff
-                port = (_b = ports) === null || _b === void 0 ? void 0 : _b[server.machineIdentifier];
+                port = Number(ports?.[server.machineIdentifier]);
             }
             const baseurl = `http://${server.host}:${port}`;
-            items.push(new client_1.PlexClient({ baseurl, token: this.token, server: this, data: server }));
+            items.push(new PlexClient({ baseurl, token: this.token, server: this, data: server }));
         }
         return items;
     }
     /** Returns list of all :class:`~plexapi.media.Optimized` objects connected to server. */
     async optimizedItems() {
-        const backgroundProcessing = await baseFunctionality_1.fetchItem(this, '/playlists?type=42');
-        const items = await baseFunctionality_1.fetchItems(this, backgroundProcessing.key, undefined, media_1.Optimized, this);
+        const backgroundProcessing = await fetchItem(this, '/playlists?type=42');
+        const items = await fetchItems(this, backgroundProcessing.key, undefined, Optimized, this);
         return items;
     }
     /**
@@ -220,18 +221,34 @@ class PlexServer {
         if (!this.baseurl) {
             throw new Error('PlexClient object missing baseurl.');
         }
-        const url = new url_1.URL(key, this.baseurl);
+        const url = new URL(key, this.baseurl);
         if (this.token && includeToken) {
-            const searchParams = new url_1.URLSearchParams(params);
+            const searchParams = new URLSearchParams(params);
             searchParams.append('X-Plex-Token', this.token);
             url.search = searchParams.toString();
             return url;
         }
         return url;
     }
+    /**
+     * Build the Plex Web URL for the object.
+     * @param base The base URL before the fragment (``#!``).
+     *    Default is https://app.plex.tv/desktop.
+     * @param endpoint The Plex Web URL endpoint.
+     *    None for server, 'playlist' for playlists, 'details' for all other media types.
+     */
+    _buildWebURL(base = 'https://app.plex.tv/desktop/', endpoint, params) {
+        if (endpoint) {
+            return `${base}#!/server/${this.machineIdentifier}/${endpoint}?${params?.toString()}`;
+        }
+        return `${base}#!/media/${this.machineIdentifier}/com.plexapp.plugins.library?${params?.toString()}`;
+    }
+    _uriRoot() {
+        return `server://${this.machineIdentifier}/com.plexapp.plugins.library`;
+    }
     _headers() {
         const headers = {
-            ...config_1.BASE_HEADERS,
+            ...BASE_HEADERS,
             'Content-type': 'application/json',
         };
         if (this.token) {
@@ -292,16 +309,14 @@ class PlexServer {
      * See python plex issue #126: Make PlexServer.clients() more user friendly.
      */
     async _myPlexClientPorts() {
-        var _a;
-        let ports = {};
+        const ports = {};
         const account = this.myPlexAccount();
         const devices = await account.devices();
         for (const device of devices) {
-            if ((_a = device.connections) === null || _a === void 0 ? void 0 : _a.length) {
-                ports[device.clientIdentifier] = new url_1.URL('http://172.17.0.2:32400').port;
+            if (device.connections?.length) {
+                ports[device.clientIdentifier] = new URL('http://172.17.0.2:32400').port;
             }
         }
         return ports;
     }
 }
-exports.PlexServer = PlexServer;

package/dist/src/server.types.js

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