node-toypad 2.0.0

package/dist/upgrades.d.ts

@@ -0,0 +1,32 @@
+import { UpgradeId } from "./ids.js";
+export type UpgradeGroup = "speed" | "power" | "weapons" | "extras" | "colors";
+export type UpgradeOverrideValue = boolean | number;
+export interface UpgradeOverride {
+    id: UpgradeId;
+    value: UpgradeOverrideValue | undefined | null;
+}
+export type UpgradeOverrides = UpgradeOverride[];
+interface UpgradeSlotDefinition {
+    slot: number;
+    max: number;
+    digitId?: number;
+    label?: string;
+    id: UpgradeId;
+}
+export declare function encodeUpgradePayload(mapId: number, overrides: UpgradeOverrides, basePayload?: Buffer): Buffer;
+export declare function getPresetOverrides(mapId: number, step: number): UpgradeOverrides | undefined;
+export declare function encodePresetPayload(mapId: number, step: number): Buffer | undefined;
+export interface UpgradeSlotInfo extends UpgradeSlotDefinition {
+    group: UpgradeGroup;
+    id: UpgradeId;
+}
+export interface UpgradeSlotState extends UpgradeSlotInfo {
+    value: number;
+}
+export interface UpgradeValue {
+    id: UpgradeId;
+    value: boolean | number;
+}
+export declare function listUpgradeSlots(mapId: number): UpgradeSlotInfo[];
+export declare function decodeUpgradePayload(mapId: number, payload: Buffer): UpgradeSlotState[];
+export {};

package/dist/upgrades.js

@@ -0,0 +1,225 @@
+var _a;
+import debug from "debug";
+import { UPGRADE_DEFINITIONS } from "./upgrades-data.js";
+import { getUpgradeLabel } from "./metadata.js";
+import { getUpgradeDigits } from "./upgrade-token-map.js";
+const GROUPS = ["speed", "power", "weapons", "extras", "colors"];
+const log = debug("node-toypad:upgrades");
+const upgradeDefinitions = (_a = UPGRADE_DEFINITIONS) !== null && _a !== void 0 ? _a : [];
+const missingSlotWarnings = new Set();
+function findUpgradeDefinition(mapId) {
+    return upgradeDefinitions.find((entry) => entry.map === mapId);
+}
+function getDefinition(mapId) {
+    const definition = findUpgradeDefinition(mapId);
+    if (!definition) {
+        throw new Error(`Unknown upgrade map ${mapId}`);
+    }
+    return definition;
+}
+function buildSlotLookup(definition) {
+    var _a;
+    const lookup = new Map();
+    for (const group of GROUPS) {
+        const slots = (_a = definition.slots[group]) !== null && _a !== void 0 ? _a : [];
+        for (const slotDef of slots) {
+            lookup.set(slotDef.id, slotDef);
+        }
+    }
+    return lookup;
+}
+function getDigitEntries(mapId) {
+    const digits = getUpgradeDigits(mapId);
+    if (!digits.length) {
+        return [];
+    }
+    return digits.map((maxValue, index) => ({
+        id: index,
+        maxValue: maxValue || 0
+    }));
+}
+function warnMissingSlot(mapId, slotId, group, max) {
+    if (max <= 1) {
+        return;
+    }
+    const key = `${mapId}:${slotId}`;
+    if (missingSlotWarnings.has(key)) {
+        return;
+    }
+    missingSlotWarnings.add(key);
+    log(`Upgrade slot ${slotId} (map ${mapId}, group ${group}) is missing encoder metadata and will decode as 0.`);
+}
+function clamp(value, maxValue) {
+    if (!Number.isFinite(value)) {
+        return 0;
+    }
+    if (maxValue <= 0) {
+        return 0;
+    }
+    if (value < 0) {
+        return 0;
+    }
+    if (value > maxValue) {
+        return maxValue;
+    }
+    return Math.trunc(value);
+}
+function decodeEncoderValues(entries, payload) {
+    if (payload.length < 8) {
+        throw new Error("Upgrade payload must be 8 bytes.");
+    }
+    const total = payload.readBigUInt64BE(0);
+    const values = entries.map(() => 0);
+    let remainder = total;
+    for (let i = entries.length - 1; i >= 0; i--) {
+        const baseValue = entries[i].maxValue || 0;
+        const base = BigInt(baseValue + 1);
+        if (base === BigInt(0)) {
+            values[i] = 0;
+            continue;
+        }
+        const digit = remainder % base;
+        values[i] = Number(digit);
+        remainder = remainder / base;
+    }
+    return values;
+}
+export function encodeUpgradePayload(mapId, overrides, basePayload) {
+    if (!overrides || !overrides.length) {
+        throw new Error("No upgrades specified.");
+    }
+    const definition = getDefinition(mapId);
+    const entries = getDigitEntries(definition.map);
+    const values = basePayload && basePayload.length >= 8 ? decodeEncoderValues(entries, basePayload) : entries.map(() => 0);
+    const slotLookup = buildSlotLookup(definition);
+    for (const override of overrides) {
+        const rawValue = override.value;
+        if (rawValue === undefined) {
+            continue;
+        }
+        const slotDef = slotLookup.get(override.id);
+        if (!slotDef) {
+            throw new Error(`Upgrade ${override.id} is not valid for map ${mapId}.`);
+        }
+        if (typeof slotDef.digitId !== "number") {
+            throw new Error(`Upgrade ${override.id} cannot be written because encoder metadata is missing.`);
+        }
+        const entry = entries[slotDef.digitId];
+        if (!entry) {
+            continue;
+        }
+        const maxValue = entry.maxValue;
+        const normalized = normalizeOverrideValue(rawValue, maxValue, slotDef.id);
+        if (normalized === undefined) {
+            continue;
+        }
+        values[slotDef.digitId] = normalized;
+    }
+    let total = BigInt(0);
+    let multiplier = BigInt(1);
+    for (let i = entries.length - 1; i >= 0; i--) {
+        total += BigInt(values[i]) * multiplier;
+        const base = BigInt((entries[i].maxValue || 0) + 1);
+        multiplier *= base === BigInt(0) ? BigInt(1) : base;
+    }
+    const buffer = Buffer.alloc(8);
+    buffer.writeBigUInt64BE(total);
+    return buffer;
+}
+function buildOverridesFromPreset(preset) {
+    var _a;
+    const overrides = [];
+    for (const group of GROUPS) {
+        const slots = preset[group];
+        if (!slots) {
+            continue;
+        }
+        for (const slot of slots) {
+            if (typeof slot.digitId !== "number") {
+                continue;
+            }
+            overrides.push({
+                id: slot.id,
+                value: (_a = slot.value) !== null && _a !== void 0 ? _a : 0
+            });
+        }
+    }
+    return overrides;
+}
+export function getPresetOverrides(mapId, step) {
+    const definition = findUpgradeDefinition(mapId);
+    if (!definition || !definition.presets) {
+        return undefined;
+    }
+    const preset = definition.presets[`step${step}`];
+    if (!preset) {
+        return undefined;
+    }
+    const overrides = buildOverridesFromPreset(preset);
+    return overrides.length ? overrides : undefined;
+}
+export function encodePresetPayload(mapId, step) {
+    const overrides = getPresetOverrides(mapId, step);
+    if (!overrides) {
+        return undefined;
+    }
+    return encodeUpgradePayload(mapId, overrides);
+}
+function normalizeOverrideValue(value, maxValue, slotId) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (typeof value === "boolean") {
+        return value ? maxValue : 0;
+    }
+    if (typeof value === "number") {
+        return clamp(value, maxValue);
+    }
+    throw new Error(`Invalid override for ${slotId}: expected boolean or number.`);
+}
+export function listUpgradeSlots(mapId) {
+    var _a;
+    const definition = findUpgradeDefinition(mapId);
+    if (!definition) {
+        return [];
+    }
+    const slots = [];
+    for (const group of GROUPS) {
+        for (const slot of ((_a = definition.slots[group]) !== null && _a !== void 0 ? _a : []).slice().sort((a, b) => a.slot - b.slot)) {
+            const label = getUpgradeLabel(slot.id);
+            slots.push({
+                ...slot,
+                ...(label ? { label } : {}),
+                group
+            });
+        }
+    }
+    return slots;
+}
+export function decodeUpgradePayload(mapId, payload) {
+    var _a, _b;
+    if (!payload || payload.length < 8) {
+        throw new Error("Upgrade payload must be 8 bytes.");
+    }
+    const definition = getDefinition(mapId);
+    const entries = getDigitEntries(definition.map);
+    const entryValues = decodeEncoderValues(entries, payload);
+    const states = [];
+    for (const group of GROUPS) {
+        for (const slot of ((_a = definition.slots[group]) !== null && _a !== void 0 ? _a : []).slice().sort((a, b) => a.slot - b.slot)) {
+            const digitId = typeof slot.digitId === "number" ? slot.digitId : undefined;
+            const value = digitId !== undefined ? (_b = entryValues[digitId]) !== null && _b !== void 0 ? _b : 0 : 0;
+            if (digitId === undefined) {
+                warnMissingSlot(mapId, slot.id, group, slot.max);
+            }
+            const label = getUpgradeLabel(slot.id);
+            states.push({
+                ...slot,
+                ...(label ? { label } : {}),
+                group,
+                value
+            });
+        }
+    }
+    return states;
+}

package/dist/vehicle-map.d.ts

@@ -0,0 +1,2 @@
+import { VehicleId } from "./ids.js";
+export declare const VEHICLE_MAP_BY_ID: Record<VehicleId, number>;

package/dist/vehicle-map.js

@@ -0,0 +1,246 @@
+export const VEHICLE_MAP_BY_ID = {
+    [0]: 0,
+    [1000]: 1,
+    [1001]: 1,
+    [1002]: 1,
+    [1003]: 1,
+    [1004]: 1,
+    [1005]: 1,
+    [1006]: 1,
+    [1007]: 1,
+    [1008]: 1,
+    [1009]: 1,
+    [1010]: 1,
+    [1011]: 1,
+    [1012]: 1,
+    [1013]: 1,
+    [1014]: 1,
+    [1015]: 2,
+    [1016]: 2,
+    [1017]: 2,
+    [1018]: 1,
+    [1019]: 1,
+    [1020]: 1,
+    [1021]: 1,
+    [1022]: 1,
+    [1023]: 1,
+    [1024]: 1,
+    [1025]: 1,
+    [1026]: 1,
+    [1027]: 2,
+    [1028]: 2,
+    [1029]: 2,
+    [1030]: 1,
+    [1031]: 1,
+    [1032]: 1,
+    [1033]: 1,
+    [1034]: 1,
+    [1035]: 1,
+    [1036]: 4,
+    [1037]: 4,
+    [1038]: 4,
+    [1039]: 1,
+    [1040]: 1,
+    [1041]: 1,
+    [1042]: 2,
+    [1043]: 2,
+    [1044]: 2,
+    [1045]: 1,
+    [1046]: 1,
+    [1047]: 1,
+    [1048]: 1,
+    [1049]: 1,
+    [1050]: 1,
+    [1051]: 2,
+    [1052]: 2,
+    [1053]: 2,
+    [1054]: 1,
+    [1055]: 1,
+    [1056]: 1,
+    [1057]: 1,
+    [1058]: 1,
+    [1059]: 1,
+    [1060]: 1,
+    [1061]: 1,
+    [1062]: 1,
+    [1063]: 1,
+    [1064]: 1,
+    [1065]: 1,
+    [1066]: 1,
+    [1067]: 1,
+    [1068]: 1,
+    [1069]: 1,
+    [1070]: 1,
+    [1071]: 1,
+    [1072]: 1,
+    [1073]: 1,
+    [1074]: 1,
+    [1075]: 1,
+    [1076]: 1,
+    [1077]: 1,
+    [1078]: 1,
+    [1079]: 1,
+    [1080]: 1,
+    [1081]: 6,
+    [1082]: 6,
+    [1083]: 6,
+    [1084]: 3,
+    [1085]: 3,
+    [1086]: 3,
+    [1087]: 7,
+    [1088]: 7,
+    [1089]: 7,
+    [1090]: 1,
+    [1091]: 1,
+    [1092]: 1,
+    [1093]: 1,
+    [1094]: 1,
+    [1095]: 1,
+    [1096]: 1,
+    [1097]: 1,
+    [1098]: 1,
+    [1099]: 1,
+    [1100]: 1,
+    [1101]: 1,
+    [1102]: 1,
+    [1103]: 1,
+    [1104]: 1,
+    [1105]: 1,
+    [1106]: 1,
+    [1107]: 1,
+    [1108]: 1,
+    [1109]: 1,
+    [1110]: 1,
+    [1111]: 1,
+    [1112]: 1,
+    [1113]: 1,
+    [1114]: 1,
+    [1115]: 1,
+    [1116]: 1,
+    [1117]: 1,
+    [1118]: 1,
+    [1119]: 1,
+    [1120]: 1,
+    [1121]: 1,
+    [1122]: 1,
+    [1123]: 6,
+    [1124]: 6,
+    [1125]: 6,
+    [1132]: 1,
+    [1133]: 1,
+    [1134]: 1,
+    [1144]: 1,
+    [1145]: 1,
+    [1146]: 1,
+    [1155]: 5,
+    [1156]: 5,
+    [1157]: 5,
+    [1158]: 1,
+    [1159]: 1,
+    [1160]: 1,
+    [1161]: 1,
+    [1162]: 1,
+    [1163]: 1,
+    [1164]: 1,
+    [1165]: 1,
+    [1166]: 1,
+    [1167]: 1,
+    [1168]: 1,
+    [1169]: 1,
+    [1170]: 1,
+    [1171]: 1,
+    [1172]: 1,
+    [1173]: 1,
+    [1174]: 1,
+    [1175]: 1,
+    [1176]: 1,
+    [1177]: 1,
+    [1178]: 1,
+    [1179]: 1,
+    [1180]: 1,
+    [1181]: 1,
+    [1182]: 1,
+    [1183]: 1,
+    [1184]: 1,
+    [1185]: 1,
+    [1186]: 1,
+    [1187]: 1,
+    [1188]: 1,
+    [1189]: 1,
+    [1190]: 1,
+    [1191]: 1,
+    [1192]: 1,
+    [1193]: 1,
+    [1194]: 1,
+    [1195]: 1,
+    [1196]: 1,
+    [1197]: 1,
+    [1198]: 1,
+    [1199]: 1,
+    [1200]: 1,
+    [1201]: 1,
+    [1202]: 1,
+    [1203]: 1,
+    [1204]: 1,
+    [1205]: 1,
+    [1206]: 1,
+    [1207]: 1,
+    [1208]: 1,
+    [1209]: 1,
+    [1210]: 1,
+    [1211]: 1,
+    [1212]: 1,
+    [1213]: 1,
+    [1214]: 1,
+    [1215]: 1,
+    [1216]: 1,
+    [1217]: 1,
+    [1218]: 1,
+    [1219]: 1,
+    [1220]: 1,
+    [1221]: 1,
+    [1222]: 1,
+    [1223]: 1,
+    [1224]: 1,
+    [1225]: 1,
+    [1226]: 1,
+    [1227]: 1,
+    [1228]: 1,
+    [1229]: 1,
+    [1230]: 1,
+    [1231]: 1,
+    [1232]: 1,
+    [1233]: 1,
+    [1234]: 1,
+    [1235]: 1,
+    [1236]: 1,
+    [1237]: 1,
+    [1238]: 1,
+    [1239]: 1,
+    [1240]: 1,
+    [1241]: 1,
+    [1242]: 1,
+    [1243]: 1,
+    [1244]: 1,
+    [1245]: 1,
+    [1246]: 1,
+    [1247]: 1,
+    [1248]: 1,
+    [1249]: 1,
+    [1250]: 1,
+    [1251]: 1,
+    [1252]: 1,
+    [1253]: 1,
+    [1254]: 1,
+    [1255]: 1,
+    [1256]: 1,
+    [1257]: 1,
+    [1258]: 1,
+    [1259]: 1,
+    [1260]: 1,
+    [1261]: 1,
+    [1262]: 1,
+    [1263]: 1,
+    [1264]: 1,
+    [1265]: 1,
+};

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "node-toypad",
+  "version": "2.0.0",
+  "description": "A JavaScript module to control the LEGO Dimensions ToyPad",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "scripts": {
+    "build": "tsc -b",
+    "clean": "rimraf dist",
+    "prepare": "npm run build",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "test:connection": "node tests/toypad-connection-test.js"
+  },
+  "author": "Nathan Kellenicki <nathan@kellenicki.com>",
+  "license": "MIT",
+  "files": [
+    "dist",
+    "data"
+  ],
+  "dependencies": {
+    "debug": "^4.4.3",
+    "node-hid": "^3.2.0"
+  },
+  "devDependencies": {
+    "@types/debug": "^4.1.12",
+    "@types/node": "^25.0.3",
+    "@vitest/coverage-v8": "^4.0.16",
+    "rimraf": "^6.1.2",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.16"
+  }
+}