node-toypad 2.0.0

package/dist/metadata.js

@@ -0,0 +1,70 @@
+var _a, _b, _c, _d;
+import charactersJson from "../data/minifigs.json" with { type: "json" };
+import vehiclesJson from "../data/vehicles.json" with { type: "json" };
+import upgradesJson from "../data/upgrades.json" with { type: "json" };
+import { VEHICLE_MAP_BY_ID } from "./vehicle-map.js";
+const characters = (_a = charactersJson) !== null && _a !== void 0 ? _a : [];
+const vehicles = (_b = vehiclesJson) !== null && _b !== void 0 ? _b : [];
+const upgrades = (_c = upgradesJson) !== null && _c !== void 0 ? _c : [];
+const characterMap = new Map(characters.map((character) => [character.id, character]));
+const vehicleMap = new Map(vehicles.map((vehicle) => [vehicle.id, vehicle]));
+const vehicleVariants = new Map();
+const upgradeLabelMap = new Map(upgrades.map((entry) => [entry.id, entry.label]));
+for (const vehicle of vehicles) {
+    const parentId = (vehicle.parentId || vehicle.id);
+    const variants = (_d = vehicleVariants.get(parentId)) !== null && _d !== void 0 ? _d : [];
+    variants.push(vehicle);
+    vehicleVariants.set(parentId, variants);
+}
+for (const [parentId, variants] of vehicleVariants.entries()) {
+    variants.sort((a, b) => {
+        const aBase = a.id === parentId ? 0 : 1;
+        const bBase = b.id === parentId ? 0 : 1;
+        if (aBase !== bBase) {
+            return aBase - bBase;
+        }
+        return a.id - b.id;
+    });
+}
+export function getCharacterById(id) {
+    return characterMap.get(id);
+}
+export function getVehicleById(id) {
+    return vehicleMap.get(id);
+}
+export function getVehicleVariant(id, step) {
+    if (typeof step === "number") {
+        const variants = vehicleVariants.get(id);
+        if (!variants) {
+            return undefined;
+        }
+        if (step < 0 || step >= variants.length) {
+            return undefined;
+        }
+        const variant = variants[step];
+        return { ...variant, step };
+    }
+    const vehicle = vehicleMap.get(id);
+    if (!vehicle) {
+        return undefined;
+    }
+    const variants = vehicleVariants.get(vehicle.parentId || vehicle.id);
+    const stepIndex = variants ? variants.findIndex((entry) => entry.id === vehicle.id) : -1;
+    return stepIndex >= 0 ? { ...vehicle, step: stepIndex } : vehicle;
+}
+export function listCharacters() {
+    return characters.slice();
+}
+export function listVehicles() {
+    return vehicles.slice();
+}
+export function getUpgradeLabel(id) {
+    return upgradeLabelMap.get(id);
+}
+export function listUpgradeLabels() {
+    return upgrades.slice();
+}
+export function getVehicleMap(id) {
+    var _a;
+    return (_a = VEHICLE_MAP_BY_ID[id]) !== null && _a !== void 0 ? _a : 0;
+}

package/dist/protocol.d.ts

@@ -0,0 +1,35 @@
+import { ActionType, RequestType, ToyPadPanel } from "./constants.js";
+export interface ToyPadCommand {
+    id: RequestType | number;
+    params: number[];
+}
+export interface ToyPadResponseMessage {
+    kind: "response";
+    requestId: number;
+    payload: Buffer;
+}
+export interface ToyPadTagEvent {
+    kind: "event";
+    panel: ToyPadPanel;
+    action: ActionType;
+    index: number;
+    tagType: number;
+    signature: string;
+    raw: Buffer;
+}
+export type ToyPadIncomingMessage = ToyPadResponseMessage | ToyPadTagEvent;
+export interface FlashOptions {
+    onTicks?: number;
+    offTicks?: number;
+}
+export declare function encodeCommand(command: ToyPadCommand, requestId: number): Buffer;
+export declare function decodeMessage(data: Buffer): ToyPadIncomingMessage | undefined;
+export declare function createSetColorCommand(panel: ToyPadPanel, color: number): ToyPadCommand;
+export declare function createGetColorCommand(panel: ToyPadPanel): ToyPadCommand;
+export declare function createFadeCommand(panel: ToyPadPanel, speed: number, cycles: number, color: number): ToyPadCommand;
+export declare function createFlashCommand(panel: ToyPadPanel, color: number, count: number, options?: FlashOptions): ToyPadCommand;
+export declare function createReadTagCommand(index: number, page: number): ToyPadCommand;
+export declare function createWriteTagCommand(index: number, page: number, data: Buffer | number[]): ToyPadCommand;
+export declare function decodeColor(payload: Buffer): number;
+export declare function normalizePanel(value: number): ToyPadPanel;
+export declare function normalizeAction(value: number): ActionType;

package/dist/protocol.js

@@ -0,0 +1,177 @@
+import { ActionType, CommandType, MessageType, PACKET_LENGTH, RequestType, ToyPadPanel } from "./constants.js";
+export function encodeCommand(command, requestId) {
+    var _a;
+    const params = (_a = command.params) !== null && _a !== void 0 ? _a : [];
+    const payload = [
+        MessageType.Response,
+        (params.length + 2) & 0xff,
+        command.id & 0xff,
+        requestId & 0xff,
+        ...params.map((value) => value & 0xff)
+    ];
+    const withChecksum = appendChecksum(payload);
+    return padMessage(withChecksum);
+}
+export function decodeMessage(data) {
+    const normalized = normalizePacket(data);
+    if (!normalized.length) {
+        return undefined;
+    }
+    const type = normalized[0];
+    if (type === MessageType.Event) {
+        return decodeActionEvent(normalized);
+    }
+    if (type === MessageType.Response) {
+        return decodeResponse(normalized);
+    }
+    return undefined;
+}
+export function createSetColorCommand(panel, color) {
+    const rgb = normalizeColor(color);
+    return {
+        id: RequestType.SetColor,
+        params: [panel & 0xff, rgb.red, rgb.green, rgb.blue]
+    };
+}
+export function createGetColorCommand(panel) {
+    return {
+        id: RequestType.GetColor,
+        params: [((panel - 1) & 0xff) >>> 0]
+    };
+}
+export function createFadeCommand(panel, speed, cycles, color) {
+    const rgb = normalizeColor(color);
+    return {
+        id: RequestType.Fade,
+        params: [panel & 0xff, speed & 0xff, cycles & 0xff, rgb.red, rgb.green, rgb.blue]
+    };
+}
+export function createFlashCommand(panel, color, count, options = {}) {
+    var _a, _b;
+    const rgb = normalizeColor(color);
+    const offTicks = ((_a = options.offTicks) !== null && _a !== void 0 ? _a : 10) & 0xff;
+    const onTicks = ((_b = options.onTicks) !== null && _b !== void 0 ? _b : 10) & 0xff;
+    return {
+        id: RequestType.Flash,
+        params: [panel & 0xff, offTicks, onTicks, count & 0xff, rgb.red, rgb.green, rgb.blue]
+    };
+}
+export function createReadTagCommand(index, page) {
+    return {
+        id: RequestType.ReadTag,
+        params: [index & 0xff, page & 0xff]
+    };
+}
+export function createWriteTagCommand(index, page, data) {
+    const payload = Array.isArray(data) ? data.slice() : Array.from(data.values());
+    if (payload.length !== 16) {
+        throw new Error(`ToyPad write requires 16 bytes of data, received ${payload.length}.`);
+    }
+    return {
+        id: RequestType.WriteTag,
+        params: [index & 0xff, page & 0xff, ...payload.map((value) => value & 0xff)]
+    };
+}
+export function decodeColor(payload) {
+    if (payload.length < 3) {
+        return 0;
+    }
+    return ((payload[0] & 0xff) << 16) | ((payload[1] & 0xff) << 8) | (payload[2] & 0xff);
+}
+export function normalizePanel(value) {
+    switch (value) {
+        case ToyPadPanel.Center:
+        case ToyPadPanel.Left:
+        case ToyPadPanel.Right:
+            return value;
+        default:
+            return ToyPadPanel.All;
+    }
+}
+export function normalizeAction(value) {
+    return value === ActionType.Remove ? ActionType.Remove : ActionType.Add;
+}
+function decodeActionEvent(data) {
+    if (data.length < 14) {
+        return undefined;
+    }
+    const command = data[1];
+    if (command !== CommandType.Action) {
+        return undefined;
+    }
+    const panel = normalizePanel(data[2]);
+    const tagType = data[3] & 0xff;
+    const index = data[4] & 0xff;
+    const action = normalizeAction(data[5]);
+    const signatureBytes = data.subarray(6, 13);
+    return {
+        kind: "event",
+        panel,
+        action,
+        index,
+        tagType,
+        signature: formatSignature(signatureBytes),
+        raw: Buffer.from(signatureBytes)
+    };
+}
+function decodeResponse(data) {
+    if (data.length < 3) {
+        return undefined;
+    }
+    const length = data[1];
+    const payloadStart = 2;
+    const payloadEnd = Math.min(data.length - 1, payloadStart + length);
+    if (payloadEnd <= payloadStart) {
+        return undefined;
+    }
+    const payloadWithRequestId = data.subarray(payloadStart, payloadEnd);
+    if (!payloadWithRequestId.length) {
+        return undefined;
+    }
+    const [requestId] = payloadWithRequestId;
+    const payload = payloadWithRequestId.subarray(1);
+    return {
+        kind: "response",
+        requestId,
+        payload
+    };
+}
+function appendChecksum(values) {
+    let checksum = 0;
+    for (const value of values) {
+        checksum = (checksum + (value & 0xff)) & 0xff;
+    }
+    return [...values, checksum];
+}
+function padMessage(values) {
+    if (values.length > PACKET_LENGTH) {
+        return Buffer.from(values.slice(0, PACKET_LENGTH));
+    }
+    const padded = values.slice();
+    while (padded.length < PACKET_LENGTH) {
+        padded.push(0x00);
+    }
+    return Buffer.from(padded);
+}
+function normalizePacket(data) {
+    if (!data.length) {
+        return data;
+    }
+    if (data[0] === 0x00 && data.length > 1) {
+        return data.subarray(1);
+    }
+    return data;
+}
+function formatSignature(buffer) {
+    return Array.from(buffer)
+        .map((value) => value.toString(16).padStart(2, "0"))
+        .join(" ");
+}
+function normalizeColor(color) {
+    const clamped = color & 0xffffff;
+    return {
+        red: (clamped >> 16) & 0xff,
+        green: (clamped >> 8) & 0xff,
+        blue: clamped & 0xff
+    };
+}

package/dist/tag.d.ts

@@ -0,0 +1,10 @@
+import { CharacterId, VehicleId } from "./ids.js";
+export declare enum TagType {
+    Unknown = "unknown",
+    Character = "character",
+    Vehicle = "vehicle"
+}
+export declare function isVehicle(data: Buffer | Uint8Array): boolean;
+export declare function getVehicleId(data: Buffer | Uint8Array): VehicleId;
+export declare function getCharacterId(uid: Buffer | Uint8Array, encrypted: Buffer | Uint8Array): CharacterId;
+export declare function detectTagType(block26: Buffer | Uint8Array): TagType;

package/dist/tag.js

@@ -0,0 +1,96 @@
+import { CharacterId } from "./ids.js";
+const VEHICLE_MARKER = Buffer.from([0x00, 0x01, 0x00, 0x00]);
+const TEA_DELTA = 0x9e3779b9;
+const TEA_SUM_INIT = 0xc6ef3720;
+export var TagType;
+(function (TagType) {
+    TagType["Unknown"] = "unknown";
+    TagType["Character"] = "character";
+    TagType["Vehicle"] = "vehicle";
+})(TagType || (TagType = {}));
+export function isVehicle(data) {
+    var _a;
+    if (data.length < VEHICLE_MARKER.length) {
+        return false;
+    }
+    for (let i = 0; i < VEHICLE_MARKER.length; i++) {
+        if (((_a = data[i]) !== null && _a !== void 0 ? _a : 0) !== VEHICLE_MARKER[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+export function getVehicleId(data) {
+    if (data.length < 2) {
+        throw new Error("Vehicle data must contain at least 2 bytes.");
+    }
+    return (((data[1] & 0xff) << 8) | (data[0] & 0xff));
+}
+export function getCharacterId(uid, encrypted) {
+    if (uid.length !== 7) {
+        throw new Error("UID must be exactly 7 bytes long.");
+    }
+    if (encrypted.length < 8) {
+        throw new Error("Encrypted character data must be at least 8 bytes.");
+    }
+    const key = generateKeys(uid);
+    const values = [readUInt32LE(encrypted, 0), readUInt32LE(encrypted, 4)];
+    const [v0, v1] = teaDecrypt(values, key);
+    if (v0 !== v1) {
+        return CharacterId.Unknown;
+    }
+    return (v0 & 0xffff);
+}
+export function detectTagType(block26) {
+    if (isVehicle(block26)) {
+        return TagType.Vehicle;
+    }
+    return TagType.Character;
+}
+function readUInt32LE(buffer, offset) {
+    return ((buffer[offset + 3] << 24) |
+        (buffer[offset + 2] << 16) |
+        (buffer[offset + 1] << 8) |
+        buffer[offset]) >>> 0;
+}
+function rotateRight(value, count) {
+    const normalized = count & 31;
+    return ((value >>> normalized) | (value << (32 - normalized))) >>> 0;
+}
+function scramble(uid, count) {
+    const base = Buffer.from([
+        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb7, 0xd5, 0xd7, 0xe6, 0xe7,
+        0xba, 0x3c, 0xa8, 0xd8, 0x75, 0x47, 0x68, 0xcf, 0x23, 0xe9, 0xfe, 0xaa
+    ]);
+    Buffer.from(uid).copy(base, 0, 0, Math.min(uid.length, 7));
+    base[count * 4 - 1] = 0xaa;
+    let v2 = 0;
+    for (let i = 0; i < count; i++) {
+        const b = base.readUInt32LE(i * 4);
+        v2 = (b + rotateRight(v2, 25) + rotateRight(v2, 10) - v2) >>> 0;
+    }
+    return v2 >>> 0;
+}
+function generateKeys(uid) {
+    return [
+        scramble(uid, 3),
+        scramble(uid, 4),
+        scramble(uid, 5),
+        scramble(uid, 6)
+    ];
+}
+function teaDecrypt(values, key) {
+    let v0 = values[0] >>> 0;
+    let v1 = values[1] >>> 0;
+    let sum = TEA_SUM_INIT >>> 0;
+    const k0 = key[0] >>> 0;
+    const k1 = key[1] >>> 0;
+    const k2 = key[2] >>> 0;
+    const k3 = key[3] >>> 0;
+    for (let i = 0; i < 32; i++) {
+        v1 = (v1 - ((((v0 << 4) >>> 0) + k2) ^ (v0 + sum) ^ (((v0 >>> 5) + k3) >>> 0))) >>> 0;
+        v0 = (v0 - ((((v1 << 4) >>> 0) + k0) ^ (v1 + sum) ^ (((v1 >>> 5) + k1) >>> 0))) >>> 0;
+        sum = (sum - TEA_DELTA) >>> 0;
+    }
+    return [v0 >>> 0, v1 >>> 0];
+}

package/dist/toypad.d.ts

@@ -0,0 +1,81 @@
+import { EventEmitter } from "events";
+import { ToyPadPanel } from "./constants.js";
+import { FlashOptions, ToyPadTagEvent } from "./protocol.js";
+import { TagType } from "./tag.js";
+import { CharacterId, VehicleId, UpgradeId } from "./ids.js";
+import { getCharacterById, getVehicleById, listCharacters, listVehicles, getUpgradeLabel, listUpgradeLabels } from "./metadata.js";
+import { UpgradeOverrides, UpgradeValue } from "./upgrades.js";
+export interface ToyPadEvents {
+    connect: () => void;
+    disconnect: () => void;
+    error: (error: Error) => void;
+    event: (event: ToyPadTagEvent) => void;
+    add: (event: ToyPadTagEvent) => void;
+    remove: (event: ToyPadTagEvent) => void;
+}
+type BasicTagInfo = {
+    id: CharacterId;
+    type: TagType.Character;
+} | {
+    id: VehicleId;
+    type: TagType.Vehicle;
+};
+export type ToyPadTagInfo = BasicTagInfo & {
+    signature: string;
+};
+export interface WriteVehicleOptions {
+    signature?: string;
+    step?: number;
+}
+export interface WriteVehicleUpgradesOptions {
+    signature?: string;
+    upgrades: UpgradeOverrides;
+}
+export interface ReadVehicleUpgradesOptions {
+    signature?: string;
+}
+export declare class ToyPad extends EventEmitter {
+    static Panel: typeof ToyPadPanel;
+    static metadata: {
+        getCharacterById: typeof getCharacterById;
+        getVehicleById: typeof getVehicleById;
+        listCharacters: typeof listCharacters;
+        listVehicles: typeof listVehicles;
+        getUpgradeLabel: typeof getUpgradeLabel;
+        listUpgradeLabels: typeof listUpgradeLabels;
+        listVehicleUpgrades(vehicleId: VehicleId): UpgradeId[];
+    };
+    private connection?;
+    private readonly activeTags;
+    connect(): Promise<void>;
+    disconnect(): void;
+    setColor(panel: ToyPadPanel, color: number): Promise<void>;
+    getColor(panel: ToyPadPanel): Promise<number>;
+    fade(panel: ToyPadPanel, speed: number, cycles: number, color: number): Promise<void>;
+    flash(panel: ToyPadPanel, color: number, count: number, options?: FlashOptions): Promise<void>;
+    readTag(panel: ToyPadPanel, signature?: string): Promise<ToyPadTagInfo>;
+    writeVehicle(panel: ToyPadPanel, vehicleId: VehicleId, options?: WriteVehicleOptions): Promise<void>;
+    writeVehicleUpgrades(panel: ToyPadPanel, options: WriteVehicleUpgradesOptions): Promise<void>;
+    readVehicleUpgrades(panel: ToyPadPanel, options?: ReadVehicleUpgradesOptions): Promise<UpgradeValue[]>;
+    private ensureConnection;
+    private forwardEvent;
+    private normalizeSignature;
+    private resolveActiveTag;
+    private readTagData;
+    private resolveVehicleVariant;
+    private createVehiclePayload;
+    private writeUpgradePayload;
+    private readUpgradePayload;
+    private readUpgradeBlock;
+    private extractUpgradePayload;
+    private delay;
+    private readBlock;
+    private resolveUpgradeFlag;
+}
+export interface ToyPad {
+    on<U extends keyof ToyPadEvents>(event: U, listener: ToyPadEvents[U]): this;
+    once<U extends keyof ToyPadEvents>(event: U, listener: ToyPadEvents[U]): this;
+    off<U extends keyof ToyPadEvents>(event: U, listener: ToyPadEvents[U]): this;
+    emit<U extends keyof ToyPadEvents>(event: U, ...args: Parameters<ToyPadEvents[U]>): boolean;
+}
+export type { ToyPadTagEvent };