incyclist-services 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Incyclist
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.MD

@@ -0,0 +1,28 @@
+# incyclist-services
+
+This Library contains the business logic used by the React components of the [Incyclist](https://incyclist.com) Indoor Cycling App. 
+
+Incyclist uses React to render the App Front-End for PC platforms ( Windows, Mac. Linux). It is planned that in the future, React Native will be used to render the Front-Ends for other platforms ( Android, IOS, AppleTV,...)
+
+All Services will be accessed by the Front-End using 
+
+```
+import {useXXX, initXXX} from {incyclist-devices}
+
+```
+
+- useXXX  can be used to consume a Service (e.g. `useDeviceConfiguration()` ) 
+- initXXX can be used to perform a lazy initialization of the Service (e.g. `initUserSettings(binding)` ) 
+
+where XXX represents the Service name
+
+The following Services are currently implemented in this library:
+
+## Settings
+- [UserSettings](./doc/classes/UserSettingsService.md): manages the user settings 
+
+
+## Devices
+- [DeviceConfiguration](./doc/classes/DeviceConfigurationService.md): manages the user configuration of scanned/added/selected devices
+- [DeviceAccess](./doc/classes/DeviceAccessService.md): manages the basic communication to the device (setting up interfacs, scanning,... )
+- [Device](./src/devices/device/README.MD): allows the Front-End to communicate with a device (reading, writing data)

package/lib/devices/access/index.d.ts

@@ -0,0 +1,2 @@
+export * from './model';
+export * from './service';

package/lib/devices/access/index.js

@@ -0,0 +1,18 @@
+"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("./model"), exports);
+__exportStar(require("./service"), exports);

package/lib/devices/access/model.d.ts

@@ -0,0 +1,24 @@
+import { IncyclistCapability } from "incyclist-devices";
+export type InterfaceState = 'connected' | 'disconnected' | 'unknown' | 'connecting' | 'disconnecting' | 'unavailable';
+export type ScanState = 'start-requested' | 'started' | 'stop-requested' | 'stopped' | 'idle';
+export interface InterfaceInfo {
+    name: string;
+    enabled: boolean;
+    state: InterfaceState;
+    isScanning: boolean;
+    properties?: InterfaceAccessProps;
+}
+export interface InterfaceAccessProps {
+    connectTimeout?: number;
+    scanTimeout?: number;
+    port?: number;
+    protocol?: string;
+    autoConnect?: boolean;
+}
+export interface InterfaceList {
+    [index: string]: InterfaceInfo;
+}
+export interface ScanFilter {
+    interfaces?: string[];
+    capabilities?: (IncyclistCapability | 'bike')[];
+}

package/lib/devices/access/model.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/devices/access/service.d.ts

@@ -0,0 +1,35 @@
+/// <reference types="node" />
+import EventEmitter from "events";
+import { EventLogger } from "gd-eventlog";
+import { DeviceSettings, IncyclistInterface } from "incyclist-devices";
+import { InterfaceList, ScanFilter, InterfaceInfo, InterfaceAccessProps, ScanState } from "./model";
+interface InternalScanState {
+    promises: (Promise<DeviceSettings[]>)[];
+    interfaces: IncyclistInterface[];
+}
+export declare class DeviceAccessService extends EventEmitter {
+    protected static _instance: DeviceAccessService;
+    protected interfaces: InterfaceList;
+    protected scanState: InternalScanState;
+    protected logger: EventLogger;
+    protected defaultProps: InterfaceAccessProps;
+    static getInstance(): DeviceAccessService;
+    constructor();
+    setDefaultInterfaceProperties(props: InterfaceAccessProps): void;
+    enableInterface(ifaceName: string, binding?: any, props?: InterfaceAccessProps): void;
+    disableInterface(ifaceName: string): void;
+    setInterfaceProperties(ifaceName: string, props: InterfaceAccessProps): void;
+    getInterfaceInfo(ifaceName: string): InterfaceInfo;
+    protected getInterface(ifaceName: string): IncyclistInterface;
+    connect(ifaceName: string): Promise<boolean>;
+    disconnect(ifaceName?: string): Promise<boolean>;
+    scan(filter?: ScanFilter): Promise<DeviceSettings[]>;
+    getProtocols(ifaceName: string): string[];
+    protected dummyScan(): Promise<DeviceSettings[]>;
+    protected emitScanStateChange(state: ScanState): void;
+    stopScan(): Promise<boolean>;
+    isScanning(ifaceName?: string): boolean;
+    protected getInterfacesForScan(filter?: ScanFilter): IncyclistInterface[];
+}
+export declare const useDeviceAccess: () => DeviceAccessService;
+export {};

package/lib/devices/access/service.js

@@ -0,0 +1,288 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDeviceAccess = exports.DeviceAccessService = void 0;
+const events_1 = __importDefault(require("events"));
+const gd_eventlog_1 = require("gd-eventlog");
+const incyclist_devices_1 = require("incyclist-devices");
+const clone_1 = __importDefault(require("../../utils/clone"));
+const merge_1 = require("../../utils/merge");
+const sleep_1 = require("../../utils/sleep");
+const configuration_1 = require("../configuration");
+class DeviceAccessService extends events_1.default {
+    static getInstance() {
+        if (!DeviceAccessService._instance)
+            DeviceAccessService._instance = new DeviceAccessService();
+        return DeviceAccessService._instance;
+    }
+    constructor() {
+        super();
+        this.interfaces = {};
+        this.scanState = null;
+        this.logger = new gd_eventlog_1.EventLogger('DeviceAccess');
+        this.defaultProps = {};
+    }
+    setDefaultInterfaceProperties(props) {
+        this.defaultProps = props;
+    }
+    enableInterface(ifaceName, binding, props = {}) {
+        const existing = this.interfaces[ifaceName];
+        if (!binding && !existing) {
+            throw new Error('Interface has not been initialized with binding');
+        }
+        if (!existing) {
+            const properties = (0, clone_1.default)(this.defaultProps);
+            (0, merge_1.merge)(properties, props);
+            const info = { name: ifaceName, interface: incyclist_devices_1.InterfaceFactory.create(ifaceName, { binding }), enabled: true, isScanning: false, properties, state: 'unknown' };
+            this.interfaces[ifaceName] = info;
+            info.interface.setBinding(binding);
+            const keys = Object.keys(this.interfaces);
+            const interfaces = keys.map(name => (Object.assign(Object.assign({}, this.interfaces[name]), { name })));
+            this.emit('interface-changed', ifaceName, this.interfaces[ifaceName], interfaces);
+        }
+        else {
+            if (this.isScanning(ifaceName)) {
+                throw new Error('Illegal State, enable Interface cannot be called during an ongoing scan');
+            }
+            if (binding)
+                existing.interface.setBinding(binding);
+            existing.enabled = true;
+            (0, merge_1.merge)(existing.properties || this.defaultProps, props);
+            this.emit('interface-changed', ifaceName, this.interfaces[ifaceName]);
+        }
+    }
+    disableInterface(ifaceName) {
+        const existing = this.interfaces[ifaceName];
+        if (!existing)
+            return;
+        if (this.isScanning(ifaceName)) {
+            const info = this.interfaces[ifaceName];
+            info.interface.stopScan().then((stopped) => {
+                this.emit('interface-changed', ifaceName, this.interfaces[ifaceName]);
+                info.isScanning = !stopped;
+                if (stopped)
+                    this.disableInterface(ifaceName);
+            });
+            return;
+        }
+        existing.enabled = false;
+        this.emit('interface-changed', ifaceName, this.interfaces[ifaceName]);
+    }
+    setInterfaceProperties(ifaceName, props) {
+        if (this.isScanning(ifaceName)) {
+            const info = this.interfaces[ifaceName];
+            info.interface.stopScan().then((stopped) => {
+                this.emit('interface-changed', 'ifaceName', this.interfaces[ifaceName]);
+                info.isScanning = !stopped;
+                if (stopped)
+                    this.setInterfaceProperties(ifaceName, props);
+            });
+            return;
+        }
+        const info = this.interfaces[ifaceName];
+        if (!info)
+            return;
+        const properties = (0, clone_1.default)(this.defaultProps);
+        (0, merge_1.merge)(properties, props);
+        info.properties = properties;
+        info.isScanning = false;
+        this.emit('interface-changed', 'ifaceName', this.interfaces[ifaceName]);
+    }
+    getInterfaceInfo(ifaceName) {
+        return this.interfaces[ifaceName];
+    }
+    getInterface(ifaceName) {
+        const info = this.interfaces[ifaceName];
+        return info === null || info === void 0 ? void 0 : info.interface;
+    }
+    connect(ifaceName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const impl = this.getInterface(ifaceName);
+            if (!impl) {
+                this.emit('interface-changed', ifaceName, { name: ifaceName, state: 'unavailable', isScanning: false });
+                return false;
+            }
+            const prevState = this.interfaces[ifaceName].state;
+            if (prevState === 'connected')
+                return true;
+            this.interfaces[ifaceName].state = 'connecting';
+            this.emit('interface-changed', ifaceName, this.interfaces[ifaceName]);
+            const connected = yield impl.connect();
+            const state = connected ? 'connected' : 'disconnected';
+            this.interfaces[ifaceName].state = state;
+            this.emit('interface-changed', ifaceName, this.interfaces[ifaceName]);
+            return connected;
+        });
+    }
+    disconnect(ifaceName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!ifaceName) {
+                const promises = Object.keys(this.interfaces).map(i => this.disconnect(i));
+                const result = yield Promise.allSettled(promises);
+                const failed = result.find(res => (res.status === 'rejected' || (res.value === true)));
+                this.removeAllListeners();
+                return failed === undefined;
+            }
+            const impl = this.getInterface(ifaceName);
+            if (!impl)
+                return true;
+            const prevState = this.interfaces[ifaceName].state;
+            this.interfaces[ifaceName].state = 'disconnecting';
+            this.emit('interface-changed', ifaceName, this.interfaces[ifaceName]);
+            const disconnected = yield impl.disconnect();
+            const state = disconnected ? 'disconnected' : prevState;
+            this.interfaces[ifaceName].state = state;
+            this.emit('interface-changed', ifaceName, this.interfaces[ifaceName]);
+            return disconnected;
+        });
+    }
+    scan(filter = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.logEvent({ message: 'device scan start', filter });
+            const detected = [];
+            const startedAdapters = [];
+            if (!this.isScanning()) {
+                this.emitScanStateChange('start-requested');
+                this.scanState = {
+                    promises: [],
+                    interfaces: []
+                };
+                const interfaces = this.scanState.interfaces = this.getInterfacesForScan(filter);
+                const adapters = [];
+                interfaces.forEach((i) => {
+                    i.on('device', (deviceSettings) => __awaiter(this, void 0, void 0, function* () {
+                        if (adapters.find(a => a.isEqual(deviceSettings)))
+                            return;
+                        this.emit('device', deviceSettings);
+                        const adapter = incyclist_devices_1.AdapterFactory.create(deviceSettings);
+                        adapters.push(adapter);
+                        adapter.on('device-info', (settings, info) => {
+                            this.emit('device-info', deviceSettings, Object.assign(Object.assign({}, info), { displayName: adapter.getUniqueName() }));
+                        });
+                        detected.push(deviceSettings);
+                        if (adapter.getSettings().interface !== 'ble') {
+                            try {
+                                yield adapter.start();
+                                while (this.scanState) {
+                                    yield (0, sleep_1.sleep)(100);
+                                }
+                                yield adapter.stop();
+                            }
+                            catch (err) {
+                                console.log('~~~ start error', err);
+                            }
+                        }
+                    }));
+                    const ifaceName = i.getName();
+                    const info = this.interfaces[ifaceName];
+                    info.isScanning = true;
+                    const props = info.properties || this.defaultProps;
+                    const { scanTimeout, port, protocol } = props;
+                    const properties = ifaceName === 'tcpip' || ifaceName === 'serial' ? { timeout: scanTimeout, port: port === null || port === void 0 ? void 0 : port.toString(), protocol } : { timeout: scanTimeout };
+                    this.scanState.promises.push(i.scan(properties));
+                });
+                this.emitScanStateChange('started');
+                try {
+                    if (this.scanState.promises.length === 0) {
+                        this.scanState.promises.push(this.dummyScan());
+                    }
+                    yield Promise.allSettled(this.scanState.promises);
+                }
+                catch (err) {
+                    this.logger.logEvent({ message: 'device scan finished with errors', filter, error: err.message, stack: err.stack });
+                }
+                this.scanState = null;
+                interfaces.forEach((i) => {
+                    i.removeAllListeners('device');
+                    this.interfaces[i.getName()].isScanning = false;
+                    if (i.getName() === 'tcpip')
+                        this.interfaces[i.getName()];
+                });
+                this.emitScanStateChange('stopped');
+                this.logger.logEvent({ message: 'device scan finished', filter, detected });
+                return detected;
+            }
+        });
+    }
+    getProtocols(ifaceName) {
+        if (ifaceName !== 'serial' && ifaceName !== 'tcpip')
+            return [];
+        if (ifaceName === 'tcpip')
+            return ['Daum Premium'];
+        return incyclist_devices_1.SerialAdapterFactory.getInstance().adapters.map(a => a.protocol);
+    }
+    dummyScan() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise(done => {
+                const timeout = this.defaultProps.scanTimeout || 5000;
+                const timeDone = Date.now() + timeout;
+                const iv = setInterval(() => {
+                    if (Date.now() > timeDone) {
+                        clearInterval(iv);
+                        done([]);
+                    }
+                }, 100);
+                this.once('stop-requested', () => {
+                    clearInterval(iv);
+                    done([]);
+                });
+            });
+        });
+    }
+    emitScanStateChange(state) {
+        this.emit('scanstate-changed', state);
+    }
+    stopScan() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isScanning())
+                return;
+            this.emitScanStateChange('stop-requested');
+            const interfaces = this.scanState.interfaces;
+            const promises = interfaces.map(i => i.stopScan().catch());
+            let result;
+            try {
+                result = yield Promise.allSettled(promises);
+            }
+            catch (err) {
+                this.logger.logEvent({ message: 'stop device scan finished with errors', error: err.message, stack: err.stack });
+                return false;
+            }
+            this.scanState.promises = [];
+            this.emitScanStateChange('stopped');
+            this.logger.logEvent({ message: 'stop device scan finished', stopScanresult: result });
+            return true;
+        });
+    }
+    isScanning(ifaceName) {
+        if (!ifaceName)
+            return this.scanState !== null && this.scanState.promises !== null && this.scanState.promises.length > 0;
+        else
+            return this.interfaces[ifaceName].isScanning;
+    }
+    getInterfacesForScan(filter) {
+        const keys = Object.keys(this.interfaces);
+        const config = (0, configuration_1.useDeviceConfiguration)();
+        const enabledInterfaces = keys.filter(i => this.interfaces[i].enabled && config.isInterfaceEnabled(i));
+        const interfaceFilter = filter === null || filter === void 0 ? void 0 : filter.interfaces;
+        let interfaces = enabledInterfaces.map(name => this.interfaces[name].interface);
+        if (interfaceFilter) {
+            const remaining = enabledInterfaces.filter(i => interfaceFilter.includes(i));
+            interfaces = remaining.map(name => this.interfaces[name].interface);
+        }
+        return interfaces;
+    }
+}
+exports.DeviceAccessService = DeviceAccessService;
+const useDeviceAccess = () => DeviceAccessService.getInstance();
+exports.useDeviceAccess = useDeviceAccess;

package/lib/devices/configuration/index.d.ts

@@ -0,0 +1,2 @@
+export * from './model';
+export * from './service';

package/lib/devices/configuration/index.js

@@ -0,0 +1,18 @@
+"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("./model"), exports);
+__exportStar(require("./service"), exports);

package/lib/devices/configuration/model/app/index.d.ts

@@ -0,0 +1,17 @@
+import { IncyclistCapability } from 'incyclist-devices';
+export type ExtendedIncyclistCapability = IncyclistCapability | 'bike';
+export interface DeviceInformation {
+    udid: string;
+    name: string;
+    selected: boolean;
+    mode?: string;
+    modeSetting?: any;
+}
+export interface CapabilityInformation {
+    capability: ExtendedIncyclistCapability;
+    devices: DeviceInformation[];
+    disabled: boolean;
+}
+export interface DeviceConfigurationInfo {
+    [index: string]: CapabilityInformation;
+}

package/lib/devices/configuration/model/app/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/devices/configuration/model/index.d.ts

@@ -0,0 +1,3 @@
+export * from './app';
+export * from './repository';
+export * from './service';

package/lib/devices/configuration/model/index.js

@@ -0,0 +1,19 @@
+"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("./app"), exports);
+__exportStar(require("./repository"), exports);
+__exportStar(require("./service"), exports);

package/lib/devices/configuration/model/repository/index.d.ts

@@ -0,0 +1,35 @@
+import { SerialDeviceSettings, AntDeviceSettings, BleDeviceSettings } from 'incyclist-devices';
+import { ExtendedIncyclistCapability } from '../app';
+export type IncyclistDeviceSettings = SerialDeviceSettings | AntDeviceSettings | BleDeviceSettings;
+export * from './legacy';
+export interface DeviceListEntry {
+    udid: string;
+    settings: IncyclistDeviceSettings;
+    displayName?: string;
+    mode?: string;
+    modes?: {
+        [index: string]: any;
+    };
+}
+export interface InterfaceSetting {
+    name: string;
+    enabled: boolean;
+    port?: number | string;
+    protocol?: string;
+}
+export interface ModeListEntry {
+    mid: string;
+    mode: string;
+    setting: any;
+}
+export type CapabilitySetting = {
+    selected: string | undefined;
+    capability: ExtendedIncyclistCapability;
+    disabled?: boolean;
+    devices: string[];
+};
+export interface DeviceConfigurationSettings {
+    interfaces?: InterfaceSetting[];
+    capabilities?: CapabilitySetting[];
+    devices?: DeviceListEntry[];
+}

package/lib/devices/configuration/model/repository/index.js

@@ -0,0 +1,17 @@
+"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("./legacy"), exports);

package/lib/devices/configuration/model/repository/legacy.d.ts

@@ -0,0 +1,57 @@
+export interface LegacyGearSetting {
+    name: string;
+    displayName?: string;
+    selected: boolean;
+    protocol: string;
+    deviceID?: string;
+    profile?: string;
+    host?: string;
+    port?: string;
+    interface: string;
+}
+export interface LegacyDeviceSelectionSettings {
+    bikes?: LegacyGearSetting[];
+    hrms?: LegacyGearSetting[];
+    disableHrm?: boolean;
+}
+export interface LegacySerialPortInfo {
+    [index: string]: {
+        name: string;
+        enabled: boolean;
+    };
+}
+export interface LegacySerialSettings {
+    enabled: boolean;
+    protocols: {
+        name: string;
+        selected: boolean;
+        id: number;
+    }[];
+}
+export interface LegacyAntSettings {
+    enabled: boolean;
+    bike: boolean;
+    hrm: boolean;
+}
+export interface LegacyDeviceConnectionSettings {
+    serial: LegacySerialSettings & LegacySerialPortInfo;
+    ant: LegacyAntSettings;
+    tcpip: {
+        enabled: boolean;
+    };
+}
+export interface IncyclistModeSettings {
+    mode: string;
+    settings: any;
+}
+export interface LegacyModeSettings {
+    [index: string]: IncyclistModeSettings;
+}
+export interface LegacyPreferences {
+    gear: LegacyModeSettings;
+}
+export interface LegacySettings {
+    connections?: LegacyDeviceConnectionSettings;
+    gearSelection?: LegacyDeviceSelectionSettings;
+    modeSettings?: LegacyModeSettings;
+}

package/lib/devices/configuration/model/repository/legacy.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/devices/configuration/model/service/index.d.ts

@@ -0,0 +1,13 @@
+import { IncyclistDeviceAdapter } from "incyclist-devices";
+import { ExtendedIncyclistCapability } from "../app";
+export interface AdapterInfo {
+    udid: string;
+    adapter: IncyclistDeviceAdapter;
+    capabilities: ExtendedIncyclistCapability[];
+}
+export interface DeviceModeInfo {
+    udid: string;
+    mode: string;
+    settings: any;
+    options?: string[];
+}

package/lib/devices/configuration/model/service/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });