alphatheta-connect 0.26.0 → 0.27.0

package/lib/network.d.ts

@@ -10,7 +10,7 @@ import { MixstatusProcessor } from "./mixstatus";
 import RemoteDatabase from "./remotedb";
 import StatusEmitter from "./status";
 import PositionEmitter from "./status/position";
-import { NetworkState } from "./types";
+import { Device, NetworkState } from "./types";
 export interface NetworkConfig {
     /**
      * The network interface to listen for devices on the network over
@@ -199,6 +199,12 @@ export declare class ProlinkNetwork {
      * accurate timecode/video sync even during scratching, reverse play, and loops.
      */
     get positionEmitter(): PositionEmitter | null;
+    /**
+     * The device this network announces itself as, once connected: the
+     * `hostDevice` the status emitter's media query and the control service
+     * send from.
+     */
+    get virtualDevice(): Device | null;
     /**
      * Get the {@link Control} service. This service can be used to control the
      * Playstate of CDJs on the network.

package/lib/remote/hue.d.ts

@@ -0,0 +1,66 @@
+export interface HueConfig {
+    bridge: string;
+    appKey: string;
+}
+/**
+ * One group as the bridge lists it: a room or a zone.
+ */
+export interface HueGroup {
+    id: string;
+    name: string;
+    type: string;
+    lights: string[];
+    /** Every light in the group is on. */
+    allOn: boolean;
+    /** At least one light in the group is on. */
+    anyOn: boolean;
+}
+export declare class HueError extends Error {
+}
+/**
+ * Raised when nothing has been paired and the environment names no bridge.
+ */
+export declare class HueUnconfiguredError extends HueError {
+    constructor();
+}
+/**
+ * Raised when the bridge has no group by the name asked for.
+ */
+export declare class HueNoGroupError extends HueError {
+    constructor(name: string, groups: HueGroup[]);
+}
+export declare function hueConfigPath(): string;
+/**
+ * The environment first (`HUE_BRIDGE`, `HUE_APP_KEY`), then the file `hue
+ * pair` wrote; `null` when neither is there.
+ */
+export declare function loadHueConfig(): Promise<HueConfig | null>;
+export declare function saveHueConfig(config: HueConfig): Promise<string>;
+export declare class Hue {
+    #private;
+    constructor(config: HueConfig);
+    get bridge(): string;
+    /**
+     * Every room and zone on the bridge, by name.
+     */
+    groups(): Promise<HueGroup[]>;
+    /**
+     * The group called `name`, matched without regard to case.
+     */
+    groupNamed(name: string): Promise<HueGroup>;
+    /**
+     * Switch every light (and plug) in the group.
+     */
+    setGroupOn(groupId: string, on: boolean): Promise<void>;
+}
+/**
+ * Ask the bridge for an application key. The bridge only issues one in the
+ * thirty seconds after its link button is pressed, so this asks once a second
+ * until it does or `waitMs` runs out.
+ */
+export declare function pairHue(bridge: string, waitMs?: number): Promise<HueConfig>;
+/**
+ * Where the bridge is: `HUE_BRIDGE`, else Signify's discovery service, which
+ * lists the bridges that have phoned home from this public address.
+ */
+export declare function discoverHueBridge(): Promise<string>;

package/lib/remote/index.d.ts

@@ -0,0 +1,100 @@
+import { LoadSource } from "../control";
+import { Logger } from "../logger";
+import { ProlinkNetwork } from "../network";
+import { CDJStatus, Device, MediaSlotInfo } from "../types";
+/**
+ * The Stagehand transport opcodes (packet 0x07) the iPad app was captured
+ * sending, besides play (0x0f then 0x14 pressed) and pause (0x14 released),
+ * which `Control` sends itself. These are held while pressed.
+ */
+export declare const TransportOp: {
+    readonly SkipForward: 24;
+    readonly SkipBackward: 25;
+    readonly SeekForward: 26;
+    readonly SeekBackward: 27;
+};
+export declare class RemoteError extends Error {
+}
+export declare class NoPlayerError extends RemoteError {
+    constructor(number: number);
+}
+export declare class CueUnknownError extends RemoteError {
+    constructor();
+}
+export interface RemoteOptions {
+    /** Interface name or address; default: the one the first player heard is on. */
+    iface?: string;
+    /** Device number 141..211; default: one derived from the interface's MAC. */
+    number?: number;
+    /** The Stagehand opcode for CUE, once one is found. */
+    cueOp?: number;
+    logger?: Logger;
+}
+/**
+ * A player as the API reports it: its identity from the keep-alives and its
+ * last status, when it has sent one.
+ */
+export interface Player {
+    number: number;
+    name: string;
+    ip: string;
+    status?: CDJStatus.State;
+}
+export declare class Remote {
+    #private;
+    private constructor();
+    /**
+     * Join the link and start collecting status. Resolves once the Stagehand
+     * join sequence is through and keep-alives are running.
+     */
+    static join(opts?: RemoteOptions): Promise<Remote>;
+    get network(): ProlinkNetwork;
+    /**
+     * Our own device as announced.
+     */
+    get me(): Device | null;
+    /**
+     * Every device heard on the link, by number.
+     */
+    get devices(): Device[];
+    /**
+     * The players, with the last status each one sent.
+     */
+    get players(): Player[];
+    player(number: number): Device;
+    play(number: number): Promise<void>;
+    pause(number: number): Promise<void>;
+    /**
+     * Press and release the cue button, once its opcode is known.
+     */
+    cue(number: number): Promise<void>;
+    /**
+     * Hold fast-forward for `holdMs`.
+     */
+    fastForward(number: number, holdMs: number): Promise<void>;
+    /**
+     * Hold rewind for `holdMs`.
+     */
+    rewind(number: number, holdMs: number): Promise<void>;
+    skipForward(number: number): Promise<void>;
+    skipBackward(number: number): Promise<void>;
+    /**
+     * One transport packet: `op` pressed or released.
+     */
+    transport(number: number, op: number, press: boolean): Promise<void>;
+    /**
+     * Press `op`, hold it for `holdMs`, release it.
+     */
+    tap(number: number, op: number, holdMs: number): Promise<void>;
+    /**
+     * What is in a player's USB and SD slots, as the player answers a media
+     * query; a slot it does not answer for is left out.
+     */
+    media(number: number): Promise<MediaSlotInfo[]>;
+    /**
+     * Tell a player to load a track from `source` (another player's stick, or a
+     * library served over the link).
+     */
+    loadTrack(number: number, trackId: number, source: LoadSource): Promise<void>;
+    leave(): Promise<void>;
+}

package/lib/remote/server.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The REST API over a {@link Remote}. JSON in and out; every error is
+ * `{"error": "…"}` with a status that says whose fault it was.
+ *
+ *   GET  /                       who we are, every device heard, the booth's power
+ *   GET  /players                the players with their last status
+ *   GET  /players/{n}/media      what is in the player's USB and SD slots
+ *   POST /players/{n}/play
+ *   POST /players/{n}/pause
+ *   POST /players/{n}/cue
+ *   POST /players/{n}/ff         {"hold_ms": 500}   hold fast-forward, then release
+ *   POST /players/{n}/rew        {"hold_ms": 500}
+ *   POST /players/{n}/skip       {"direction": "forward" | "backward"}
+ *   POST /players/{n}/op         {"op": 26, "press": true}   one raw transport packet
+ *   POST /players/{n}/load       {"track_id": 1, "source": {"device": 2, "slot": "usb"}}
+ *   GET  /booth                  the Hue group and whether it is on
+ *   PUT  /booth                  {"on": true}
+ *   POST /booth/on
+ *   POST /booth/off
+ *   GET  /hue/groups             every room and zone the bridge has
+ */
+import http from 'http';
+import { Logger } from "../logger";
+import { Hue } from './hue';
+import { Remote } from './index';
+export interface ServerOptions {
+    remote: Remote;
+    hue: Hue | null;
+    /** The Hue room or zone the booth's gear is plugged into. */
+    boothGroup: string;
+    logger?: Logger;
+}
+export declare function createServer({ remote, hue, boothGroup, logger }: ServerOptions): http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;

package/lib/remotedb/fields.d.ts

@@ -65,7 +65,7 @@ export declare const UInt8: {
         data: Buffer;
     };
     type: NumberFieldType;
-    bytesToRead: 1 | 2 | 4;
+    bytesToRead: 1 | 4 | 2;
 };
 /**
  * Field representing a UInt16
@@ -81,7 +81,7 @@ export declare const UInt16: {
         data: Buffer;
     };
     type: NumberFieldType;
-    bytesToRead: 1 | 2 | 4;
+    bytesToRead: 1 | 4 | 2;
 };
 /**
  * Field representing a UInt32
@@ -97,7 +97,7 @@ export declare const UInt32: {
         data: Buffer;
     };
     type: NumberFieldType;
-    bytesToRead: 1 | 2 | 4;
+    bytesToRead: 1 | 4 | 2;
 };
 /**
  * Field representing a null-terminated big endian UTF-16 string
@@ -131,7 +131,7 @@ declare const fieldMap: {
             data: Buffer;
         };
         type: NumberFieldType;
-        bytesToRead: 1 | 2 | 4;
+        bytesToRead: 1 | 4 | 2;
     };
     readonly 16: {
         new (value: number | Buffer): {
@@ -144,7 +144,7 @@ declare const fieldMap: {
             data: Buffer;
         };
         type: NumberFieldType;
-        bytesToRead: 1 | 2 | 4;
+        bytesToRead: 1 | 4 | 2;
     };
     readonly 17: {
         new (value: number | Buffer): {
@@ -157,7 +157,7 @@ declare const fieldMap: {
             data: Buffer;
         };
         type: NumberFieldType;
-        bytesToRead: 1 | 2 | 4;
+        bytesToRead: 1 | 4 | 2;
     };
     readonly 20: typeof Binary;
     readonly 38: typeof String;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alphatheta-connect",
-  "version": "0.26.0",
+  "version": "0.27.0",
   "main": "lib/index.js",
   "author": "Evan Purkhiser <evanpurkhiser@gmail.com>",
   "contributors": [