incyclist-services 1.0.0

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

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

package/lib/devices/ride/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("./service"), exports);
+__exportStar(require("./model"), exports);

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

@@ -0,0 +1,28 @@
+import { DeviceProperties } from "incyclist-devices/lib/types/device";
+import { AdapterInfo } from "../configuration";
+export interface AdapterRideInfo extends AdapterInfo {
+    isStarted: boolean;
+}
+export interface RideServiceDeviceProperties extends DeviceProperties {
+    forceErgMode?: boolean;
+    startPos?: number;
+    realityFactor?: number;
+    rideMode?: string;
+    route?: any;
+}
+export interface Point {
+    elevation: number;
+    distance: number;
+}
+export interface PreparedRoute {
+    name: string;
+    description: string;
+    programId: number;
+    type: string;
+    totalDistance: number;
+    lapMode: boolean;
+    minElevation: number;
+    maxElevation: number;
+    sampleRate: number;
+    points: Point[];
+}

package/lib/devices/ride/model.js

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

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

@@ -0,0 +1,44 @@
+/// <reference types="node" />
+import EventEmitter from "events";
+import { DeviceData, DeviceSettings } from "incyclist-devices";
+import { DeviceAccessService } from "../access/service";
+import { AdapterInfo, DeviceConfigurationService } from "../configuration";
+import CyclingMode, { UpdateRequest } from "incyclist-devices/lib/modes/cycling-mode";
+import { AdapterRideInfo, PreparedRoute, RideServiceDeviceProperties } from "./model";
+import { UserSettingsService } from "../../settings";
+export declare class DeviceRideService extends EventEmitter {
+    protected static _instance: DeviceRideService;
+    protected configurationService: DeviceConfigurationService;
+    protected userSettings: UserSettingsService;
+    protected accessService: DeviceAccessService;
+    protected initizialized: boolean;
+    protected adapters: AdapterRideInfo[];
+    protected startPromises: Promise<boolean>[];
+    protected data: DeviceData;
+    protected simulatorEnforced: boolean;
+    protected deviceDataHandler: any;
+    static getInstance(): DeviceRideService;
+    constructor();
+    protected waitForInit(): Promise<void>;
+    lazyInit(): Promise<void>;
+    protected getAdapterStateInfo(adapterInfo: AdapterInfo): {
+        udid: string;
+        name: string;
+        isControl: boolean;
+        capabilities: import("../configuration").ExtendedIncyclistCapability[];
+    };
+    protected getAdapterList(): AdapterRideInfo[];
+    prepareEppRoute(props: RideServiceDeviceProperties): PreparedRoute;
+    start(props: RideServiceDeviceProperties): Promise<boolean>;
+    cancelStart(): Promise<boolean>;
+    startRide(_props: any): void;
+    stop(): Promise<boolean>;
+    pause(): void;
+    resume(): void;
+    onData(deviceSettings: DeviceSettings, data: DeviceData): void;
+    sendUpdate(request: UpdateRequest): void;
+    getCyclingMode(udid?: string): CyclingMode;
+    onCyclingModeChanged(udid: string, mode: string, settings: any): void;
+    enforceSimulator(enforced?: boolean): void;
+}
+export declare const useDeviceRide: () => DeviceRideService;

package/lib/devices/ride/service.js

@@ -0,0 +1,439 @@
+"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.useDeviceRide = exports.DeviceRideService = void 0;
+const events_1 = __importDefault(require("events"));
+const incyclist_devices_1 = require("incyclist-devices");
+const sleep_1 = require("../../utils/sleep");
+const service_1 = require("../access/service");
+const configuration_1 = require("../configuration");
+const clone_1 = __importDefault(require("../../utils/clone"));
+const settings_1 = require("../../settings");
+class DeviceRideService extends events_1.default {
+    static getInstance() {
+        if (!DeviceRideService._instance)
+            DeviceRideService._instance = new DeviceRideService();
+        return DeviceRideService._instance;
+    }
+    constructor() {
+        super();
+        this.data = {};
+        this.deviceDataHandler = this.onData.bind(this);
+        this.initizialized = false;
+        this.simulatorEnforced = false;
+    }
+    waitForInit() {
+        return new Promise(done => {
+            this.accessService = (0, service_1.useDeviceAccess)();
+            this.configurationService = (0, configuration_1.useDeviceConfiguration)();
+            if (this.configurationService.isInitialized())
+                return done();
+            this.configurationService.once('initialized', done);
+            this.configurationService.init();
+        });
+    }
+    lazyInit() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.initizialized) {
+                yield this.waitForInit();
+            }
+            this.adapters = (_a = this.configurationService.getAdapters()) === null || _a === void 0 ? void 0 : _a.map(ai => Object.assign({}, Object.assign(Object.assign({}, ai), { isStarted: false })));
+            const handleModeChange = this.onCyclingModeChanged.bind(this);
+            this.configurationService.on('mode-changed', handleModeChange);
+            this.userSettings = (0, settings_1.useUserSettings)();
+        });
+    }
+    getAdapterStateInfo(adapterInfo) {
+        const { udid, adapter, capabilities } = adapterInfo;
+        const name = adapter.getUniqueName();
+        const isControl = adapter.hasCapability(incyclist_devices_1.IncyclistCapability.Control);
+        return { udid, name, isControl, capabilities };
+    }
+    getAdapterList() {
+        if (!this.simulatorEnforced)
+            return this.adapters;
+        const adapter = incyclist_devices_1.AdapterFactory.create({ interface: 'simulator', name: 'Simulator' });
+        return [{ adapter, udid: 'Simulator' + Date.now(), capabilities: adapter.getCapabilities(), isStarted: false }];
+    }
+    prepareEppRoute(props) {
+        const { route, startPos, realityFactor, rideMode } = props;
+        if (!route || !route.get()) {
+            return null;
+        }
+        let res;
+        const eppPreferences = (0, clone_1.default)(this.userSettings.get('eppPreferences', {}));
+        if (!eppPreferences.programId)
+            eppPreferences.programId = 1;
+        else {
+            eppPreferences.programId++;
+            if (eppPreferences.programId > 32767)
+                eppPreferences.programId = 1;
+        }
+        this.userSettings.update({ eppPreferences });
+        const routeData = route.get();
+        if (routeData.epp) {
+            const eppData = routeData.epp;
+            let points = eppData.programData;
+            const offset = startPos || 0;
+            if (startPos !== undefined && startPos !== 0) {
+                let idxBefore = 0;
+                let idxAfter = points.length - 1;
+                let done = false;
+                for (let i = 0; i < points.length && !done; i++) {
+                    const p = points[i];
+                    if (p.distance <= startPos)
+                        idxBefore = i;
+                    if (p.distance >= startPos) {
+                        idxAfter = i;
+                        done = true;
+                    }
+                }
+                if (idxAfter > idxBefore) {
+                    const originalPoints = points;
+                    const distance = startPos - originalPoints[idxBefore].distance;
+                    const distanceGain = originalPoints[idxAfter].distance - originalPoints[idxBefore].distance;
+                    const elevationGain = originalPoints[idxAfter].elevation - originalPoints[idxBefore].elevation;
+                    points = [];
+                    points.push({ distance: offset, elevation: originalPoints[idxBefore].elevation + elevationGain * distance / distanceGain });
+                    points = points.concat(originalPoints.slice(idxAfter));
+                    if (route.isLap()) {
+                        points = points.concat(originalPoints.slice(1, idxBefore + 1).map(p => { p.distance += routeData.distance; return p; }));
+                        points.push({ distance: routeData.distance + offset, elevation: originalPoints[idxBefore].elevation + elevationGain * distance / distanceGain });
+                    }
+                }
+                else {
+                    const originalPoints = points;
+                    points = originalPoints.slice(idxAfter);
+                    if (route.isLap()) {
+                        points = points.concat(originalPoints.slice(1, idxBefore + 1).map(p => { p.distance += routeData.distance; return p; }));
+                    }
+                }
+            }
+            const pStart = points[0];
+            const elevationStart = pStart.elevation;
+            const totalDistance = route.isLap() ? routeData.distance : Math.ceil(routeData.distance - (startPos || 0));
+            res = {
+                name: eppData.name,
+                description: eppData.description,
+                programId: eppPreferences.programId,
+                type: rideMode || 'free ride',
+                totalDistance,
+                lapMode: route.isLap(),
+                minElevation: eppData.minElevation,
+                maxElevation: eppData.maxElevation,
+                sampleRate: eppData.sampleRate,
+                points: points.map(p => {
+                    const adjustedElevation = realityFactor === undefined ? p.elevation : elevationStart + (p.elevation - elevationStart) * realityFactor / 100;
+                    return {
+                        elevation: adjustedElevation,
+                        distance: p.distance,
+                    };
+                })
+            };
+        }
+        else {
+            const sampleRate = 10;
+            let points = routeData.decoded;
+            let totalDistance = Math.ceil(routeData.distance);
+            if (startPos !== undefined && startPos !== 0) {
+                let idxBefore = 0;
+                let idxAfter = points.length - 1;
+                let done = false;
+                for (let i = 0; i < points.length && !done; i++) {
+                    const p = points[i];
+                    if (p.routeDistance <= startPos)
+                        idxBefore = i;
+                    if (p.routeDistance >= startPos) {
+                        idxAfter = i;
+                        done = true;
+                    }
+                }
+                if (idxAfter > idxBefore) {
+                    const originalPoints = points;
+                    const distance = startPos - originalPoints[idxBefore].routeDistance;
+                    const distanceGain = originalPoints[idxAfter].routeDistance - originalPoints[idxBefore].routeDistance;
+                    const elevationGain = originalPoints[idxAfter].elevation - originalPoints[idxBefore].elevation;
+                    points = [];
+                    points.push({ routeDistance: startPos, elevation: originalPoints[idxBefore].elevation + elevationGain * distance / distanceGain });
+                    points = points.concat(originalPoints.slice(idxAfter));
+                    if (route.isLap()) {
+                        points = points.concat(originalPoints.slice(1, idxBefore + 1).map(p => { p.routeDistance += routeData.distance; return p; }));
+                        points.push({ routeDistance: routeData.distance, elevation: originalPoints[idxBefore].elevation + elevationGain * distance / distanceGain });
+                    }
+                }
+                else {
+                    const originalPoints = points;
+                    points = originalPoints.slice(idxAfter);
+                    if (route.isLap()) {
+                        points = originalPoints.slice(1, idxBefore + 1).map(p => { p.routeDistance += routeData.distance; return p; });
+                    }
+                }
+                totalDistance = route.isLap() ? routeData.distance : Math.ceil(routeData.distance - (startPos || 0));
+            }
+            res = {
+                name: routeData.title,
+                description: '',
+                programId: eppPreferences.programId,
+                type: rideMode || 'free ride',
+                totalDistance,
+                lapMode: route.isLap(),
+                minElevation: 0,
+                maxElevation: Math.ceil(Math.max(...points.map(p => p.elevation)) / 1000) * 1000,
+                sampleRate,
+                points: []
+            };
+            const offset = startPos || 0;
+            let d = offset;
+            let i = 0;
+            let pStart = points[0];
+            const elevationStart = pStart.elevation ? Math.round(pStart.elevation * 10) / 10 : 0;
+            const addPoint = (distanceValue, elevationValue, inc = true) => {
+                const distance = Math.round(distanceValue);
+                let elevation = elevationValue >= 0 ? Math.round(elevationValue * 10) / 10 : 0;
+                if (realityFactor !== undefined) {
+                    elevation = elevationStart + (elevation - elevationStart) * realityFactor / 100;
+                }
+                res.points.push({
+                    elevation,
+                    distance
+                });
+                if (inc)
+                    d += sampleRate;
+            };
+            while (d <= routeData.distance + offset && i < points.length) {
+                const p = points[i];
+                if (i === 0) {
+                    addPoint(0, p.elevation, false);
+                    i++;
+                }
+                else {
+                    if (p.routeDistance < d) {
+                        pStart = p;
+                        i++;
+                    }
+                    else if (p.routeDistance === d + sampleRate) {
+                        addPoint(p.routeDistance - offset, p.elevation);
+                        i++;
+                    }
+                    else if (p.routeDistance > d + sampleRate) {
+                        do {
+                            const d1 = pStart.routeDistance;
+                            const d2 = p.routeDistance;
+                            const e1 = pStart.elevation;
+                            const e2 = p.elevation;
+                            const dT = d + sampleRate;
+                            const e = e1 + (e2 - e1) * (dT - d1) / (d2 - d1);
+                            addPoint(dT - offset, e);
+                        } while (p.routeDistance > d + sampleRate);
+                        if (p.routeDistance >= routeData.distance || i === points.length - 1) {
+                            addPoint(p.routeDistance - offset, p.elevation);
+                            i++;
+                        }
+                        else {
+                            i++;
+                            pStart = p;
+                        }
+                    }
+                    else {
+                        i++;
+                    }
+                }
+            }
+        }
+        return res;
+    }
+    start(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.lazyInit();
+            const { forceErgMode, startPos, realityFactor, rideMode, route } = props;
+            while (this.startPromises) {
+                (0, sleep_1.sleep)(500);
+            }
+            const adapters = this.getAdapterList();
+            this.emit('start-request', adapters.map(this.getAdapterStateInfo));
+            this.startPromises = adapters.map(ai => {
+                const startProps = (0, clone_1.default)(props);
+                if (ai.adapter.isControllable()) {
+                    const d = ai.adapter;
+                    let mode, settings;
+                    if (!this.simulatorEnforced) {
+                        if (forceErgMode) {
+                            const modes = d.getSupportedCyclingModes().filter(C => C.isERG);
+                            if (modes.length > 0) {
+                                mode = new modes[0](d);
+                                const modeInfo = this.configurationService.getModeSettings(ai.udid, mode);
+                                settings = modeInfo.settings;
+                            }
+                        }
+                        if (!mode) {
+                            const modeInfo = this.configurationService.getModeSettings(ai.udid);
+                            mode = modeInfo.mode;
+                            settings = modeInfo.settings;
+                        }
+                    }
+                    if (!mode)
+                        mode = d.getDefaultCyclingMode();
+                    d.setCyclingMode(mode, settings);
+                    if (d.getCyclingMode().getModeProperty('eppSupport')) {
+                        startProps.route = this.prepareEppRoute({ route, startPos, realityFactor, rideMode });
+                        startProps.onStatusUpdate = (completed, total) => {
+                            this.emit('start-update', this.getAdapterStateInfo(ai), completed, total);
+                        };
+                    }
+                }
+                return ai.adapter.start(startProps)
+                    .then(success => {
+                    if (success) {
+                        this.emit('start-success', this.getAdapterStateInfo(ai));
+                    }
+                    ai.isStarted = true;
+                    return success;
+                })
+                    .catch(err => {
+                    ai.isStarted = false;
+                    this.emit('start-error', this.getAdapterStateInfo(ai), err);
+                    return false;
+                });
+            });
+            const status = yield Promise.all(this.startPromises);
+            const allOK = status.find(s => s === false) === undefined;
+            this.emit('start-result', allOK);
+            if (allOK) {
+                this.startRide(props);
+            }
+            this.startPromises = null;
+            return allOK;
+        });
+    }
+    cancelStart() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const adapters = this.getAdapterList();
+            adapters.forEach(ai => {
+                const d = ai.adapter;
+                d.off('data', this.deviceDataHandler);
+                if (!ai.isStarted)
+                    d.stop();
+            });
+            this.startPromises = null;
+            return true;
+        });
+    }
+    startRide(_props) {
+        const adapters = this.getAdapterList();
+        adapters.forEach(ai => {
+            ai.adapter.on('data', this.deviceDataHandler);
+        });
+    }
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const adapters = this.getAdapterList();
+            this.emit('stop-ride');
+            adapters.forEach(ai => {
+                ai.adapter.off('data', this.deviceDataHandler);
+            });
+            return true;
+        });
+    }
+    pause() {
+        const adapters = this.getAdapterList();
+        adapters.forEach(ai => {
+            ai.adapter.pause();
+            ai.adapter.off('data', this.deviceDataHandler);
+        });
+    }
+    resume() {
+        const adapters = this.getAdapterList();
+        adapters.forEach(ai => {
+            ai.adapter.resume();
+            ai.adapter.on('data', this.deviceDataHandler);
+        });
+    }
+    onData(deviceSettings, data) {
+        const adapters = this.getAdapterList();
+        const hasControl = adapters.find(ai => ai.capabilities.includes(incyclist_devices_1.IncyclistCapability.Control)) !== undefined;
+        const hasPower = adapters.find(ai => ai.capabilities.includes(incyclist_devices_1.IncyclistCapability.Power)) !== undefined;
+        const adapterInfo = adapters.find(ai => ai.adapter.isEqual(deviceSettings));
+        adapterInfo.capabilities.forEach(capability => {
+            switch (capability) {
+                case incyclist_devices_1.IncyclistCapability.HeartRate:
+                    this.data.heartrate = data.heartrate;
+                    break;
+                case incyclist_devices_1.IncyclistCapability.Power:
+                    this.data.power = data.power;
+                    this.data.speed = data.speed;
+                    break;
+                case incyclist_devices_1.IncyclistCapability.Cadence:
+                    this.data.cadence = data.cadence;
+                    if (hasControl && !hasPower) {
+                        this.data.speed = data.speed;
+                        this.data.power = data.power;
+                    }
+                    break;
+                case incyclist_devices_1.IncyclistCapability.Control:
+                    this.data.deviceDistanceCounter = data.deviceDistanceCounter;
+                    this.data.deviceTime = data.deviceTime;
+                    this.data.distance = data.distance;
+                    this.data.internalDistanceCounter = data.internalDistanceCounter;
+                    this.data.slope = data.slope;
+                    this.data.timestamp = data.timestamp;
+                    break;
+            }
+        });
+        this.emit('data', this.data);
+    }
+    sendUpdate(request) {
+        const adapters = this.getAdapterList();
+        adapters.forEach(ai => {
+            if (ai.adapter.isControllable()) {
+                const d = ai.adapter;
+                d.sendUpdate(request);
+            }
+        });
+    }
+    getCyclingMode(udid) {
+        var _a, _b;
+        const adapters = this.getAdapterList();
+        let adapter;
+        if (udid) {
+            adapter = (_a = adapters.find(ai => ai.udid === udid)) === null || _a === void 0 ? void 0 : _a.adapter;
+        }
+        else {
+            adapter = (_b = adapters.find(ai => ai.adapter.hasCapability(incyclist_devices_1.IncyclistCapability.Control))) === null || _b === void 0 ? void 0 : _b.adapter;
+        }
+        if (adapter)
+            return adapter.getCyclingMode();
+    }
+    onCyclingModeChanged(udid, mode, settings) {
+        var _a;
+        const currentMode = this.getCyclingMode(udid);
+        if (!currentMode || currentMode.getName() !== mode) {
+            const adapters = this.getAdapterList();
+            const adapter = (_a = adapters.find(ai => ai.udid === udid)) === null || _a === void 0 ? void 0 : _a.adapter;
+            if (adapter && adapter.isControllable()) {
+                const device = adapter;
+                device.setCyclingMode(mode, settings);
+            }
+        }
+        else {
+            currentMode.setSettings(settings);
+        }
+    }
+    enforceSimulator(enforced = true) {
+        this.simulatorEnforced = enforced;
+    }
+}
+exports.DeviceRideService = DeviceRideService;
+const useDeviceRide = () => DeviceRideService.getInstance();
+exports.useDeviceRide = useDeviceRide;

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+export * from './devices';
+export { useUserSettings, initUserSettings, UserSettingsService, UserSettingsBinding, IUserSettingsBinding } from './settings';

package/lib/index.js

@@ -0,0 +1,23 @@
+"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 });
+exports.UserSettingsBinding = exports.UserSettingsService = exports.initUserSettings = exports.useUserSettings = void 0;
+__exportStar(require("./devices"), exports);
+var settings_1 = require("./settings");
+Object.defineProperty(exports, "useUserSettings", { enumerable: true, get: function () { return settings_1.useUserSettings; } });
+Object.defineProperty(exports, "initUserSettings", { enumerable: true, get: function () { return settings_1.initUserSettings; } });
+Object.defineProperty(exports, "UserSettingsService", { enumerable: true, get: function () { return settings_1.UserSettingsService; } });
+Object.defineProperty(exports, "UserSettingsBinding", { enumerable: true, get: function () { return settings_1.UserSettingsBinding; } });

package/lib/settings/index.d.ts

@@ -0,0 +1,3 @@
+import { UserSettingsService, useUserSettings, initUserSettings } from "./user/service";
+import { UserSettingsBinding, IUserSettingsBinding } from './user/bindings';
+export { UserSettingsService, useUserSettings, initUserSettings, UserSettingsBinding, IUserSettingsBinding };

package/lib/settings/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserSettingsBinding = exports.initUserSettings = exports.useUserSettings = exports.UserSettingsService = void 0;
+const service_1 = require("./user/service");
+Object.defineProperty(exports, "UserSettingsService", { enumerable: true, get: function () { return service_1.UserSettingsService; } });
+Object.defineProperty(exports, "useUserSettings", { enumerable: true, get: function () { return service_1.useUserSettings; } });
+Object.defineProperty(exports, "initUserSettings", { enumerable: true, get: function () { return service_1.initUserSettings; } });
+const bindings_1 = require("./user/bindings");
+Object.defineProperty(exports, "UserSettingsBinding", { enumerable: true, get: function () { return bindings_1.UserSettingsBinding; } });

package/lib/settings/user/bindings/index.d.ts

@@ -0,0 +1,2 @@
+import { UserSettingsBinding, IUserSettingsBinding } from "./types";
+export { UserSettingsBinding, IUserSettingsBinding };

package/lib/settings/user/bindings/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserSettingsBinding = void 0;
+const types_1 = require("./types");
+Object.defineProperty(exports, "UserSettingsBinding", { enumerable: true, get: function () { return types_1.UserSettingsBinding; } });

package/lib/settings/user/bindings/json.d.ts

@@ -0,0 +1,15 @@
+import { UserSettingsBinding } from "./types";
+export default class JSONFileBindig extends UserSettingsBinding {
+    static _instance: UserSettingsBinding;
+    path: string;
+    settings: any;
+    savePromise: Promise<boolean> | null;
+    static getInstance(path?: string): UserSettingsBinding;
+    constructor(path?: string);
+    getAll(): Promise<any>;
+    set(key: string, value: any): Promise<boolean>;
+    canOverwrite(): boolean;
+    save(settings?: any): Promise<boolean>;
+    waitForSaveFinished(): Promise<void>;
+    verify(settings: any): boolean;
+}