@sebbo2002/node-pyatv 6.0.0-develop.2 → 6.0.0

package/src/lib/tools.ts

@@ -1,379 +0,0 @@
-'use strict';
-
-import {
-    NodePyATVDeviceState,
-    NodePyATVExecutableType,
-    NodePyATVFindAndInstanceOptions,
-    NodePyATVInstanceOptions,
-    NodePyATVInternalState,
-    NodePyATVMediaType, NodePyATVPowerState, NodePyATVRepeatState, NodePyATVShuffleState,
-    NodePyATVState
-} from './types.js';
-
-import {ChildProcess, spawn, SpawnOptions} from 'child_process';
-import {FakeChildProcess} from './fake-spawn.js';
-
-const requestIds: string[] = [];
-
-export function addRequestId(): string {
-    let id = '?';
-
-    for (let i = 0; i < 1000; i += 1) {
-        id = Math.round(Math.random() * (i + 6) * 36).toString(36).toUpperCase();
-        if (!requestIds.includes(id)) {
-            requestIds.push(id);
-            break;
-        }
-    }
-
-    return id;
-}
-
-export function removeRequestId(id: string | undefined): void {
-    if (id && requestIds.includes(id)) {
-        requestIds.splice(requestIds.indexOf(id), 1);
-    }
-}
-
-export function debug(id: string, message: string, options: NodePyATVInstanceOptions): void {
-    if (options.debug) {
-        const log = typeof options.debug === 'function' ? options.debug : console.log;
-        const enableColors = !process.env.NO_COLOR && !options.noColors;
-
-        const parts = [
-            enableColors ? '\x1b[0m' : '', // Color Reset
-            enableColors ? '\x1b[90m' : '', // Grey
-            '[node-pyatv][',
-            enableColors ? '\x1b[37m' : '', // Light Grey
-            id,
-            enableColors ? '\x1b[90m' : '', // Grey
-            '] ',
-            enableColors ? '\x1b[0m' : '', // Color Reset
-            message
-        ];
-
-        log.apply(null, [parts.join('')]);
-    }
-}
-
-export function getExecutable(executable: NodePyATVExecutableType, options: NodePyATVInstanceOptions): string {
-    if (executable === NodePyATVExecutableType.atvremote && typeof options.atvremotePath === 'string') {
-        return options.atvremotePath;
-    }
-    else if (executable === NodePyATVExecutableType.atvscript && typeof options.atvscriptPath === 'string') {
-        return options.atvscriptPath;
-    }
-    else {
-        return executable;
-    }
-}
-
-export function execute(
-    requestId: string,
-    executableType: NodePyATVExecutableType,
-    parameters: string[],
-    options: NodePyATVInstanceOptions
-): ChildProcess | FakeChildProcess {
-    const executable = getExecutable(executableType, options);
-    const mySpawn: ((command: string, args: Array<string>, options: SpawnOptions) => (ChildProcess | FakeChildProcess)) = typeof options.spawn === 'function' ? options.spawn : spawn;
-
-    debug(requestId, `${executable} ${parameters.join(' ')}`, options);
-    const child = mySpawn(executable, parameters, {
-        env: process.env
-    });
-
-    /* eslint-disable @typescript-eslint/no-explicit-any*/
-    const onStdOut = (data: any) => debug(requestId, `stdout: ${String(data).trim()}`, options);
-    const onStdErr = (data: any) => debug(requestId, `stderr: ${String(data).trim()}`, options);
-    const onError = (data: any) => debug(requestId, `error: ${String(data).trim()}`, options);
-    /* eslint-enable @typescript-eslint/no-explicit-any*/
-
-    const onClose = (code: number) => {
-        debug(requestId, `${executable} exited with code: ${code}`, options);
-
-        if (child.stdout) {
-            child.stdout.off('data', onStdOut);
-        }
-        if (child.stderr) {
-            child.stderr.off('data', onStdErr);
-        }
-
-        child.off('error', onError);
-        child.off('close', onClose);
-    };
-
-    if (child.stdout) {
-        child.stdout.on('data', onStdOut);
-    }
-    if (child.stderr) {
-        child.stderr.on('data', onStdErr);
-    }
-
-    child.on('error', onError);
-    child.on('close', onClose);
-
-    return child;
-}
-
-export async function request(
-    requestId: string,
-    executableType: NodePyATVExecutableType,
-    parameters: string[],
-    options: NodePyATVInstanceOptions
-): Promise<string|Record<string,unknown>> {
-    const result = {
-        stdout: '',
-        stderr: '',
-        code: 0
-    };
-
-    await new Promise((resolve, reject) => {
-        const pyatv = execute(requestId, executableType, parameters, options);
-
-        /* eslint-disable @typescript-eslint/no-explicit-any*/
-        const onStdOut = (data: any) => result.stdout += String(data).trim();
-        const onStdErr = (data: any) => result.stderr += String(data).trim();
-        const onError = (data: any) => reject(data instanceof Error ? data : new Error(String(data)));
-        /* eslint-enable @typescript-eslint/no-explicit-any*/
-
-        const onClose: (code: number) => void = (code: number) => {
-            result.code = code;
-
-            if (pyatv.stdout) {
-                pyatv.stdout.off('data', onStdOut);
-            }
-            if (pyatv.stderr) {
-                pyatv.stderr.off('data', onStdErr);
-            }
-
-            pyatv.off('error', onError);
-            pyatv.off('close', onClose);
-            resolve(undefined);
-        };
-
-        if (pyatv.stdout) {
-            pyatv.stdout.on('data', onStdOut);
-        }
-        if (pyatv.stderr) {
-            pyatv.stderr.on('data', onStdErr);
-        }
-
-        pyatv.on('error', onError);
-        pyatv.on('close', onClose);
-    });
-
-    if (result.stderr.length > 0) {
-        const msg = `Unable to execute request ${requestId}: ${result.stderr}`;
-        debug(requestId, msg, options);
-        throw new Error(msg);
-    }
-    if (executableType === NodePyATVExecutableType.atvscript) {
-        try {
-            return JSON.parse(result.stdout);
-        }
-        catch (error) {
-            const msg = `Unable to parse result ${requestId} json: ${error}`;
-            debug(requestId, msg, options);
-            throw new Error(msg);
-        }
-    }
-
-    return result.stdout;
-}
-
-export function getParamters(options: NodePyATVFindAndInstanceOptions = {}): string[] {
-    const parameters: string[] = [];
-
-    if (options.hosts) {
-        parameters.push('-s', options.hosts.join(','));
-    }
-    else if (options.host) {
-        parameters.push('-s', options.host);
-    }
-    if (options.id) {
-        parameters.push('-i', options.id);
-    }
-    if (options.protocol) {
-        parameters.push('--protocol', options.protocol);
-    }
-    if (options.dmapCredentials) {
-        parameters.push('--dmap-credentials', options.dmapCredentials);
-    }
-    if (options.mrpCredentials) {
-        parameters.push('--mrp-credentials', options.mrpCredentials);
-    }
-    if (options.airplayCredentials) {
-        parameters.push('--airplay-credentials', options.airplayCredentials);
-    }
-    if (options.companionCredentials) {
-        parameters.push('--companion-credentials', options.companionCredentials);
-    }
-    if (options.raopCredentials) {
-        parameters.push('--raop-credentials', options.raopCredentials);
-    }
-
-    return parameters;
-}
-
-function parseStateStringAttr(
-    input: NodePyATVInternalState,
-    output: NodePyATVState,
-    inputAttr: ('hash' | 'title' | 'album' | 'artist' | 'genre' | 'app' | 'app_id'),
-    outputAttr: ('hash' | 'title' | 'album' | 'artist' | 'genre' | 'app' | 'appId'),
-    d: (msg: string) => void
-): void {
-    if (typeof input[inputAttr] === 'string') {
-        output[outputAttr] = input[inputAttr] as string;
-        return;
-    }
-
-    d(`No ${outputAttr} value found in input (${JSON.stringify(input)})`);
-}
-
-export function parseState(input: NodePyATVInternalState, id: string, options: NodePyATVInstanceOptions): NodePyATVState {
-    const d = (msg: string) => debug(id, msg, options);
-    const result: NodePyATVState = {
-        dateTime: null,
-        hash: null,
-        mediaType: null,
-        deviceState: null,
-        title: null,
-        artist: null,
-        album: null,
-        genre: null,
-        totalTime: null,
-        position: null,
-        shuffle: null,
-        repeat: null,
-        app: null,
-        appId: null,
-        powerState: null
-    };
-    if (!input || typeof input !== 'object') {
-        return result;
-    }
-    if(input.exception) {
-        let errorStr = 'Got pyatv Error: ' + input.exception;
-        if(input.stacktrace) {
-            errorStr += '\n\npyatv Stacktrace:\n' + input.stacktrace;
-        }
-
-        throw new Error(errorStr);
-    }
-
-    // datetime
-    if (typeof input.datetime === 'string') {
-        const date = new Date(input.datetime);
-        if (!isNaN(date.getTime())) {
-            result.dateTime = date;
-        }
-        else {
-            d(`Invalid datetime value ${input.datetime}, ignore attribute`);
-        }
-    }
-    else {
-        d(`No datetime value found in input (${JSON.stringify(input)})`);
-    }
-
-    // hash
-    parseStateStringAttr(input, result, 'hash', 'hash', d);
-
-    // mediaType
-    if(typeof input.media_type === 'string') {
-        const validValues = Object.keys(NodePyATVMediaType).map(o => String(o));
-        if (validValues.includes(input.media_type)) {
-            result.mediaType = NodePyATVMediaType[input.media_type as NodePyATVMediaType];
-        }
-        else {
-            d(`Unsupported mediaType value ${input.media_type}, ignore attribute`);
-        }
-    } else {
-        d(`No mediaType value found in input (${JSON.stringify(input)})`);
-    }
-
-    // deviceState
-    if(typeof input.device_state === 'string') {
-        const validValues = Object.keys(NodePyATVDeviceState).map(o => String(o));
-        if (validValues.includes(input.device_state)) {
-            result.deviceState = NodePyATVDeviceState[input.device_state as NodePyATVDeviceState];
-        }
-        else {
-            d(`Unsupported deviceState value ${input.device_state}, ignore attribute`);
-        }
-    } else {
-        d(`No deviceState value found in input (${JSON.stringify(input)})`);
-    }
-
-    // title
-    parseStateStringAttr(input, result, 'title', 'title', d);
-
-    // artist
-    parseStateStringAttr(input, result, 'artist', 'artist', d);
-
-    // album
-    parseStateStringAttr(input, result, 'album', 'album', d);
-
-    // genre
-    parseStateStringAttr(input, result, 'genre', 'genre', d);
-
-    // totalTime
-    if (typeof input.total_time === 'number') {
-        result.totalTime = input.total_time;
-    }
-    else {
-        d(`No totalTime value found in input (${JSON.stringify(input)})`);
-    }
-
-    // position
-    if (typeof input.position === 'number') {
-        result.position = input.position;
-    }
-    else {
-        d(`No position value found in input (${JSON.stringify(input)})`);
-    }
-
-    // shuffle
-    if(typeof input.shuffle === 'string') {
-        const validValues = Object.keys(NodePyATVShuffleState).map(o => String(o));
-        if (validValues.includes(input.shuffle)) {
-            result.shuffle = NodePyATVShuffleState[input.shuffle as NodePyATVShuffleState];
-        }
-        else {
-            d(`Unsupported shuffle value ${input.shuffle}, ignore attribute`);
-        }
-    } else {
-        d(`No shuffle value found in input (${JSON.stringify(input)})`);
-    }
-
-    // repeat
-    if(typeof input.repeat === 'string') {
-        const validValues = Object.keys(NodePyATVRepeatState).map(o => String(o));
-        if (validValues.includes(input.repeat)) {
-            result.repeat = NodePyATVRepeatState[input.repeat as NodePyATVRepeatState];
-        }
-        else {
-            d(`Unsupported repeat value ${input.repeat}, ignore attribute`);
-        }
-    } else {
-        d(`No repeat value found in input (${JSON.stringify(input)})`);
-    }
-
-    // app
-    parseStateStringAttr(input, result, 'app', 'app', d);
-    parseStateStringAttr(input, result, 'app_id', 'appId', d);
-
-    // powerState
-    if(typeof input.power_state === 'string') {
-        const validValues = Object.keys(NodePyATVPowerState).map(o => String(o));
-        if (validValues.includes(input.power_state)) {
-            result.powerState = NodePyATVPowerState[input.power_state as NodePyATVPowerState];
-        }
-        else {
-            d(`Unsupported powerState value ${input.power_state}, ignore attribute`);
-        }
-    } else {
-        d(`No powerState value found in input (${JSON.stringify(input)})`);
-    }
-
-    return result;
-}

package/src/lib/types.ts

@@ -1,230 +0,0 @@
-import {ChildProcess, SpawnOptions} from 'child_process';
-import {FakeChildProcess} from './fake-spawn.js';
-
-export enum NodePyATVExecutableType {
-    atvremote = 'atvremote',
-    atvscript = 'atvscript',
-}
-
-export enum NodePyATVProtocol {
-    dmap = 'dmap',
-    mrp = 'mrp',
-    airplay = 'airplay',
-    mdns = 'mdns',
-}
-
-export enum NodePyATVMediaType {
-    music = 'music',
-    tv = 'tv',
-    video = 'video',
-    unknown = 'unknown'
-}
-
-export enum NodePyATVDeviceState {
-    idle = 'idle',
-    loading = 'loading',
-    paused = 'paused',
-    playing = 'playing',
-    seeking = 'seeking',
-    stopped = 'stopped'
-}
-
-export enum NodePyATVRepeatState {
-    all = 'all',
-    track = 'track',
-    off = 'off'
-}
-
-export enum NodePyATVShuffleState {
-    albums = 'albums',
-    songs = 'songs',
-    off = 'off'
-}
-
-export enum NodePyATVPowerState {
-    on = 'on',
-    off = 'off'
-}
-
-export enum NodePyATVKeys {
-    down = 'down',
-    home = 'home',
-    homeHold = 'homeHold',
-    left = 'left',
-    menu = 'menu',
-    next = 'next',
-    pause = 'pause',
-    play = 'play',
-    playPause = 'playPause',
-    previous = 'previous',
-    right = 'right',
-    select = 'select',
-    skipBackward = 'skipBackward',
-    skipForward = 'skipForward',
-    stop = 'stop',
-    suspend = 'suspend',
-    topMenu = 'topMenu',
-    up = 'up',
-    volumeDown = 'volumeDown',
-    volumeUp = 'volumeUp',
-    wakeup = 'wakeup',
-    turnOff = 'turnOff',
-    turnOn = 'turnOn'
-}
-
-/**
- * @internal
- */
-export enum NodePyATVInternalKeys {
-    down = 'down',
-    home = 'home',
-    homeHold = 'home_hold',
-    left = 'left',
-    menu = 'menu',
-    next = 'next',
-    pause = 'pause',
-    play = 'play',
-    playPause = 'play_pause',
-    previous = 'previous',
-    right = 'right',
-    select = 'select',
-    skipBackward = 'skip_backward',
-    skipForward = 'skip_forward',
-    stop = 'stop',
-    suspend = 'suspend',
-    topMenu = 'top_menu',
-    up = 'up',
-    volumeDown = 'volume_down',
-    volumeUp = 'volume_up',
-    wakeup = 'wakeup',
-    turnOff = 'turn_off',
-    turnOn = 'turn_on'
-}
-
-export enum NodePyATVListenerState {
-    stopped,
-    starting,
-    started,
-    stopping
-}
-
-
-export type NodePyATVStateIndex = keyof NodePyATVState;
-
-export type NodePyATVEventValueType = (string | number | NodePyATVMediaType | NodePyATVDeviceState |
-    NodePyATVShuffleState | NodePyATVRepeatState);
-
-
-export interface NodePyATVInstanceOptions {
-    atvremotePath?: string;
-    atvscriptPath?: string;
-    debug?: true | ((msg: string) => void);
-    noColors?: true;
-    spawn?: (command: string, args: Array<string>, options: SpawnOptions) => (ChildProcess | FakeChildProcess);
-}
-
-export interface NodePyATVVersionResponse {
-    pyatv: string | null;
-    module: string | null;
-}
-
-export interface NodePyATVFindOptions {
-    host?: string;
-    hosts?: string[];
-    id?: string;
-    protocol?: NodePyATVProtocol;
-    dmapCredentials?: string;
-    mrpCredentials?: string;
-    airplayCredentials?: string;
-    companionCredentials?: string;
-    raopCredentials?: string;
-}
-
-export interface NodePyATVFindAndInstanceOptions extends NodePyATVInstanceOptions, NodePyATVFindOptions {
-
-}
-
-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
- */
-export interface NodePyATVInternalState {
-    result?: string | unknown,
-    datetime?: string | unknown,
-    hash?: string | unknown,
-    media_type?: string | unknown,
-    device_state?: string | unknown,
-    title?: string | unknown,
-    artist?: string | unknown,
-    album?: string | unknown,
-    genre?: string | unknown,
-    total_time?: number | unknown,
-    position?: 1 | unknown,
-    shuffle?: string | unknown,
-    repeat?: string | unknown,
-    app?: string | unknown,
-    app_id?: string | unknown,
-    power_state?: string | unknown,
-    push_updates?: string | unknown,
-    exception?: string | unknown,
-    stacktrace?: string | unknown,
-    connection?: string | unknown
-}
-
-export interface NodePyATVState {
-    dateTime: Date | null;
-    hash: string | null;
-    mediaType: NodePyATVMediaType | null,
-    deviceState: NodePyATVDeviceState | null,
-    title: string | null,
-    artist: string | null,
-    album: string | null,
-    genre: string | null,
-    totalTime: number | null,
-    position: number | null,
-    shuffle: NodePyATVShuffleState | null,
-    repeat: NodePyATVRepeatState | null,
-    app: string | null,
-    appId: string | null,
-    powerState: NodePyATVPowerState | null
-}
-
-export interface NodePyATVApp {
-    id: string;
-    name: string;
-    launch: () => Promise<void>;
-}

package/test/device-event.ts

@@ -1,88 +0,0 @@
-'use strict';
-
-import assert from 'assert';
-import NodePyATVDevice from '../src/lib/device.js';
-import NodePyATVDeviceEvent from '../src/lib/device-event.js';
-
-describe('NodePyATVDeviceEvent', function () {
-    describe('get key()', function () {
-        it('should work', function () {
-            const event = new NodePyATVDeviceEvent({
-                key: 'genre',
-                old: 'Jazz',
-                new: 'Rock',
-                device: new NodePyATVDevice({
-                    host: '192.168.178.2',
-                    name: 'My Testinstance'
-                })
-            });
-
-            assert.strictEqual(event.key, 'genre');
-        });
-    });
-
-    describe('get oldValue()', function () {
-        it('should work', function () {
-            const event = new NodePyATVDeviceEvent({
-                key: 'genre',
-                old: 'Jazz',
-                new: 'Rock',
-                device: new NodePyATVDevice({
-                    host: '192.168.178.2',
-                    name: 'My Testinstance'
-                })
-            });
-
-            assert.strictEqual(event.oldValue, 'Jazz');
-        });
-    });
-
-    describe('get newValue()', function () {
-        it('should work', function () {
-            const event = new NodePyATVDeviceEvent({
-                key: 'genre',
-                old: 'Jazz',
-                new: 'Rock',
-                device: new NodePyATVDevice({
-                    host: '192.168.178.2',
-                    name: 'My Testinstance'
-                })
-            });
-
-            assert.strictEqual(event.newValue, 'Rock');
-        });
-    });
-
-    describe('get value()', function () {
-        it('should work', function () {
-            const event = new NodePyATVDeviceEvent({
-                key: 'genre',
-                old: 'Jazz',
-                new: 'Rock',
-                device: new NodePyATVDevice({
-                    host: '192.168.178.2',
-                    name: 'My Testinstance'
-                })
-            });
-
-            assert.strictEqual(event.value, 'Rock');
-        });
-    });
-
-    describe('get device()', function () {
-        it('should work', function () {
-            const device = new NodePyATVDevice({
-                host: '192.168.178.2',
-                name: 'My Testinstance'
-            });
-            const event = new NodePyATVDeviceEvent({
-                key: 'genre',
-                old: 'Jazz',
-                new: 'Rock',
-                device
-            });
-
-            assert.deepEqual(event.device, device);
-        });
-    });
-});