@sebbo2002/node-pyatv 5.0.0 → 5.1.1-develop.1

package/package.json

@@ -15,23 +15,23 @@
     "@semantic-release/exec": "^6.0.3",
     "@semantic-release/git": "^10.0.1",
     "@types/mocha": "^9.1.1",
-    "@types/node": "^18.0.0",
-    "@types/semver": "^7.3.10",
-    "@typescript-eslint/eslint-plugin": "^5.30.5",
-    "@typescript-eslint/parser": "^5.30.5",
-    "c8": "^7.11.3",
-    "eslint": "^8.19.0",
-    "eslint-plugin-jsonc": "^2.3.1",
+    "@types/node": "^18.7.16",
+    "@types/semver": "^7.3.12",
+    "@typescript-eslint/eslint-plugin": "^5.36.2",
+    "@typescript-eslint/parser": "^5.36.2",
+    "c8": "^7.12.0",
+    "eslint": "^8.23.0",
+    "eslint-plugin-jsonc": "^2.4.0",
     "esm": "^3.2.25",
     "license-checker": "^25.0.1",
     "mocha": "^10.0.0",
     "mochawesome": "^7.1.3",
-    "semantic-release": "^19.0.3",
+    "semantic-release": "^19.0.5",
     "semantic-release-license": "^1.0.3",
     "source-map-support": "^0.5.21",
-    "ts-node": "^10.8.2",
-    "typedoc": "^0.23.5",
-    "typescript": "^4.7.4"
+    "ts-node": "^10.9.1",
+    "typedoc": "^0.23.14",
+    "typescript": "^4.8.2"
   },
   "engines": {
     "node": "^12.20.0 || >=14.13.1"
@@ -58,5 +58,5 @@
     "test": "mocha"
   },
   "type": "module",
-  "version": "5.0.0"
+  "version": "5.1.1-develop.1"
 }

package/src/lib/device.ts

@@ -10,6 +10,7 @@ import {
     NodePyATVMediaType,
     NodePyATVProtocol,
     NodePyATVRepeatState,
+    NodePyATVService,
     NodePyATVShuffleState,
     NodePyATVState
 } from './types.js';
@@ -74,6 +75,67 @@ export default class NodePyATVDevice implements EventEmitter{
         return this.options.protocol;
     }
 
+    /**
+     * Get the model identifier of the device. Only set, if the
+     * device was found using [[find()]]. Requires pyatv ≧ 0.10.3.
+     *
+     * @example device.model → "Gen4K"
+     */
+    get model(): string | undefined {
+        return this.options.model;
+    }
+
+    /**
+     * Get the model name of the device. Only set, if the device
+     * was found with [[find()]]. Requires pyatv ≧ 0.10.3.
+     *
+     * @example device.modelName → "Apple TV 4K"
+     */
+    get modelName(): string | undefined {
+        return this.options.modelName;
+    }
+
+    /**
+     * Get the operating system of the device. Only set, if the
+     * device was found with [[find()]]. Requires pyatv ≧ 0.10.3.
+     *
+     * @example device.os → "TvOS"
+     */
+    get os(): string | undefined {
+        return this.options.os;
+    }
+
+    /**
+     * Get the device version. Only set, if the device was found
+     * during a scan using [[find()]]. Requires pyatv ≧ 0.10.3.
+     *
+     * @example device.version → "15.5.1"
+     */
+    get version(): string | undefined {
+        return this.options.version;
+    }
+
+    /**
+     * Returns a list of services supported by the device. Ony set, if
+     * the device was found during a scan using [[find()]]. Requires
+     * pyatv ≧ 0.10.3.
+     *
+     * @example device.services → [
+     *   {
+     *     "protocol": "airplay",
+     *     "port": 7000
+     *   },
+     *   {
+     *     "protocol": "dmap",
+     *     "port": 3689
+     *   }
+     * ]
+     */
+    get services(): NodePyATVService[] | undefined {
+        return this.options.services;
+    }
+
+
     /**
      * Returns true, if debugging is enabled. Returns the custom
      * logging method, if one was specified. Otherwise, if debug

package/src/lib/index.ts

@@ -1,26 +1,29 @@
 'use strict';
 
 export {
-    NodePyATVProtocol,
-    NodePyATVMediaType,
+    NodePyATVDeviceOptions,
     NodePyATVDeviceState,
-    NodePyATVRepeatState,
-    NodePyATVShuffleState,
-    NodePyATVKeys,
-    NodePyATVInstanceOptions,
-    NodePyATVVersionResponse,
-    NodePyATVFindOptions,
+    NodePyATVEventValueType,
+    NodePyATVExecutableType,
     NodePyATVFindAndInstanceOptions,
-    NodePyATVDeviceOptions,
+    NodePyATVFindOptions,
     NodePyATVGetStateOptions,
-    NodePyATVState,
-    NodePyATVPowerState,
+    NodePyATVInstanceOptions,
+    NodePyATVKeys,
     NodePyATVListenerState,
-    NodePyATVEventValueType,
+    NodePyATVMediaType,
+    NodePyATVPowerState,
+    NodePyATVProtocol,
+    NodePyATVRepeatState,
+    NodePyATVService,
+    NodePyATVShuffleState,
+    NodePyATVState,
+    NodePyATVVersionResponse
 } from './types.js';
 
 export {default as NodePyATVDeviceEvent} from './device-event.js';
 export {default as NodePyATVDeviceEvents} from './device-events.js';
 export {default as NodePyATVDevice} from './device.js';
+export {default as NodePyATVInstance} from './instance.js';
 
 export {default} from './instance.js';

package/src/lib/instance.ts

@@ -10,6 +10,7 @@ import {
     NodePyATVExecutableType,
     NodePyATVFindAndInstanceOptions,
     NodePyATVInstanceOptions,
+    NodePyATVInternalScanDevice,
     NodePyATVVersionResponse
 } from './types.js';
 
@@ -117,11 +118,16 @@ export default class NodePyATVInstance {
             throw new Error(`Unable to parse pyatv response: ${JSON.stringify(result, null, '  ')}`);
         }
 
-        const objects = result.devices.map((device: { address: string, identifier: string, name: string }) =>
+        const objects = result.devices.map((device: NodePyATVInternalScanDevice) =>
             this.device(Object.assign({}, options, {
                 host: device.address,
                 id: device.identifier,
-                name: device.name
+                name: device.name,
+                model: device.device_info?.model,
+                modelName: device.device_info?.model_str,
+                os: device.device_info?.operating_system,
+                version: device.device_info?.version,
+                services: device.services
             }))
         );
 

package/src/lib/types.ts

@@ -147,12 +147,38 @@ export interface NodePyATVFindAndInstanceOptions extends NodePyATVInstanceOption
 export interface NodePyATVDeviceOptions extends NodePyATVFindAndInstanceOptions {
     host: string;
     name: string;
+    model?: string;
+    modelName?: string;
+    os?: string;
+    version?: string;
+    services?: NodePyATVService[];
 }
 
 export interface NodePyATVGetStateOptions {
     maxAge?: number;
 }
 
+export interface NodePyATVService {
+    protocol: NodePyATVProtocol;
+    port: number;
+}
+
+/**
+ * @internal
+ */
+export interface NodePyATVInternalScanDevice {
+    name: string;
+    address: string;
+    identifier: string;
+    device_info?: {
+        model: string;
+        model_str: string;
+        operating_system: string;
+        version: string;
+    };
+    services?: NodePyATVService[];
+}
+
 /**
  * @internal
  */

package/test/device.ts

@@ -11,7 +11,7 @@ import {
     NodePyATVShuffleState
 } from '../src/lib/types.js';
 import NodePyATVInstance from '../src/lib/instance.js';
-import {createFakeSpawn} from '../src/lib/fake-spawn.js';
+import { createFakeSpawn } from '../src/lib/fake-spawn.js';
 
 describe('NodePyATVDevice', function () {
     describe('get name()', function () {
@@ -60,6 +60,129 @@ describe('NodePyATVDevice', function () {
         });
     });
 
+    describe('get model()', function () {
+        it('should return the model if set by scan', function () {
+            const device = new NodePyATVDevice({
+                name: 'Vardagsrum',
+                host: '10.0.10.81',
+                id: 'xxx',
+                model: 'Gen4K'
+            });
+
+            assert.strictEqual(device.model, 'Gen4K');
+        });
+        it('should return undefined otherwise', function () {
+            const device = new NodePyATVDevice({
+                name: 'Vardagsrum',
+                host: '10.0.10.81'
+            });
+
+            assert.strictEqual(device.model, undefined);
+        });
+    });
+
+    describe('get modelName()', function () {
+        it('should return the model name if set by scan', function () {
+            const device = new NodePyATVDevice({
+                name: 'Vardagsrum',
+                host: '10.0.10.81',
+                id: 'xxx',
+                modelName: 'Apple TV 4K'
+            });
+
+            assert.strictEqual(device.modelName, 'Apple TV 4K');
+        });
+        it('should return undefined otherwise', function () {
+            const device = new NodePyATVDevice({
+                name: 'Vardagsrum',
+                host: '10.0.10.81'
+            });
+
+            assert.strictEqual(device.modelName, undefined);
+        });
+    });
+
+    describe('get os()', function () {
+        it('should return the operating system if set by scan', function () {
+            const device = new NodePyATVDevice({
+                name: 'Vardagsrum',
+                host: '10.0.10.81',
+                id: 'xxx',
+                os: 'TvOS'
+            });
+
+            assert.strictEqual(device.os, 'TvOS');
+        });
+        it('should return undefined otherwise', function () {
+            const device = new NodePyATVDevice({
+                name: 'Vardagsrum',
+                host: '10.0.10.81'
+            });
+
+            assert.strictEqual(device.os, undefined);
+        });
+    });
+
+    describe('get version()', function () {
+        it('should return the version if set by scan', function () {
+            const device = new NodePyATVDevice({
+                name: 'Vardagsrum',
+                host: '10.0.10.81',
+                id: 'xxx',
+                version: '15.5.1'
+            });
+
+            assert.strictEqual(device.version, '15.5.1');
+        });
+        it('should return undefined otherwise', function () {
+            const device = new NodePyATVDevice({
+                name: 'Vardagsrum',
+                host: '10.0.10.81'
+            });
+
+            assert.strictEqual(device.version, undefined);
+        });
+    });
+
+    describe('get services()', function () {
+        it('should return the services if set by scan', function () {
+            const device = new NodePyATVDevice({
+                name: 'Vardagsrum',
+                host: '10.0.10.81',
+                id: 'xxx',
+                services: [
+                    {
+                        protocol: NodePyATVProtocol.mrp,
+                        port: 49152
+                    },
+                    {
+                        protocol: NodePyATVProtocol.airplay,
+                        port: 7000
+                    }
+                ]
+            });
+
+            assert.deepStrictEqual(device.services, [
+                {
+                    protocol: 'mrp',
+                    port: 49152
+                },
+                {
+                    protocol: 'airplay',
+                    port: 7000
+                }
+            ]);
+        });
+        it('should return undefined otherwise', function () {
+            const device = new NodePyATVDevice({
+                name: 'Vardagsrum',
+                host: '10.0.10.81'
+            });
+
+            assert.strictEqual(device.services, undefined);
+        });
+    });
+
     describe('get debug()', function () {
         it('should return true if set to true', function () {
             const device = new NodePyATVDevice({

package/test/instance.ts

@@ -7,15 +7,15 @@ import { fileURLToPath } from 'url';
 
 import { createFakeSpawn } from '../src/lib/fake-spawn.js';
 import NodePyATVInstance, {
-    NodePyATVProtocol,
-    NodePyATVMediaType,
     NodePyATVDeviceEvent,
     NodePyATVDeviceState,
-    NodePyATVRepeatState,
-    NodePyATVShuffleState,
     NodePyATVKeys,
     NodePyATVListenerState,
-    NodePyATVPowerState
+    NodePyATVMediaType,
+    NodePyATVPowerState,
+    NodePyATVProtocol,
+    NodePyATVRepeatState,
+    NodePyATVShuffleState
 } from '../src/lib/index.js';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -257,6 +257,85 @@ describe('NodePyATVInstance', function () {
                 });
             }, /Unable to parse pyatv response: /);
         });
+        it('should work if devices are without device_info / services', async function () {
+            const devices = await NodePyATVInstance.find({
+                spawn: createFakeSpawn(cp => {
+                    cp.stdout({
+                        result: 'success',
+                        datetime: '2020-11-06T20:47:30.840022+01:00',
+                        devices: [
+                            {
+                                name: 'Vardagsrum',
+                                address: '10.0.10.81',
+                                identifier: 'xxx'
+                            }
+                        ]
+                    }).code(1).end();
+                })
+            });
+
+            assert.strictEqual(devices.length, 1);
+            assert.strictEqual(devices[0].name, 'Vardagsrum');
+            assert.strictEqual(devices[0].host, '10.0.10.81');
+            assert.strictEqual(devices[0].id, 'xxx');
+            assert.strictEqual(devices[0].model, undefined);
+            assert.strictEqual(devices[0].modelName, undefined);
+            assert.strictEqual(devices[0].os, undefined);
+            assert.strictEqual(devices[0].version, undefined);
+            assert.deepStrictEqual(devices[0].services, undefined);
+        });
+        it('should work if devices are with device_info / services', async function () {
+            const devices = await NodePyATVInstance.find({
+                spawn: createFakeSpawn(cp => {
+                    cp.stdout({
+                        result: 'success',
+                        datetime: '2020-11-06T20:47:30.840022+01:00',
+                        devices: [
+                            {
+                                name: 'Vardagsrum',
+                                address: '10.0.10.81',
+                                identifier: 'xxx',
+                                device_info: {
+                                    'model': 'Gen4K',
+                                    'model_str': 'Apple TV 4K',
+                                    'operating_system': 'TvOS',
+                                    'version': '15.5.1'
+                                },
+                                services: [
+                                    {
+                                        protocol: 'mrp',
+                                        port: 49152
+                                    },
+                                    {
+                                        protocol: 'airplay',
+                                        port: 7000
+                                    }
+                                ]
+                            }
+                        ]
+                    }).code(1).end();
+                })
+            });
+
+            assert.strictEqual(devices.length, 1);
+            assert.strictEqual(devices[0].name, 'Vardagsrum');
+            assert.strictEqual(devices[0].host, '10.0.10.81');
+            assert.strictEqual(devices[0].id, 'xxx');
+            assert.strictEqual(devices[0].model, 'Gen4K');
+            assert.strictEqual(devices[0].modelName, 'Apple TV 4K');
+            assert.strictEqual(devices[0].os, 'TvOS');
+            assert.strictEqual(devices[0].version, '15.5.1');
+            assert.deepStrictEqual(devices[0].services, [
+                {
+                    protocol: NodePyATVProtocol.mrp,
+                    port: 49152
+                },
+                {
+                    protocol: NodePyATVProtocol.airplay,
+                    port: 7000
+                }
+            ]);
+        });
     });
 
     describe('static device()', function () {