incyclist-devices 2.2.10-beta.0 → 2.3.0-beta.10

package/lib/direct-connect/messages/CharacteristicNotification.d.ts

@@ -0,0 +1,12 @@
+import { EmptyBody, TDCBody, TDCResponse } from "../types";
+import { Message } from "./message";
+export type TDCCharacteristicNotification = TDCResponse<TDCCharacteristicNotificationBody>;
+export interface TDCCharacteristicNotificationBody extends TDCBody {
+    characteristicUUID: string;
+    characteristicData: Uint8Array;
+}
+export declare class CharacteristicNotificationMessage extends Message<EmptyBody, TDCCharacteristicNotificationBody> {
+    constructor(seqNum?: number);
+    buildResponseBody(body: TDCCharacteristicNotificationBody): Buffer;
+    parseResponseBody(body: Buffer): TDCCharacteristicNotificationBody;
+}

package/lib/direct-connect/messages/CharacteristicNotification.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CharacteristicNotificationMessage = void 0;
+const consts_1 = require("../consts");
+const message_1 = require("./message");
+class CharacteristicNotificationMessage extends message_1.Message {
+    constructor(seqNum) {
+        super(consts_1.DC_MESSAGE_CHARACTERISTIC_NOTIFICATION);
+    }
+    buildResponseBody(body) {
+        return Buffer.concat([Buffer.from(body.characteristicUUID, "hex"),
+            Buffer.from(body.characteristicData)]);
+    }
+    parseResponseBody(body) {
+        const characteristicUUID = Buffer.from(body.subarray(0, 16)).toString("hex");
+        const characteristicData = body.subarray(16, body.length);
+        return {
+            characteristicUUID,
+            characteristicData,
+        };
+    }
+}
+exports.CharacteristicNotificationMessage = CharacteristicNotificationMessage;

package/lib/direct-connect/messages/DiscoverCharacteristics.d.ts

@@ -0,0 +1,22 @@
+import { BleProperty } from "../../ble/types";
+import { TDCBody, TDCRequest, TDCResponse } from "../types";
+import { Message } from "./message";
+export type TDCDiscoverCharacteristicsRequest = TDCRequest<TDCDiscoverCharacteristicsRequestBody>;
+export type TDCDiscoverCharacteristicsResponse = TDCResponse<TDCDiscoverCharacteristicsResponseBody>;
+export interface TDCDiscoverCharacteristicsRequestBody extends TDCBody {
+    serviceUUID: string;
+}
+export interface TDCDiscoverCharacteristicsResponseBody extends TDCBody {
+    serviceUUID: string;
+    characteristicDefinitions: Array<{
+        characteristicUUID: string;
+        properties: BleProperty[];
+    }>;
+}
+export declare class DiscoverCharacteristicsMessage extends Message<TDCDiscoverCharacteristicsRequestBody, TDCDiscoverCharacteristicsResponseBody> {
+    constructor();
+    parseRequestBody(body: Buffer): TDCDiscoverCharacteristicsRequestBody;
+    buildRequestBody(body: TDCDiscoverCharacteristicsRequestBody): Buffer;
+    buildResponseBody(body: TDCDiscoverCharacteristicsResponseBody): Buffer;
+    parseResponseBody(body: Buffer): TDCDiscoverCharacteristicsResponseBody;
+}

package/lib/direct-connect/messages/DiscoverCharacteristics.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiscoverCharacteristicsMessage = void 0;
+const utils_1 = require("../../ble/utils");
+const consts_1 = require("../consts");
+const message_1 = require("./message");
+class DiscoverCharacteristicsMessage extends message_1.Message {
+    constructor() {
+        super(consts_1.DC_MESSAGE_DISCOVER_CHARACTERISTICS);
+    }
+    parseRequestBody(body) {
+        const serviceUUID = body.subarray(0, 16).toString("hex");
+        return {
+            serviceUUID,
+        };
+    }
+    buildRequestBody(body) {
+        return Buffer.from(body.serviceUUID, "hex");
+    }
+    buildResponseBody(body) {
+        const serviceUUIDBuffer = Buffer.from(body.serviceUUID, "hex");
+        const characteristicBuffers = body.characteristicDefinitions.map((charDef) => Buffer.concat([
+            Buffer.from(charDef.characteristicUUID, "hex"),
+            Buffer.from([(0, utils_1.propertyVal)(charDef.properties)]),
+        ]));
+        return Buffer.concat([serviceUUIDBuffer, ...characteristicBuffers]);
+    }
+    parseResponseBody(body) {
+        const length = body.length;
+        const serviceUUID = body.subarray(0, 16).toString("hex");
+        const characteristicDefinitions = [];
+        for (let i = 16; i < length; i += 17) {
+            const characteristicUUID = Buffer.from(body.subarray(i, i + 16)).toString("hex");
+            const properties = (0, utils_1.propertyFromVal)(body.readUInt8(i + 16));
+            characteristicDefinitions.push({ characteristicUUID, properties });
+        }
+        return {
+            serviceUUID,
+            characteristicDefinitions,
+        };
+    }
+}
+exports.DiscoverCharacteristicsMessage = DiscoverCharacteristicsMessage;

package/lib/direct-connect/messages/DiscoverServices.d.ts

@@ -0,0 +1,15 @@
+import { EmptyBody, TDCBody, TDCMessageHeader, TDCRequest, TDCResponse } from "../types";
+import { Message } from "./message";
+export type TDCDiscoverServicesRequest = TDCRequest<EmptyBody>;
+export type TDCDiscoverServicesResponse = TDCResponse<TDCDiscoverServicesResponseBody>;
+export interface TDCDiscoverServicesResponseBody extends TDCBody {
+    serviceDefinitions: Array<{
+        serviceUUID: string;
+    }>;
+}
+export declare class DiscoverServiceMessage extends Message<EmptyBody, TDCDiscoverServicesResponseBody> {
+    constructor();
+    buildResponseBody(body: TDCDiscoverServicesResponseBody): Buffer;
+    parseResponseBody(body: Buffer): TDCDiscoverServicesResponseBody;
+    verifyHeader(header: TDCMessageHeader): boolean;
+}

package/lib/direct-connect/messages/DiscoverServices.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiscoverServiceMessage = void 0;
+const consts_1 = require("../consts");
+const error_1 = require("./error");
+const message_1 = require("./message");
+class DiscoverServiceMessage extends message_1.Message {
+    constructor() {
+        super(consts_1.DC_MESSAGE_DISCOVER_SERVICES);
+    }
+    buildResponseBody(body) {
+        const serviceBuffers = body.serviceDefinitions.map((service) => {
+            return Buffer.from(service.serviceUUID, "hex");
+        });
+        return Buffer.concat(serviceBuffers);
+    }
+    parseResponseBody(body) {
+        const serviceDefinitions = [];
+        const length = body.length;
+        for (let i = 0; i < length; i += 16) {
+            const serviceUUID = body.subarray(i, i + 16).toString("hex");
+            serviceDefinitions.push({ serviceUUID });
+        }
+        return { serviceDefinitions };
+    }
+    verifyHeader(header) {
+        if (header.msgId !== consts_1.DC_MESSAGE_DISCOVER_SERVICES) {
+            throw new error_1.IllegalMessageError(consts_1.DC_ERROR_INVALID_MESSAGE_TYPE);
+        }
+        return super.verifyHeader(header);
+    }
+}
+exports.DiscoverServiceMessage = DiscoverServiceMessage;

package/lib/direct-connect/messages/EnableCharacteristicNotifications.d.ts

@@ -0,0 +1,18 @@
+import { TDCBody, TDCRequest, TDCResponse } from "../types";
+import { Message } from "./message";
+export type TDCEnableCharacteristicNotificationsRequest = TDCRequest<TDCEnableCharacteristicNotificationsRequestBody>;
+export type TDCEnableCharacteristicNotificationsResponse = TDCResponse<TDCEnableCharacteristicNotificationsResponseBody>;
+export interface TDCEnableCharacteristicNotificationsRequestBody extends TDCBody {
+    characteristicUUID: string;
+    enable: boolean;
+}
+export interface TDCEnableCharacteristicNotificationsResponseBody extends TDCBody {
+    characteristicUUID: string;
+}
+export declare class EnableCharacteristicNotificationsMessage extends Message<TDCEnableCharacteristicNotificationsRequestBody, TDCEnableCharacteristicNotificationsResponseBody> {
+    constructor();
+    buildRequestBody(body: TDCEnableCharacteristicNotificationsRequestBody): Buffer;
+    buildResponseBody(body: TDCEnableCharacteristicNotificationsResponseBody): Buffer;
+    parseRequestBody(body: Buffer): TDCEnableCharacteristicNotificationsRequestBody;
+    parseResponseBody(body: Buffer): TDCEnableCharacteristicNotificationsResponseBody;
+}

package/lib/direct-connect/messages/EnableCharacteristicNotifications.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnableCharacteristicNotificationsMessage = void 0;
+const consts_1 = require("../consts");
+const message_1 = require("./message");
+class EnableCharacteristicNotificationsMessage extends message_1.Message {
+    constructor() {
+        super(consts_1.DC_MESSAGE_ENABLE_CHARACTERISTIC_NOTIFICATIONS);
+    }
+    buildRequestBody(body) {
+        const enabledVal = body.enable ? 1 : 0;
+        return Buffer.concat([
+            Buffer.from(body.characteristicUUID, "hex"),
+            Buffer.from([enabledVal])
+        ]);
+    }
+    buildResponseBody(body) {
+        return Buffer.from(body.characteristicUUID, "hex");
+    }
+    parseRequestBody(body) {
+        const characteristicUUID = Buffer.from(body.subarray(0, 16)).toString("hex");
+        const enabledVal = body.readUInt8(16);
+        const enable = enabledVal !== 0;
+        return {
+            characteristicUUID, enable
+        };
+    }
+    parseResponseBody(body) {
+        const characteristicUUID = Buffer.from(body.subarray(0, 16)).toString("hex");
+        return {
+            characteristicUUID,
+        };
+    }
+}
+exports.EnableCharacteristicNotificationsMessage = EnableCharacteristicNotificationsMessage;

package/lib/direct-connect/messages/ReadCharacteristic.d.ts

@@ -0,0 +1,18 @@
+import { TDCBody, TDCRequest, TDCResponse } from "../types";
+import { Message } from "./message";
+export type TDCReadCharacteristicRequest = TDCRequest<TDCReadCharacteristicRequestBody>;
+export type TDCReadCharacteristicResponse = TDCResponse<TDCReadCharacteristicResponseBody>;
+export interface TDCReadCharacteristicRequestBody extends TDCBody {
+    characteristicUUID: string;
+}
+export interface TDCReadCharacteristicResponseBody extends TDCBody {
+    characteristicUUID: string;
+    characteristicData: Uint8Array;
+}
+export declare class ReadCharacteristicMessage extends Message<TDCReadCharacteristicRequestBody, TDCReadCharacteristicResponseBody> {
+    constructor();
+    buildRequestBody(body: TDCReadCharacteristicRequestBody): Buffer;
+    buildResponseBody(body: TDCReadCharacteristicResponseBody): Buffer;
+    parseRequestBody(body: Buffer): TDCReadCharacteristicRequestBody;
+    parseResponseBody(body: Buffer): TDCReadCharacteristicResponseBody;
+}

package/lib/direct-connect/messages/ReadCharacteristic.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReadCharacteristicMessage = void 0;
+const consts_1 = require("../consts");
+const message_1 = require("./message");
+class ReadCharacteristicMessage extends message_1.Message {
+    constructor() {
+        super(consts_1.DC_MESSAGE_READ_CHARACTERISTIC);
+    }
+    buildRequestBody(body) {
+        return Buffer.from(body.characteristicUUID, "hex");
+    }
+    buildResponseBody(body) {
+        return Buffer.concat([
+            Buffer.from(body.characteristicUUID, "hex"),
+            Buffer.from(body.characteristicData),
+        ]);
+    }
+    parseRequestBody(body) {
+        const characteristicUUID = Buffer.from(body.subarray(0, 16)).toString("hex");
+        return {
+            characteristicUUID,
+        };
+    }
+    parseResponseBody(body) {
+        const characteristicUUID = Buffer.from(body.subarray(0, 16)).toString("hex");
+        const characteristicData = body.subarray(16, body.length);
+        return {
+            characteristicUUID,
+            characteristicData,
+        };
+    }
+}
+exports.ReadCharacteristicMessage = ReadCharacteristicMessage;

package/lib/direct-connect/messages/WriteCharacteristic.d.ts

@@ -0,0 +1,18 @@
+import { TDCBody, TDCRequest, TDCResponse } from "../types";
+import { Message } from "./message";
+export type TDCWriteCharacteristicRequest = TDCRequest<TDCWriteCharacteristicRequestBody>;
+export type TDCWriteCharacteristicResponse = TDCResponse<TDCWriteCharacteristicResponseBody>;
+export interface TDCWriteCharacteristicRequestBody extends TDCBody {
+    characteristicUUID: string;
+    characteristicData: Uint8Array;
+}
+export interface TDCWriteCharacteristicResponseBody extends TDCBody {
+    characteristicUUID: string;
+}
+export declare class WriteCharacteristicMessage extends Message<TDCWriteCharacteristicRequestBody, TDCWriteCharacteristicResponseBody> {
+    constructor();
+    buildRequestBody(body: TDCWriteCharacteristicRequestBody): Buffer;
+    buildResponseBody(body: TDCWriteCharacteristicResponseBody): Buffer;
+    parseRequestBody(body: Buffer): TDCWriteCharacteristicRequestBody;
+    parseResponseBody(body: Buffer): TDCWriteCharacteristicResponseBody;
+}

package/lib/direct-connect/messages/WriteCharacteristic.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WriteCharacteristicMessage = void 0;
+const consts_1 = require("../consts");
+const message_1 = require("./message");
+class WriteCharacteristicMessage extends message_1.Message {
+    constructor() {
+        super(consts_1.DC_MESSAGE_WRITE_CHARACTERISTIC);
+    }
+    buildRequestBody(body) {
+        return Buffer.concat([
+            Buffer.from(body.characteristicUUID, "hex"),
+            Buffer.from(body.characteristicData),
+        ]);
+    }
+    buildResponseBody(body) {
+        return Buffer.concat([
+            Buffer.from(body.characteristicUUID, "hex"),
+        ]);
+    }
+    parseRequestBody(body) {
+        const characteristicUUID = Buffer.from(body.subarray(0, 16)).toString("hex");
+        const characteristicData = body.subarray(16, body.length);
+        return {
+            characteristicUUID,
+            characteristicData,
+        };
+    }
+    parseResponseBody(body) {
+        const characteristicUUID = Buffer.from(body.subarray(0, 16)).toString("hex");
+        return {
+            characteristicUUID,
+        };
+    }
+}
+exports.WriteCharacteristicMessage = WriteCharacteristicMessage;

package/lib/direct-connect/messages/error.d.ts

@@ -0,0 +1,5 @@
+export declare class IllegalMessageError extends Error {
+    code: number;
+    constructor(code: number);
+}
+export declare const getResponseCode: (error: IllegalMessageError) => number;

package/lib/direct-connect/messages/error.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getResponseCode = exports.IllegalMessageError = void 0;
+const consts_1 = require("../consts");
+class IllegalMessageError extends Error {
+    constructor(code) {
+        super('Illegal request: ' + code);
+        this.code = code;
+        this.name = 'IllegalRequestError';
+    }
+}
+exports.IllegalMessageError = IllegalMessageError;
+const getResponseCode = (error) => {
+    if (error.code === consts_1.DC_ERROR_UNKNOWN_MESSAGE_TYPE)
+        return consts_1.DC_RC_UNKNOWN_MESSAGE_TYPE;
+    return consts_1.DC_RC_UNEXPECTED_ERROR;
+};
+exports.getResponseCode = getResponseCode;

package/lib/direct-connect/messages/factory.d.ts

@@ -0,0 +1,6 @@
+import { Message } from "./message";
+export declare class DCMessageFactory {
+    static createMessage(buffer: Buffer): Message<any, any>;
+    static create(msgId: number): Message<any, any>;
+    static buildErrorResponse(request: Buffer, code: number): Buffer;
+}

package/lib/direct-connect/messages/factory.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DCMessageFactory = void 0;
+const consts_1 = require("../consts");
+const CharacteristicNotification_1 = require("./CharacteristicNotification");
+const DiscoverCharacteristics_1 = require("./DiscoverCharacteristics");
+const DiscoverServices_1 = require("./DiscoverServices");
+const EnableCharacteristicNotifications_1 = require("./EnableCharacteristicNotifications");
+const error_1 = require("./error");
+const ReadCharacteristic_1 = require("./ReadCharacteristic");
+const WriteCharacteristic_1 = require("./WriteCharacteristic");
+class DCMessageFactory {
+    static createMessage(buffer) {
+        if (buffer.length < 6) {
+            throw new error_1.IllegalMessageError(consts_1.DC_ERROR_INVALID_MESSAGE_LENGTH);
+        }
+        const msgId = buffer.readUInt8(1);
+        return this.create(msgId);
+    }
+    static create(msgId) {
+        switch (msgId) {
+            case consts_1.DC_MESSAGE_DISCOVER_SERVICES:
+                return new DiscoverServices_1.DiscoverServiceMessage();
+            case consts_1.DC_MESSAGE_DISCOVER_CHARACTERISTICS:
+                return new DiscoverCharacteristics_1.DiscoverCharacteristicsMessage();
+            case consts_1.DC_MESSAGE_READ_CHARACTERISTIC:
+                return new ReadCharacteristic_1.ReadCharacteristicMessage();
+            case consts_1.DC_MESSAGE_WRITE_CHARACTERISTIC:
+                return new WriteCharacteristic_1.WriteCharacteristicMessage();
+            case consts_1.DC_MESSAGE_ENABLE_CHARACTERISTIC_NOTIFICATIONS:
+                return new EnableCharacteristicNotifications_1.EnableCharacteristicNotificationsMessage();
+            case consts_1.DC_MESSAGE_CHARACTERISTIC_NOTIFICATION:
+                return new CharacteristicNotification_1.CharacteristicNotificationMessage();
+            default:
+                throw new error_1.IllegalMessageError(consts_1.DC_ERROR_UNKNOWN_MESSAGE_TYPE);
+        }
+    }
+    static buildErrorResponse(request, code) {
+        const response = Buffer.from(request);
+        response.writeUInt8(code, 3);
+        return response;
+    }
+}
+exports.DCMessageFactory = DCMessageFactory;

package/lib/direct-connect/messages/index.d.ts

@@ -0,0 +1,9 @@
+export * from './error';
+export * from './message';
+export * from './factory';
+export * from './DiscoverServices';
+export * from './DiscoverCharacteristics';
+export * from './ReadCharacteristic';
+export * from './WriteCharacteristic';
+export * from './EnableCharacteristicNotifications';
+export * from './CharacteristicNotification';

package/lib/direct-connect/messages/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./error"), exports);
+__exportStar(require("./message"), exports);
+__exportStar(require("./factory"), exports);
+__exportStar(require("./DiscoverServices"), exports);
+__exportStar(require("./DiscoverCharacteristics"), exports);
+__exportStar(require("./ReadCharacteristic"), exports);
+__exportStar(require("./WriteCharacteristic"), exports);
+__exportStar(require("./EnableCharacteristicNotifications"), exports);
+__exportStar(require("./CharacteristicNotification"), exports);

package/lib/direct-connect/messages/message.d.ts

@@ -0,0 +1,21 @@
+import { TDCBody, TDCMessageHeader, TDCRequest, TDCResponse } from "../types";
+export declare class Message<TReq extends TDCBody, TRes extends TDCBody> {
+    msgId?: number;
+    protected request: TDCRequest<TReq>;
+    protected response: TDCResponse<TRes>;
+    constructor(msgId?: number);
+    buildResponse(response: TDCResponse<TRes>): Buffer;
+    buildRequest(request: TDCRequest<TReq>): Buffer;
+    createRequest(seqNum: any, body: TReq): Buffer;
+    parseRequest(buffer: Buffer): TDCRequest<TReq>;
+    prepareResponse(request: TDCRequest<TReq>, respCode: number, body: TRes): TDCResponse<TRes>;
+    parseResponse(buffer: Buffer): TDCResponse<TRes>;
+    buildHeader(header: TDCMessageHeader, length: number): Buffer;
+    buildResponseBody(body: TRes): Buffer;
+    buildRequestBody(body: TReq): Buffer;
+    verifyHeader(header: TDCMessageHeader): boolean;
+    parseRequestBody(body: Buffer): TReq;
+    parseResponseBody(body: Buffer): TRes;
+}
+export declare const parseHeader: (buffer: Buffer) => TDCMessageHeader;
+export declare const RC: (code: any) => string;

package/lib/direct-connect/messages/message.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RC = exports.parseHeader = exports.Message = void 0;
+const consts_1 = require("../consts");
+const error_1 = require("./error");
+class Message {
+    constructor(msgId) {
+        this.msgId = msgId;
+    }
+    buildResponse(response) {
+        const { header, body } = response;
+        const bodyBuffer = this.buildResponseBody(body);
+        const headerBuffer = this.buildHeader(header, bodyBuffer.length);
+        return Buffer.concat([headerBuffer, bodyBuffer]);
+    }
+    buildRequest(request) {
+        const { header, body } = request;
+        const bodyBuffer = this.buildRequestBody(body);
+        const headerBuffer = this.buildHeader(header, bodyBuffer.length);
+        return Buffer.concat([headerBuffer, bodyBuffer]);
+    }
+    createRequest(seqNum, body) {
+        const header = {
+            msgId: this.msgId,
+            seqNum,
+            respCode: 0,
+            msgVersion: 1,
+            length: 0
+        };
+        return this.buildRequest({ header, body });
+    }
+    parseRequest(buffer) {
+        const header = (0, exports.parseHeader)(buffer);
+        this.verifyHeader(header);
+        const bodyBuffer = buffer.subarray(6);
+        const body = this.parseRequestBody(bodyBuffer);
+        return { header, body };
+    }
+    prepareResponse(request, respCode, body) {
+        const header = Object.assign(Object.assign({}, request.header), { respCode });
+        return { header, body };
+    }
+    parseResponse(buffer) {
+        const header = (0, exports.parseHeader)(buffer);
+        this.verifyHeader(header);
+        const bodyBuffer = buffer.subarray(6);
+        const body = this.parseResponseBody(bodyBuffer);
+        return { header, body };
+    }
+    buildHeader(header, length) {
+        const buffer = Buffer.alloc(6);
+        buffer.writeUInt8(header.msgVersion, 0);
+        buffer.writeUInt8(header.msgId, 1);
+        buffer.writeUInt8(header.seqNum, 2);
+        buffer.writeUInt8(header.respCode, 3);
+        buffer.writeUInt16BE(length !== null && length !== void 0 ? length : header.length, 4);
+        return buffer;
+    }
+    buildResponseBody(body) {
+        return Buffer.from([]);
+    }
+    buildRequestBody(body) {
+        return Buffer.from([]);
+    }
+    verifyHeader(header) {
+        if (header.msgId !== this.msgId) {
+            throw new error_1.IllegalMessageError(consts_1.DC_ERROR_INVALID_MESSAGE_TYPE);
+        }
+        return true;
+    }
+    parseRequestBody(body) {
+        return {};
+    }
+    parseResponseBody(body) {
+        return {};
+    }
+}
+exports.Message = Message;
+const parseHeader = (buffer) => {
+    if (buffer.length < 6) {
+        throw new error_1.IllegalMessageError(consts_1.DC_ERROR_INVALID_MESSAGE_LENGTH);
+    }
+    const msgVersion = buffer.readUInt8(0);
+    const msgId = buffer.readUInt8(1);
+    const seqNum = buffer.readUInt8(2);
+    const respCode = buffer.readUInt8(3);
+    const length = buffer.readUInt16BE(4);
+    return { msgVersion, msgId, seqNum, respCode, length };
+};
+exports.parseHeader = parseHeader;
+const RC = (code) => {
+    switch (code) {
+        case consts_1.DC_RC_REQUEST_COMPLETED_SUCCESSFULLY: return 'success';
+        case consts_1.DC_RC_UNKNOWN_MESSAGE_TYPE: return 'Unknown Message Type';
+        case consts_1.DC_RC_UNEXPECTED_ERROR: return 'Unexpected Error';
+        case consts_1.DC_RC_SERVICE_NOT_FOUND: return 'Service Not Found';
+        case consts_1.DC_RC_CHARACTERISTIC_NOT_FOUND: return 'Characteristic Not Found';
+        case consts_1.DC_RC_CHARACTERISTIC_OPERATION_NOT_SUPPORTED: return 'Characteristic Operation Not Supported';
+        case consts_1.DC_RC_CHARACTERISTIC_WRITE_FAILED_INVALID_SIZE: return 'Characteristic Write Failed';
+        case consts_1.DC_RC_UNKNOWN_PROTOCOL_VERSION: return 'Unknown Protocol Version';
+        default:
+            return `Unknown (${code})`;
+    }
+};
+exports.RC = RC;

package/lib/direct-connect/types.d.ts

@@ -0,0 +1,24 @@
+import { IncyclistScanProps } from "../types";
+export interface TDCMessageHeader {
+    msgVersion: number;
+    msgId: number;
+    seqNum: number;
+    respCode: number;
+    length: number;
+}
+export interface TDCBody {
+}
+export declare class TDCRequest<T extends TDCBody> {
+    header: TDCMessageHeader;
+    body: T;
+}
+export declare class TDCResponse<T extends TDCBody> {
+    header: TDCMessageHeader;
+    body: T;
+}
+export interface EmptyBody extends TDCBody {
+}
+export interface DirectConnectScanProps extends IncyclistScanProps {
+    serviceUUID?: string;
+    serviceUUIDs?: string[];
+}

package/lib/direct-connect/types.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TDCResponse = exports.TDCRequest = void 0;
+class TDCRequest {
+}
+exports.TDCRequest = TDCRequest;
+class TDCResponse {
+}
+exports.TDCResponse = TDCResponse;

package/lib/direct-connect/utils.d.ts

@@ -0,0 +1,5 @@
+import { BleProperty } from "../ble/types";
+export declare const parseUUID: (str: string) => string;
+export declare const beautifyUUID: (str: string, withX?: boolean) => string;
+export declare const propertyVal: (properties: BleProperty[]) => number;
+export declare const propertyFromVal: (val: number) => BleProperty[];