@iobroker/dm-utils 2.0.1 → 3.0.2

package/build/DeviceManagement.d.ts

@@ -1,40 +1,40 @@
 import type { AdapterInstance } from '@iobroker/adapter-core';
 import type { ActionContext } from './ActionContext';
 import type { ProgressDialog } from './ProgressDialog';
-import { type DeviceDetails, type DeviceInfo, type ErrorResponse, type InstanceDetails, type JsonFormData, type JsonFormSchema, type RefreshResponse, type RetVal, type ActionButton } from './types';
-import type { BackendToGuiCommand, ControlState } from './types/base';
-export declare abstract class DeviceManagement<T extends AdapterInstance = AdapterInstance> {
-    protected readonly adapter: T;
+import { type ActionButton, type DeviceDetails, type DeviceId, type DeviceInfo, type DeviceStatus, type ErrorResponse, type InstanceDetails, type JsonFormData, type JsonFormSchema, type RetVal } from './types';
+import type { BackendToGuiCommand, DeviceRefreshResponse, InstanceRefreshResponse } from './types/base';
+import type { ProgressOptions } from './types/common';
+export type DeviceLoadContext<TId extends DeviceId> = {
+    addDevice(device: DeviceInfo<TId>): void;
+    setTotalDevices(count: number): void;
+};
+export declare abstract class DeviceManagement<TAdapter extends AdapterInstance = AdapterInstance, TId extends DeviceId = string> {
+    protected readonly adapter: TAdapter;
     private instanceInfo?;
     private devices?;
     private readonly communicationStateId;
-    private readonly contexts;
-    constructor(adapter: T, communicationStateId?: string | boolean);
+    private readonly deviceLoadContexts;
+    private readonly messageContexts;
+    constructor(adapter: TAdapter, communicationStateId?: string | boolean);
     private ensureCommunicationState;
-    protected sendCommandToGui(command: BackendToGuiCommand): Promise<void>;
+    protected sendCommandToGui(command: BackendToGuiCommand<TId>): Promise<void>;
     protected get log(): ioBroker.Log;
     protected getInstanceInfo(): RetVal<InstanceDetails>;
-    protected abstract listDevices(): RetVal<DeviceInfo[]>;
-    protected getDeviceDetails(id: string): RetVal<DeviceDetails | null | {
+    protected abstract loadDevices(context: DeviceLoadContext<TId>): RetVal<void>;
+    protected getDeviceInfo(_deviceId: TId): RetVal<DeviceInfo<TId>>;
+    protected getDeviceStatus(_deviceId: TId): RetVal<DeviceStatus | DeviceStatus[]>;
+    protected getDeviceDetails(id: TId): RetVal<DeviceDetails<TId> | null | {
         error: string;
     }>;
-    protected handleInstanceAction(actionId: string, context?: ActionContext, options?: {
-        value?: number | string | boolean;
-        [key: string]: any;
-    }): RetVal<ErrorResponse> | RetVal<RefreshResponse>;
-    protected handleDeviceAction(deviceId: string, actionId: string, context?: ActionContext, options?: {
-        value?: number | string | boolean;
-        [key: string]: any;
-    }): RetVal<ErrorResponse> | RetVal<RefreshResponse>;
-    protected handleDeviceControl(deviceId: string, controlId: string, newState: ControlState, context?: MessageContext): RetVal<ErrorResponse | ioBroker.State>;
-    protected handleDeviceControlState(deviceId: string, controlId: string, context?: MessageContext): RetVal<ErrorResponse | ioBroker.State>;
+    private handleInstanceAction;
+    private handleDeviceAction;
+    private handleDeviceControl;
+    private handleDeviceControlState;
     private onMessage;
     private handleMessage;
-    private convertActions;
-    private convertControls;
     private sendReply;
 }
-export declare class MessageContext implements ActionContext {
+export declare class MessageContext<TId extends DeviceId> implements ActionContext {
     private readonly adapter;
     private hasOpenProgressDialog;
     private lastMessage?;
@@ -47,13 +47,9 @@ export declare class MessageContext implements ActionContext {
         title?: ioBroker.StringOrTranslated;
         buttons?: (ActionButton | 'apply' | 'cancel' | 'close')[];
     }): Promise<JsonFormData | undefined>;
-    openProgress(title: string, options?: {
-        indeterminate?: boolean;
-        value?: number;
-        label?: string;
-    }): Promise<ProgressDialog>;
-    sendFinalResult(result: ErrorResponse | RefreshResponse): void;
-    sendControlResult(deviceId: string, controlId: string, result: ErrorResponse | ioBroker.State): void;
+    openProgress(title: ioBroker.StringOrTranslated, options?: ProgressOptions): Promise<ProgressDialog>;
+    sendFinalResult(result: ErrorResponse | DeviceRefreshResponse<'api', TId> | InstanceRefreshResponse): void;
+    sendControlResult(deviceId: TId, controlId: string, result: ErrorResponse | ioBroker.State): void;
     handleProgress(message: ioBroker.Message): void;
     private checkPreconditions;
     private send;

package/build/DeviceManagement.js

@@ -5,7 +5,8 @@ const types_1 = require("./types");
 class DeviceManagement {
     constructor(adapter, communicationStateId) {
         this.adapter = adapter;
-        this.contexts = new Map();
+        this.deviceLoadContexts = new Map();
+        this.messageContexts = new Map();
         adapter.on('message', this.onMessage.bind(this));
         if (communicationStateId === true) {
             // use standard ID `info.deviceManager`
@@ -40,7 +41,7 @@ class DeviceManagement {
     }
     async sendCommandToGui(command) {
         if (this.communicationStateId) {
-            await this.adapter.setStateAsync(this.communicationStateId, JSON.stringify(command), true);
+            await this.adapter.setState(this.communicationStateId, JSON.stringify(command), true);
         }
         else {
             throw new Error('Communication state not found');
@@ -51,7 +52,13 @@ class DeviceManagement {
     }
     getInstanceInfo() {
         // Overload this method if your adapter does not use BackendToGui communication and States/Objects in DeviceInfo
-        return { apiVersion: 'v2', communicationStateId: this.communicationStateId || undefined };
+        return { apiVersion: 'v3', communicationStateId: this.communicationStateId || undefined };
+    }
+    getDeviceInfo(_deviceId) {
+        throw new Error('Do not send "infoUpdate" or "delete" command without implementing getDeviceInfo method!');
+    }
+    getDeviceStatus(_deviceId) {
+        throw new Error('Do not send "statusUpdate" command without implementing getDeviceStatus method!');
     }
     getDeviceDetails(id) {
         return { id, schema: {} };
@@ -77,7 +84,7 @@ class DeviceManagement {
                 },
             };
         }
-        if (!action.handler) {
+        if (!('handler' in action) || !action.handler) {
             this.log.warn(`Instance action ${actionId} is disabled because it has no handler`);
             return {
                 error: {
@@ -91,40 +98,41 @@ class DeviceManagement {
     handleDeviceAction(deviceId, actionId, context, options) {
         var _a;
         if (!this.devices) {
-            this.log.warn(`Device action ${actionId} was called before listDevices()`);
+            this.log.warn(`Device action ${actionId} was called before loadDevices()`);
             return {
                 error: {
                     code: types_1.ErrorCodes.E_DEVICE_ACTION_NOT_INITIALIZED,
-                    message: `Device action ${actionId} was called before listDevices()`,
+                    message: `Device action ${actionId} was called before loadDevices()`,
                 },
             };
         }
-        const device = this.devices.get(deviceId);
+        const jsonId = JSON.stringify(deviceId);
+        const device = this.devices.get(jsonId);
         if (!device) {
-            this.log.warn(`Device action ${actionId} was called on unknown device: ${deviceId}`);
+            this.log.warn(`Device action ${actionId} was called on unknown device: ${jsonId}`);
             return {
                 error: {
                     code: types_1.ErrorCodes.E_DEVICE_ACTION_DEVICE_UNKNOWN,
-                    message: `Device action ${actionId} was called on unknown device: ${deviceId}`,
+                    message: `Device action ${actionId} was called on unknown device: ${jsonId}`,
                 },
             };
         }
         const action = (_a = device.actions) === null || _a === void 0 ? void 0 : _a.find(a => a.id === actionId);
         if (!action) {
-            this.log.warn(`Device action ${actionId} doesn't exist on device ${deviceId}`);
+            this.log.warn(`Device action ${actionId} doesn't exist on device ${jsonId}`);
             return {
                 error: {
                     code: types_1.ErrorCodes.E_DEVICE_ACTION_UNKNOWN,
-                    message: `Device action ${actionId} doesn't exist on device ${deviceId}`,
+                    message: `Device action ${actionId} doesn't exist on device ${jsonId}`,
                 },
             };
         }
-        if (!action.handler) {
-            this.log.warn(`Device action ${actionId} on ${deviceId} is disabled because it has no handler`);
+        if (!('handler' in action) || !action.handler) {
+            this.log.warn(`Device action ${actionId} on ${jsonId} is disabled because it has no handler`);
             return {
                 error: {
                     code: types_1.ErrorCodes.E_DEVICE_ACTION_NO_HANDLER,
-                    message: `Device action ${actionId} on ${deviceId} is disabled because it has no handler`,
+                    message: `Device action ${actionId} on ${jsonId} is disabled because it has no handler`,
                 },
             };
         }
@@ -133,40 +141,41 @@ class DeviceManagement {
     handleDeviceControl(deviceId, controlId, newState, context) {
         var _a;
         if (!this.devices) {
-            this.log.warn(`Device control ${controlId} was called before listDevices()`);
+            this.log.warn(`Device control ${controlId} was called before loadDevices()`);
             return {
                 error: {
                     code: types_1.ErrorCodes.E_DEVICE_CONTROL_NOT_INITIALIZED,
-                    message: `Device control ${controlId} was called before listDevices()`,
+                    message: `Device control ${controlId} was called before loadDevices()`,
                 },
             };
         }
-        const device = this.devices.get(deviceId);
+        const jsonId = JSON.stringify(deviceId);
+        const device = this.devices.get(jsonId);
         if (!device) {
-            this.log.warn(`Device control ${controlId} was called on unknown device: ${deviceId}`);
+            this.log.warn(`Device control ${controlId} was called on unknown device: ${jsonId}`);
             return {
                 error: {
                     code: types_1.ErrorCodes.E_DEVICE_CONTROL_DEVICE_UNKNOWN,
-                    message: `Device control ${controlId} was called on unknown device: ${deviceId}`,
+                    message: `Device control ${controlId} was called on unknown device: ${jsonId}`,
                 },
             };
         }
         const control = (_a = device.controls) === null || _a === void 0 ? void 0 : _a.find(a => a.id === controlId);
         if (!control) {
-            this.log.warn(`Device control ${controlId} doesn't exist on device ${deviceId}`);
+            this.log.warn(`Device control ${controlId} doesn't exist on device ${jsonId}`);
             return {
                 error: {
                     code: types_1.ErrorCodes.E_DEVICE_CONTROL_UNKNOWN,
-                    message: `Device control ${controlId} doesn't exist on device ${deviceId}`,
+                    message: `Device control ${controlId} doesn't exist on device ${jsonId}`,
                 },
             };
         }
         if (!control.handler) {
-            this.log.warn(`Device control ${controlId} on ${deviceId} is disabled because it has no handler`);
+            this.log.warn(`Device control ${controlId} on ${jsonId} is disabled because it has no handler`);
             return {
                 error: {
                     code: types_1.ErrorCodes.E_DEVICE_CONTROL_NO_HANDLER,
-                    message: `Device control ${controlId} on ${deviceId} is disabled because it has no handler`,
+                    message: `Device control ${controlId} on ${jsonId} is disabled because it has no handler`,
                 },
             };
         }
@@ -176,40 +185,41 @@ class DeviceManagement {
     handleDeviceControlState(deviceId, controlId, context) {
         var _a;
         if (!this.devices) {
-            this.log.warn(`Device get state ${controlId} was called before listDevices()`);
+            this.log.warn(`Device get state ${controlId} was called before loadDevices()`);
             return {
                 error: {
                     code: types_1.ErrorCodes.E_DEVICE_GET_STATE_NOT_INITIALIZED,
-                    message: `Device control ${controlId} was called before listDevices()`,
+                    message: `Device control ${controlId} was called before loadDevices()`,
                 },
             };
         }
-        const device = this.devices.get(deviceId);
+        const jsonId = JSON.stringify(deviceId);
+        const device = this.devices.get(jsonId);
         if (!device) {
-            this.log.warn(`Device get state ${controlId} was called on unknown device: ${deviceId}`);
+            this.log.warn(`Device get state ${controlId} was called on unknown device: ${jsonId}`);
             return {
                 error: {
                     code: types_1.ErrorCodes.E_DEVICE_GET_STATE_DEVICE_UNKNOWN,
-                    message: `Device control ${controlId} was called on unknown device: ${deviceId}`,
+                    message: `Device control ${controlId} was called on unknown device: ${jsonId}`,
                 },
             };
         }
         const control = (_a = device.controls) === null || _a === void 0 ? void 0 : _a.find(a => a.id === controlId);
         if (!control) {
-            this.log.warn(`Device get state ${controlId} doesn't exist on device ${deviceId}`);
+            this.log.warn(`Device get state ${controlId} doesn't exist on device ${jsonId}`);
             return {
                 error: {
                     code: types_1.ErrorCodes.E_DEVICE_GET_STATE_UNKNOWN,
-                    message: `Device control ${controlId} doesn't exist on device ${deviceId}`,
+                    message: `Device control ${controlId} doesn't exist on device ${jsonId}`,
                 },
             };
         }
         if (!control.getStateHandler) {
-            this.log.warn(`Device get state ${controlId} on ${deviceId} is disabled because it has no handler`);
+            this.log.warn(`Device get state ${controlId} on ${jsonId} is disabled because it has no handler`);
             return {
                 error: {
                     code: types_1.ErrorCodes.E_DEVICE_GET_STATE_NO_HANDLER,
-                    message: `Device get state ${controlId} on ${deviceId} is disabled because it has no handler`,
+                    message: `Device get state ${controlId} on ${jsonId} is disabled because it has no handler`,
                 },
             };
         }
@@ -222,73 +232,110 @@ class DeviceManagement {
         void this.handleMessage(obj).catch(this.log.error);
     }
     async handleMessage(msg) {
+        var _a;
         this.log.debug(`DeviceManagement received: ${JSON.stringify(msg)}`);
         switch (msg.command) {
             case 'dm:instanceInfo': {
                 this.instanceInfo = await this.getInstanceInfo();
-                this.sendReply(Object.assign(Object.assign({}, this.instanceInfo), { actions: this.convertActions(this.instanceInfo.actions) }), msg);
+                this.sendReply(Object.assign(Object.assign({}, this.instanceInfo), { actions: convertActions(this.instanceInfo.actions) }), msg);
                 return;
             }
-            case 'dm:listDevices': {
-                const deviceList = await this.listDevices();
-                this.devices = deviceList.reduce((map, value) => {
-                    if (map.has(value.id)) {
-                        throw new Error(`Device ID ${value.id} is not unique`);
+            case 'dm:loadDevices': {
+                const context = new DeviceLoadContextImpl(msg, this.adapter);
+                this.deviceLoadContexts.set(msg._id, context);
+                await this.loadDevices(context);
+                if (context.complete()) {
+                    this.deviceLoadContexts.delete(msg._id);
+                }
+                this.devices = context.devices.reduce((map, value) => {
+                    const jsonId = JSON.stringify(value.id);
+                    if (map.has(jsonId)) {
+                        throw new Error(`Device ID ${jsonId} is not unique`);
                     }
-                    map.set(value.id, value);
+                    map.set(jsonId, value);
                     return map;
                 }, new Map());
-                const apiDeviceList = deviceList.map(d => (Object.assign(Object.assign({}, d), { actions: this.convertActions(d.actions), controls: this.convertControls(d.controls) })));
-                this.sendReply(apiDeviceList, msg);
-                this.adapter.sendTo(msg.from, msg.command, this.devices, msg.callback);
+                return;
+            }
+            case 'dm:deviceInfo': {
+                const deviceInfo = await this.getDeviceInfo(msg.message);
+                this.sendReply(Object.assign(Object.assign({}, deviceInfo), { actions: convertActions(deviceInfo.actions), controls: convertControls(deviceInfo.controls) }), msg);
+                return;
+            }
+            case 'dm:deviceStatus': {
+                const deviceStatus = await this.getDeviceStatus(msg.message);
+                this.sendReply(deviceStatus, msg);
                 return;
             }
             case 'dm:deviceDetails': {
                 const details = await this.getDeviceDetails(msg.message);
-                this.adapter.sendTo(msg.from, msg.command, details, msg.callback);
+                this.sendReply(details, msg);
                 return;
             }
             case 'dm:instanceAction': {
                 const action = msg.message;
                 const context = new MessageContext(msg, this.adapter);
-                this.contexts.set(msg._id, context);
+                this.messageContexts.set(msg._id, context);
                 const result = await this.handleInstanceAction(action.actionId, context, { value: action.value });
-                this.contexts.delete(msg._id);
+                this.messageContexts.delete(msg._id);
                 context.sendFinalResult(result);
                 return;
             }
             case 'dm:deviceAction': {
                 const action = msg.message;
                 const context = new MessageContext(msg, this.adapter);
-                this.contexts.set(msg._id, context);
+                this.messageContexts.set(msg._id, context);
                 const result = await this.handleDeviceAction(action.deviceId, action.actionId, context, {
                     value: action.value,
                 });
-                this.contexts.delete(msg._id);
-                context.sendFinalResult(result);
+                this.messageContexts.delete(msg._id);
+                if ('update' in result) {
+                    // special handling for update responses (we need to update our cache and convert actions/controls before sending to GUI)
+                    const update = result.update;
+                    (_a = this.devices) === null || _a === void 0 ? void 0 : _a.set(JSON.stringify(update.id), update);
+                    context.sendFinalResult({
+                        update: Object.assign(Object.assign({}, update), { actions: convertActions(update.actions), controls: convertControls(update.controls) }),
+                    });
+                }
+                else {
+                    context.sendFinalResult(result);
+                }
                 return;
             }
             case 'dm:deviceControl': {
                 const control = msg.message;
                 const context = new MessageContext(msg, this.adapter);
-                this.contexts.set(msg._id, context);
+                this.messageContexts.set(msg._id, context);
                 const result = await this.handleDeviceControl(control.deviceId, control.controlId, control.state, context);
-                this.contexts.delete(msg._id);
+                this.messageContexts.delete(msg._id);
                 context.sendControlResult(control.deviceId, control.controlId, result);
                 return;
             }
             case 'dm:deviceControlState': {
                 const control = msg.message;
                 const context = new MessageContext(msg, this.adapter);
-                this.contexts.set(msg._id, context);
+                this.messageContexts.set(msg._id, context);
                 const result = await this.handleDeviceControlState(control.deviceId, control.controlId, context);
-                this.contexts.delete(msg._id);
+                this.messageContexts.delete(msg._id);
                 context.sendControlResult(control.deviceId, control.controlId, result);
                 return;
             }
+            case 'dm:deviceLoadProgress': {
+                const { origin } = msg.message;
+                const context = this.deviceLoadContexts.get(origin);
+                if (!context) {
+                    this.log.warn(`Unknown message origin: ${origin}`);
+                    this.sendReply({ error: 'Unknown load progress origin' }, msg);
+                    return;
+                }
+                if (context.handleProgress(msg)) {
+                    this.deviceLoadContexts.delete(origin);
+                }
+                return;
+            }
             case 'dm:actionProgress': {
                 const { origin } = msg.message;
-                const context = this.contexts.get(origin);
+                const context = this.messageContexts.get(origin);
                 if (!context) {
                     this.log.warn(`Unknown message origin: ${origin}`);
                     this.sendReply({ error: 'Unknown action origin' }, msg);
@@ -299,41 +346,57 @@ class DeviceManagement {
             }
         }
     }
-    convertActions(actions) {
-        if (!actions) {
-            return undefined;
-        }
-        // detect duplicate IDs
-        const ids = new Set();
-        actions.forEach(a => {
-            if (ids.has(a.id)) {
-                throw new Error(`Action ID ${a.id} is used twice, this would lead to unexpected behavior`);
-            }
-            ids.add(a.id);
-        });
-        // remove handler function to send it as JSON
-        return actions.map((a) => (Object.assign(Object.assign({}, a), { handler: undefined, disabled: !a.handler })));
-    }
-    convertControls(controls) {
-        if (!controls) {
-            return undefined;
-        }
-        // detect duplicate IDs
-        const ids = new Set();
-        controls.forEach(a => {
-            if (ids.has(a.id)) {
-                throw new Error(`Control ID ${a.id} is used twice, this would lead to unexpected behavior`);
-            }
-            ids.add(a.id);
-        });
-        // remove handler function to send it as JSON
-        return controls.map((a) => (Object.assign(Object.assign({}, a), { handler: undefined, getStateHandler: undefined })));
-    }
     sendReply(reply, msg) {
         this.adapter.sendTo(msg.from, msg.command, reply, msg.callback);
     }
 }
 exports.DeviceManagement = DeviceManagement;
+class DeviceLoadContextImpl {
+    constructor(msg, adapter) {
+        this.adapter = adapter;
+        this.minBatchSize = 8;
+        this.devices = [];
+        this.sendNext = [];
+        this.completed = false;
+        this.respondTo = msg;
+        this.id = msg._id;
+    }
+    addDevice(device) {
+        this.devices.push(device);
+        this.sendNext.push(Object.assign(Object.assign({}, device), { actions: convertActions(device.actions), controls: convertControls(device.controls) }));
+        this.flush();
+    }
+    setTotalDevices(count) {
+        this.totalDevices = count;
+        this.flush();
+    }
+    complete() {
+        this.completed = true;
+        return this.flush();
+    }
+    handleProgress(message) {
+        this.respondTo = message;
+        return this.flush();
+    }
+    flush() {
+        if (this.sendNext.length <= this.minBatchSize && !this.completed) {
+            return false;
+        }
+        if (!this.respondTo) {
+            return false;
+        }
+        const reply = {
+            add: this.sendNext,
+            total: this.totalDevices,
+            next: this.completed ? undefined : { origin: this.id },
+        };
+        this.sendNext = [];
+        const msg = this.respondTo;
+        this.respondTo = undefined;
+        this.adapter.sendTo(msg.from, msg.command, reply, msg.callback);
+        return this.completed;
+    }
+}
 class MessageContext {
     constructor(msg, adapter) {
         this.adapter = adapter;
@@ -345,9 +408,7 @@ class MessageContext {
         const promise = new Promise(resolve => {
             this.progressHandler = () => resolve();
         });
-        this.send('message', {
-            message: text,
-        });
+        this.send({ type: 'message', message: text });
         return promise;
     }
     showConfirmation(text) {
@@ -355,9 +416,7 @@ class MessageContext {
         const promise = new Promise(resolve => {
             this.progressHandler = msg => resolve(!!msg.confirm);
         });
-        this.send('confirm', {
-            confirm: text,
-        });
+        this.send({ type: 'confirm', confirm: text });
         return promise;
     }
     showForm(schema, options) {
@@ -365,7 +424,8 @@ class MessageContext {
         const promise = new Promise(resolve => {
             this.progressHandler = msg => resolve(msg.data);
         });
-        this.send('form', {
+        this.send({
+            type: 'form',
             form: Object.assign({ schema }, options),
         });
         return promise;
@@ -378,9 +438,7 @@ class MessageContext {
                 const promise = new Promise(resolve => {
                     this.progressHandler = () => resolve();
                 });
-                this.send('progress', {
-                    progress: Object.assign(Object.assign(Object.assign({ title }, options), update), { open: true }),
-                }, true);
+                this.send({ type: 'progress', progress: update }, true);
                 return promise;
             },
             close: () => {
@@ -390,28 +448,23 @@ class MessageContext {
                         resolve();
                     };
                 });
-                this.send('progress', {
-                    progress: { open: false },
-                });
+                this.send({ type: 'progress', progress: { open: false } });
                 return promise;
             },
         };
         const promise = new Promise(resolve => {
             this.progressHandler = () => resolve(dialog);
         });
-        this.send('progress', {
-            progress: Object.assign(Object.assign({ title }, options), { open: true }),
-        }, true);
+        this.send({ type: 'progress', progress: Object.assign(Object.assign({ title }, options), { open: true }) }, true);
         return promise;
     }
     sendFinalResult(result) {
-        this.send('result', {
-            result,
-        });
+        this.send({ type: 'result', result });
     }
     sendControlResult(deviceId, controlId, result) {
         if (typeof result === 'object' && 'error' in result) {
-            this.send('result', {
+            this.send({
+                type: 'result',
                 result: {
                     error: result.error,
                     deviceId,
@@ -420,7 +473,8 @@ class MessageContext {
             });
         }
         else {
-            this.send('result', {
+            this.send({
+                type: 'result',
                 result: {
                     state: result,
                     deviceId,
@@ -442,11 +496,11 @@ class MessageContext {
             throw new Error("Can't show another dialog while a progress dialog is open. Please call 'close()' on the dialog before opening another dialog.");
         }
     }
-    send(type, message, doNotClose) {
+    send(message, doNotClose) {
         if (!this.lastMessage) {
             throw new Error("No outstanding message, can't send a new one");
         }
-        this.adapter.sendTo(this.lastMessage.from, this.lastMessage.command, Object.assign(Object.assign({}, message), { type, origin: this.lastMessage.message.origin || this.lastMessage._id }), this.lastMessage.callback);
+        this.adapter.sendTo(this.lastMessage.from, this.lastMessage.command, Object.assign(Object.assign({}, message), { origin: this.lastMessage.message.origin || this.lastMessage._id }), this.lastMessage.callback);
         if (!doNotClose) {
             // "progress" is exception. It will be closed with "close" flag
             this.lastMessage = undefined;
@@ -454,3 +508,33 @@ class MessageContext {
     }
 }
 exports.MessageContext = MessageContext;
+function convertActions(actions) {
+    if (!actions) {
+        return undefined;
+    }
+    // detect duplicate IDs
+    const ids = new Set();
+    actions.forEach(a => {
+        if (ids.has(a.id)) {
+            throw new Error(`Action ID ${a.id} is used twice, this would lead to unexpected behavior`);
+        }
+        ids.add(a.id);
+    });
+    // remove a handler function to send it as JSON
+    return actions.map((a) => (Object.assign(Object.assign({}, a), { handler: undefined, disabled: !a.handler && !a.url })));
+}
+function convertControls(controls) {
+    if (!controls) {
+        return undefined;
+    }
+    // detect duplicate IDs
+    const ids = new Set();
+    controls.forEach(a => {
+        if (ids.has(a.id)) {
+            throw new Error(`Control ID ${a.id} is used twice, this would lead to unexpected behavior`);
+        }
+        ids.add(a.id);
+    });
+    // remove handler function to send it as JSON
+    return controls.map((a) => (Object.assign(Object.assign({}, a), { handler: undefined, getStateHandler: undefined })));
+}

package/build/ProgressDialog.d.ts

@@ -1,9 +1,5 @@
+import type { ProgressUpdate } from './types/common';
 export interface ProgressDialog {
-    update(update: {
-        title?: ioBroker.StringOrTranslated;
-        indeterminate?: boolean;
-        value?: number;
-        label?: ioBroker.StringOrTranslated;
-    }): Promise<void>;
+    update(update: ProgressUpdate): Promise<void>;
     close(): Promise<void>;
 }

package/build/index.d.ts

@@ -1,3 +1,3 @@
 export type * from './ActionContext';
 export * from './DeviceManagement';
-export * from './types';
+export type * from './types';

package/build/index.js

@@ -15,5 +15,3 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./DeviceManagement"), exports);
-// don't export * from "./MessageContext" as it is private
-__exportStar(require("./types"), exports);

package/build/types/adapter.d.ts

@@ -1,7 +1,8 @@
 import type * as base from './base';
+import type { DeviceId } from './common';
 export type ActionBase = base.ActionBase<'adapter'>;
 export type InstanceAction = base.InstanceAction<'adapter'>;
-export type DeviceAction = base.DeviceAction<'adapter'>;
+export type DeviceAction<TId extends DeviceId> = base.DeviceAction<'adapter', TId>;
 export type InstanceDetails = base.InstanceDetails<'adapter'>;
-export type DeviceInfo = base.DeviceInfo<'adapter'>;
-export type DeviceControl = base.DeviceControl<'adapter'>;
+export type DeviceInfo<TId extends DeviceId> = base.DeviceInfo<'adapter', TId>;
+export type DeviceControl<TId extends DeviceId> = base.DeviceControl<'adapter', TId>;