@sebbo2002/node-pyatv 6.0.0-develop.1 → 6.0.0-develop.3

package/src/lib/fake-spawn.ts

@@ -1,121 +0,0 @@
-import {SpawnOptions} from 'child_process';
-import {EventEmitter} from 'events';
-
-/**
- * @internal
- */
-export function createFakeSpawn(callback: ((cp: FakeChildProcessController) => void)): (
-    command: string,
-    args: ReadonlyArray<string>,
-    options: SpawnOptions
-) => FakeChildProcess {
-    return (command: string, args: ReadonlyArray<string>, options: SpawnOptions) => new FakeChildProcess(
-        command,
-        args,
-        options,
-        callback
-    );
-}
-
-/**
- * @internal
- */
-export class FakeChildProcessStdIn extends EventEmitter {
-    write (data: string): void {
-        this.emit('data', Buffer.from(data));
-    }
-}
-
-/**
- * @internal
- */
-export class FakeChildProcess extends EventEmitter {
-    cmd: string;
-    args: ReadonlyArray<string>;
-    timeout: NodeJS.Timeout | undefined;
-    stdout: EventEmitter;
-    stderr: EventEmitter;
-    stdin: FakeChildProcessStdIn;
-
-    constructor(command: string, args: ReadonlyArray<string>, options: SpawnOptions, callback: (cp: FakeChildProcessController) => void) {
-        super();
-
-        this.cmd = command;
-        this.args = args;
-        this.timeout = setTimeout(() => {
-            console.error(new Error(`FakeSpawn: Timeout for ${this.cmd} ${this.args.join(' ')}!`));
-        }, 5000);
-
-        this.stdout = new EventEmitter();
-        this.stderr = new EventEmitter();
-        this.stdin = new FakeChildProcessStdIn();
-
-        const controller = new FakeChildProcessController(this);
-        setTimeout(() => callback(controller), 0);
-    }
-
-    kill(): void {
-        this.emit('close', 0);
-        if(this.timeout !== undefined) {
-            clearTimeout(this.timeout);
-            this.timeout = undefined;
-        }
-    }
-}
-
-/**
- * @internal
- */
-export class FakeChildProcessController {
-    _cp: FakeChildProcess;
-    _code: number | null;
-
-    constructor(cp: FakeChildProcess) {
-        this._cp = cp;
-        this._code = null;
-    }
-
-    cmd(): string {
-        return this._cp.cmd;
-    }
-
-    stdout(content: string | Record<string, unknown>): this {
-        this._cp.stdout.emit('data', typeof content === 'string' ? content : JSON.stringify(content));
-        return this;
-    }
-
-    stderr(content: string): this {
-        this._cp.stderr.emit('data', content);
-        return this;
-    }
-
-    // eslint-disable-next-line
-    onStdIn(listener: (...args: any[]) => void): this {
-        this._cp.stdin.on('data', listener);
-        return this;
-    }
-
-    error(error: Error): this {
-        this._cp.emit('error', error);
-        return this;
-    }
-
-    code(exitCode: number): this {
-        this._code = exitCode;
-        return this;
-    }
-
-    end(content?: string | Record<string, unknown>): this {
-        if (content !== undefined) {
-            this.stdout(content);
-        }
-
-        this._cp.emit('close', this._code || 0);
-        if(this._cp.timeout !== undefined) {
-            clearTimeout(this._cp.timeout);
-            this._cp.timeout = undefined;
-        }
-
-        return this;
-    }
-}

package/src/lib/index.ts

@@ -1,29 +0,0 @@
-'use strict';
-
-export {
-    NodePyATVDeviceOptions,
-    NodePyATVDeviceState,
-    NodePyATVEventValueType,
-    NodePyATVExecutableType,
-    NodePyATVFindAndInstanceOptions,
-    NodePyATVFindOptions,
-    NodePyATVGetStateOptions,
-    NodePyATVInstanceOptions,
-    NodePyATVKeys,
-    NodePyATVListenerState,
-    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

@@ -1,211 +0,0 @@
-'use strict';
-
-import semver from 'semver';
-import { dirname } from 'path';
-import { fileURLToPath } from 'url';
-import { promises as fsPromises } from 'fs';
-
-import {
-    NodePyATVDeviceOptions,
-    NodePyATVExecutableType,
-    NodePyATVFindAndInstanceOptions,
-    NodePyATVInstanceOptions,
-    NodePyATVInternalScanDevice,
-    NodePyATVVersionResponse
-} from './types.js';
-
-import { addRequestId, debug, getParamters, removeRequestId, request } from './tools.js';
-import { NodePyATVDevice } from '../lib/index.js';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-/**
- * Default class exported by `@sebbo2002/node-pyatv`. Use [[find]] to scan for devices in your local network. Use
- * [[device]] to connect to a known device by passing (at least) it's name and IP.
- *
- * ```typescript
- * import pyatv from '@sebbo2002/node-pyatv';
- * ```
- */
-export default class NodePyATVInstance {
-    private readonly options: NodePyATVInstanceOptions = {};
-
-    /**
-     * Checks if pyatv is installed and ready to be used.
-     * Will throw an error if not.
-     *
-     * @param options
-     */
-    public static async check (options: NodePyATVInstanceOptions = {}): Promise<void> {
-        const versions = await this.version(options);
-        if (!versions.pyatv) {
-            throw new Error('Unable to find pyatv. Is it installed?');
-        }
-        if (semver.lt(versions.pyatv, '0.6.0')) {
-            throw new Error('Found pyatv, but unforunately it\'s too old. Please update pyatv.');
-        }
-
-        try {
-            await this.find(options);
-        } catch (error) {
-            throw new Error(`Unable to scan for devices: ${String(error).replace('Error: ', '')}`);
-        }
-    }
-
-    /**
-     * Resolves with the version of pyatv and of the module itself.
-     * If a value can't be found, null is returned instead.
-     *
-     * @param options
-     */
-    public static async version (options: NodePyATVInstanceOptions = {}): Promise<NodePyATVVersionResponse> {
-        const id = addRequestId();
-        let pyatv = null;
-        let module = null;
-
-        try {
-            pyatv = await request(id, NodePyATVExecutableType.atvremote, ['--version'], options) as string;
-        } catch (error) {
-            debug(id, `Unable to get pyatv version due to ${error}`, options);
-        }
-
-        if (pyatv && pyatv.substr(0, 10) === 'atvremote ') {
-            pyatv = pyatv.substr(10);
-        }
-        if (!semver.valid(pyatv)) {
-            debug(id, `String "${pyatv}" is not a valid pyatv version, set it to null`, options);
-            pyatv = null;
-        }
-
-        try {
-            const json = JSON.parse(await fsPromises.readFile(__dirname + '/../../package.json', 'utf8'));
-            module = json?.version || null;
-        } catch (error) {
-            debug(id, `Unable to get module version due to ${error}`, options);
-        }
-        if (module && !semver.valid(module)) {
-            debug(id, `String "${module}" is not a valid module version, set it to null`, options);
-            module = null;
-        }
-
-        removeRequestId(id);
-        return {
-            pyatv,
-            module
-        };
-    }
-
-    /**
-     * Scan the network for Apple TVs by using pyatv's atvscript. See [[NodePyATVFindAndInstanceOptions]]
-     * for the options allowed. Use the `host` / `hosts` attribute to filter by IP addresses. Resolves with
-     * an array of [[NodePyATVDevice]].
-     *
-     * ```typescript
-     * import pyatv from '@sebbo2002/node-pyatv';
-     * const devices = await pyatv.find();
-     * console.log(devices);
-     * ```
-     *
-     * @param options
-     */
-    public static async find (options: NodePyATVFindAndInstanceOptions = {}): Promise<NodePyATVDevice[]> {
-        const id = addRequestId();
-        const parameters = getParamters(options);
-
-        const result = await request(id, NodePyATVExecutableType.atvscript, [...parameters, 'scan'], options);
-        if (typeof result !== 'object' || result.result !== 'success' || !Array.isArray(result.devices)) {
-            throw new Error(`Unable to parse pyatv response: ${JSON.stringify(result, null, '  ')}`);
-        }
-
-        const objects = result.devices.map((device: NodePyATVInternalScanDevice) =>
-            this.device(Object.assign({}, options, {
-                host: device.address,
-                id: device.identifier,
-                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
-            }))
-        );
-
-        removeRequestId(id);
-        return objects;
-    }
-
-    /**
-     * Create a [[NodePyATVDevice]] to query the state and control it.
-     * At least `host` and `name` are required.
-     *
-     * @param options
-     */
-    public static device (options: NodePyATVDeviceOptions): NodePyATVDevice {
-        return new NodePyATVDevice(options);
-    }
-
-    /**
-     * Use this to apply [[NodePyATVInstanceOptions]]
-     * (e.g. debug log method) to all further requests
-     *
-     * ```typescript
-     * import pyatv from '@sebbo2002/node-pyatv';
-     * const myPyatv = new pyatv({debug: true});
-     * const devices = myPyatv.find();
-     * console.log(devices);
-     * ```
-     * @param options
-     */
-    public constructor (options: NodePyATVInstanceOptions = {}) {
-        this.options = Object.assign({}, options);
-    }
-
-    /**
-     * Checks if pyatv is installed and ready to be used.
-     * Will throw an error if not.
-     *
-     * @param options
-     */
-    public async check (options: NodePyATVInstanceOptions = {}): Promise<void> {
-        return NodePyATVInstance.check(Object.assign({}, this.options, options));
-    }
-
-    /**
-     * Resolves with the version of pyatv and of the module itself.
-     * If a value can't be found, null is returned instead.
-     *
-     * @param options
-     */
-    public async version (options: NodePyATVInstanceOptions = {}): Promise<NodePyATVVersionResponse> {
-        return NodePyATVInstance.version(Object.assign({}, this.options, options));
-    }
-
-    /**
-     * Scan the network for Apple TVs by using pyatv's atvscript. See [[NodePyATVFindAndInstanceOptions]]
-     * for the options allowed. Use the `host` / `hosts` attribute to filter by IP addresses. Resolves with
-     * an array of [[NodePyATVDevice]].
-     *
-     * ```typescript
-     * import pyatv from '@sebbo2002/node-pyatv';
-     * const myPyATV = new pyatv({debug: true});
-     * const devices = await myPyATV.find();
-     * console.log(devices);
-     * ```
-     *
-     * @param options
-     */
-    public async find (options: NodePyATVFindAndInstanceOptions = {}): Promise<NodePyATVDevice[]> {
-        return NodePyATVInstance.find(Object.assign({}, this.options, options));
-    }
-
-    /**
-     * Create a [[NodePyATVDevice]] to query the state and control it.
-     * At least `host` and `name` are required.
-     *
-     * @param options
-     */
-    public device (options: NodePyATVDeviceOptions): NodePyATVDevice {
-        return NodePyATVInstance.device(Object.assign({}, this.options, options));
-    }
-}