@c8y/ngx-components 1023.57.0 → 1023.59.1

package/fesm2022/c8y-ngx-components-computed-asset-properties-c8y-ngx-components-computed-asset-properties-C5oS4Be-.mjs

@@ -0,0 +1,790 @@
+import { ComputedPropertiesService, hookComputedProperty } from '@c8y/ngx-components/asset-properties';
+import * as i0 from '@angular/core';
+import { inject, Injector, Injectable } from '@angular/core';
+import { MeasurementService, InventoryService, AlarmService, EventService, OperationService } from '@c8y/client';
+import { MeasurementRealtimeService, DatePipe, ManagedObjectRealtimeService, AlarmRealtimeService, EventRealtimeService, OperationRealtimeService } from '@c8y/ngx-components';
+import { from, map, filter, startWith, take, switchMap, distinctUntilChanged, pairwise, share, NEVER, scan, tap, of, catchError, combineLatest, merge } from 'rxjs';
+import { gettext } from '@c8y/ngx-components/gettext';
+import { get } from 'lodash-es';
+
+class LastMeasurementStrategy {
+    constructor(config, injector) {
+        this.config = config;
+        this.measurementService = injector.get(MeasurementService);
+        this.measurementRealtime = injector.get(MeasurementRealtimeService);
+        this.datePipe = injector.get(DatePipe);
+        this.datapoint = config.dp.filter(dp => dp.__active)[0];
+    }
+    fetchCurrentValue() {
+        const measurementFilter = {
+            valueFragmentSeries: this.datapoint.series,
+            valueFragmentType: this.datapoint.fragment,
+            pageSize: 1,
+            revert: true,
+            dateFrom: '1970-01-01',
+            source: this.datapoint.__target.id
+        };
+        return from(this.measurementService.list(measurementFilter)).pipe(map(({ data }) => data[0]), filter(measurement => !!measurement), map(measurement => this.formatMeasurement(measurement)));
+    }
+    createRealtimeStream(initialValue) {
+        return this.measurementRealtime
+            .onCreateOfSpecificMeasurement$(this.datapoint.fragment, this.datapoint.series, this.datapoint.__target)
+            .pipe(map(measurement => this.formatMeasurement(measurement)), startWith(initialValue));
+    }
+    formatMeasurement(measurement) {
+        const resultType = this.config?.resultType;
+        const fragment = this.datapoint.fragment;
+        const series = this.datapoint.series;
+        if (resultType === 1) {
+            return measurement[fragment][series].value;
+        }
+        else if (resultType === 2) {
+            return measurement[fragment][series].value + ' ' + measurement[fragment][series].unit;
+        }
+        else if (resultType === 3) {
+            const date = this.datePipe.transform(new Date(measurement.time), 'short');
+            return `${date} | ${measurement[fragment][series].value} ${measurement[fragment][series].unit}`;
+        }
+        else if (resultType === 4) {
+            return measurement[fragment][series];
+        }
+        return '';
+    }
+}
+
+/**
+ * Generic handler for realtime values following the three modes pattern
+ * Closed for modification but open for extension through strategies
+ */
+class RealtimeValueHandler {
+    constructor(strategy, config) {
+        this.strategy = strategy;
+        this.config = {
+            refetchOnResume: true,
+            preserveValueOnPause: true
+        };
+        if (config) {
+            this.config = { ...this.config, ...config };
+        }
+    }
+    /**
+     * Creates an Observable based on the metadata mode
+     */
+    getValue(metadata = { mode: 'realtime' }) {
+        if (metadata.mode === 'singleValue') {
+            return this.strategy.fetchCurrentValue().pipe(take(1));
+        }
+        if (metadata.mode === 'realtime' && !metadata.realtimeControl$) {
+            return this.handleUncontrolledRealtime();
+        }
+        if (metadata.mode === 'realtime' && metadata.realtimeControl$) {
+            return this.handleControlledRealtime(metadata.realtimeControl$);
+        }
+    }
+    handleUncontrolledRealtime() {
+        return this.strategy
+            .fetchCurrentValue()
+            .pipe(switchMap(initialValue => this.strategy.createRealtimeStream(initialValue)));
+    }
+    handleControlledRealtime(control$) {
+        const controlWithPrevious$ = control$.pipe(distinctUntilChanged(), startWith(null), pairwise(), share());
+        return controlWithPrevious$.pipe(switchMap(([previous, current]) => {
+            if (!current) {
+                // Realtime is disabled
+                if (previous === null) {
+                    // Initial emission while disabled
+                    return this.strategy.fetchCurrentValue().pipe(take(1));
+                }
+                else if (this.config.preserveValueOnPause) {
+                    // Was previously enabled - preserve last value
+                    return NEVER;
+                }
+                else {
+                    // Don't preserve value - fetch current
+                    return this.strategy.fetchCurrentValue().pipe(take(1));
+                }
+            }
+            else {
+                // Realtime is enabled
+                if (this.config.refetchOnResume || previous === null) {
+                    // Re-fetch current value and start streaming
+                    return this.strategy
+                        .fetchCurrentValue()
+                        .pipe(switchMap(currentValue => this.strategy.createRealtimeStream(currentValue)));
+                }
+                else {
+                    // Continue with realtime stream without re-fetching
+                    return this.strategy.createRealtimeStream(null);
+                }
+            }
+        }));
+    }
+}
+
+/**
+ * Creates an Observable that tracks the latest measurement value for a specific datapoint.
+ * Combines initial server fetch with real-time measurement updates.
+ *
+ * @param config - Measurement configuration (datapoint, result type, etc.)
+ * @param metadata - Configuration controlling the behavior of the function
+ * @returns Observable<string> - Stream of measurement string values
+ */
+function lastMeasurementValue(config, metadata = { mode: 'realtime' }) {
+    const injector = inject(Injector);
+    const strategy = new LastMeasurementStrategy(config, injector);
+    const handler = new RealtimeValueHandler(strategy);
+    return handler.getValue(metadata);
+}
+
+const lastMeasurement = {
+    name: 'lastMeasurement',
+    contextType: ['device', 'asset', 'group'],
+    prop: {
+        c8y_JsonSchema: {
+            properties: {
+                lastMeasurement: {
+                    label: 'Last measurement',
+                    type: 'string'
+                }
+            }
+        },
+        name: 'lastMeasurement',
+        label: gettext('Last measurement'),
+        type: 'string',
+        config: { dp: [], resultType: 1 },
+        computed: true,
+        isEditable: false,
+        isStandardProperty: true
+    },
+    loadConfigComponent: () => import('./c8y-ngx-components-computed-asset-properties-last-measurement-config.component-DkrSvf9F.mjs').then(m => m.ComputedPropertyLastMeasurementConfigComponent),
+    value: ({ config }) => {
+        return lastMeasurementValue(config);
+    }
+};
+
+class ChildCountStrategy {
+    constructor(asset, childType, injector) {
+        this.asset = asset;
+        this.childType = childType;
+        this.inventoryService = injector.get(InventoryService);
+        this.moRealtimeService = injector.get(ManagedObjectRealtimeService);
+    }
+    fetchCurrentValue() {
+        return from(this.inventoryService.detail(this.asset.id, { withChildren: true })).pipe(map(resp => resp?.data?.[this.childType]?.references?.length || 0));
+    }
+    createRealtimeStream(initialValue) {
+        return this.moRealtimeService.onAll$(this.asset.id).pipe(map(resp => resp?.data?.[this.childType]?.references?.length || 0), startWith(initialValue));
+    }
+}
+
+/**
+ * Shared function that tracks the count of child items (devices or assets) for a specific managed object.
+ * Supports real-time updates when child items are added or removed.
+ *
+ * @param asset - The managed object to track child items for
+ * @param childType - Type of child items ('childDevices' or 'childAssets')
+ * @param metadata - Configuration controlling the behavior of the function
+ * @returns Observable<number> - Stream of child items count values
+ */
+function childCountValue(asset, metadata = { mode: 'realtime' }, childType) {
+    const injector = inject(Injector);
+    const strategy = new ChildCountStrategy(asset, childType, injector);
+    const handler = new RealtimeValueHandler(strategy);
+    return handler.getValue(metadata);
+}
+
+const childAssetsCount = {
+    name: 'childAssetsCount',
+    contextType: ['group', 'asset'],
+    prop: {
+        c8y_JsonSchema: {
+            properties: {
+                childAssetsCount: {
+                    label: 'Number of child assets',
+                    type: 'number'
+                }
+            }
+        },
+        name: 'childAssetsCount',
+        label: gettext('Number of child assets'),
+        type: 'number',
+        computed: true,
+        isEditable: false,
+        isStandardProperty: true
+    },
+    value: ({ context, metadata }) => childAssetsCountValue(context, metadata)
+};
+/**
+ * Creates an Observable that tracks the count of child assets for a specific asset.
+ * Supports real-time updates when child assets are added or removed.
+ *
+ * @param asset - The managed object (asset) to track child assets for
+ * @param metadata - Configuration controlling the behavior of the function
+ * @returns Observable<number> - Stream of child assets count values
+ */
+function childAssetsCountValue(asset, metadata = { mode: 'realtime' }) {
+    return childCountValue(asset, metadata, 'childAssets');
+}
+
+/**
+ * Base class for count-based strategies
+ * Provides common accumulation logic
+ */
+class CountStrategyBase {
+    createRealtimeStream(initialValue) {
+        return this.getRealtimeIncrement$().pipe(scan((count, increment) => count + increment, initialValue), startWith(initialValue));
+    }
+}
+
+class AlarmCountStrategy extends CountStrategyBase {
+    constructor(config, asset, dateFrom, injector) {
+        super();
+        this.config = config;
+        this.asset = asset;
+        this.dateFrom = dateFrom;
+        this.alarmService = injector.get(AlarmService);
+        this.alarmRealtimeService = injector.get(AlarmRealtimeService);
+        this.startTime = new Date();
+    }
+    fetchCurrentValue() {
+        const severities = Object.keys(this.config.severities || {}).filter(key => this.config.severities[key]);
+        const filters = {
+            source: this.asset.id,
+            dateFrom: this.dateFrom.toISOString(),
+            type: this.config.type,
+            pageSize: 1,
+            withTotalElements: true,
+            ...(severities.length && { severity: severities.join(',') })
+        };
+        return from(this.alarmService.list(filters)).pipe(map(resp => resp?.paging?.totalElements || 0), tap(() => (this.startTime = new Date())) // Update start time after fetch
+        );
+    }
+    getRealtimeIncrement$() {
+        return this.alarmRealtimeService.onAll$(this.asset.id).pipe(map(({ data }) => data), filter(alarm => alarm.type === this.config.type &&
+            this.config.severities[alarm.severity] &&
+            new Date(alarm.creationTime) > this.startTime), tap(() => (this.startTime = new Date())), map(() => 1) // Each matching alarm increments by 1
+        );
+    }
+}
+
+/**
+ * Creates an Observable that tracks alarm count for a specific asset.
+ * When real-time is paused and resumed, it re-fetches the current count from server
+ * to account for alarms that occurred during the pause.
+ *
+ * @param config - Alarm filtering configuration (type, severities, etc.)
+ * @param asset - The managed object (device/asset) to track alarms for
+ * @param dateFrom - Start date for counting alarms
+ * @param metadata - Configuration controlling the behavior of the function
+ * @returns Observable<number> - Stream of alarm count values
+ */
+function alarmCountValue(config, asset, dateFrom, metadata = { mode: 'realtime' }) {
+    const injector = inject(Injector);
+    const strategy = new AlarmCountStrategy(config, asset, dateFrom, injector);
+    const handler = new RealtimeValueHandler(strategy);
+    return handler.getValue(metadata);
+}
+
+const alarmCount3Months = {
+    name: 'alarmCount3Months',
+    contextType: ['device', 'group', 'asset'],
+    prop: {
+        c8y_JsonSchema: {
+            properties: {
+                alarmCount3Months: {
+                    label: 'Alarm count 3 months',
+                    type: 'number'
+                }
+            }
+        },
+        name: 'alarmCount3Months',
+        label: gettext('Alarm count 3 months'),
+        type: 'number',
+        config: { type: '' },
+        computed: true,
+        isEditable: false,
+        isStandardProperty: true
+    },
+    loadConfigComponent: () => import('./c8y-ngx-components-computed-asset-properties-alarm-count-config.component-SA0syLy7.mjs').then(m => m.ComputedPropertyAlarmCountConfigComponent),
+    value: ({ config, context, metadata }) => alarmCount3MonthsValue(config, context, metadata)
+};
+function alarmCount3MonthsValue(config, asset, metadata) {
+    const threeMonthsAgo = new Date();
+    threeMonthsAgo.setMonth(threeMonthsAgo.getMonth() - 3);
+    return alarmCountValue(config, asset, threeMonthsAgo, metadata);
+}
+
+const alarmCountToday = {
+    name: 'alarmCountToday',
+    contextType: ['device', 'group', 'asset'],
+    prop: {
+        c8y_JsonSchema: {
+            properties: {
+                alarmCountToday: {
+                    label: 'Alarm count today',
+                    type: 'number'
+                }
+            }
+        },
+        name: 'alarmCountToday',
+        label: gettext('Alarm count today'),
+        type: 'number',
+        config: { type: '' },
+        computed: true,
+        isEditable: false,
+        isStandardProperty: true
+    },
+    loadConfigComponent: () => import('./c8y-ngx-components-computed-asset-properties-alarm-count-config.component-SA0syLy7.mjs').then(m => m.ComputedPropertyAlarmCountConfigComponent),
+    value: ({ config, context, metadata }) => alarmCountTodayValue(config, context, metadata)
+};
+function alarmCountTodayValue(config, asset, metadata) {
+    const oneDayAgo = new Date();
+    oneDayAgo.setDate(oneDayAgo.getDate() - 1);
+    return alarmCountValue(config, asset, oneDayAgo, metadata);
+}
+
+class EventCountStrategy extends CountStrategyBase {
+    constructor(config, asset, dateFrom, injector) {
+        super();
+        this.config = config;
+        this.asset = asset;
+        this.dateFrom = dateFrom;
+        this.eventService = injector.get(EventService);
+        this.eventRealtimeService = injector.get(EventRealtimeService);
+    }
+    fetchCurrentValue() {
+        const filters = {
+            source: this.asset.id,
+            dateFrom: this.dateFrom.toISOString(),
+            type: this.config.type,
+            pageSize: 1,
+            withTotalElements: true
+        };
+        return from(this.eventService.list(filters)).pipe(map(resp => resp?.paging?.totalElements || 0));
+    }
+    getRealtimeIncrement$() {
+        return this.eventRealtimeService.onAll$(this.asset.id).pipe(map(({ data }) => data), filter(event => event.type === this.config.type && new Date(event.time) >= this.dateFrom), map(() => 1));
+    }
+}
+
+/**
+ * Creates an Observable that tracks event count for a specific asset.
+ * When real-time is paused and resumed, it re-fetches the current count from server
+ * to account for events that occurred during the pause.
+ *
+ * @param config - Event filtering configuration (type, etc.)
+ * @param asset - The managed object (device/asset) to track events for
+ * @param dateFrom - Start date for counting events
+ * @param metadata - Configuration controlling the behavior of the function
+ * @returns Observable<number> - Stream of event count values
+ */
+function eventCountValue(config, asset, dateFrom, metadata = { mode: 'realtime' }) {
+    const injector = inject(Injector);
+    const strategy = new EventCountStrategy(config, asset, dateFrom, injector);
+    const handler = new RealtimeValueHandler(strategy);
+    return handler.getValue(metadata);
+}
+
+const eventCountToday = {
+    name: 'eventCountToday',
+    contextType: ['device', 'group', 'asset'],
+    prop: {
+        c8y_JsonSchema: {
+            properties: {
+                eventCountToday: {
+                    label: 'Event count today',
+                    type: 'number'
+                }
+            }
+        },
+        name: 'eventCountToday',
+        label: gettext('Event count today'),
+        type: 'number',
+        config: { type: '' },
+        computed: true,
+        isEditable: false,
+        isStandardProperty: true
+    },
+    loadConfigComponent: () => import('./c8y-ngx-components-computed-asset-properties-event-count-config.component-CaTb9cph.mjs').then(m => m.ComputedPropertyEventCountConfigComponent),
+    value: ({ config, context, metadata }) => eventCountTodayValue(config, context, metadata)
+};
+function eventCountTodayValue(config, asset, metadata) {
+    const today = new Date();
+    today.setHours(0, 0, 0, 0);
+    return eventCountValue(config, asset, today, metadata);
+}
+
+const eventCount3Months = {
+    name: 'eventCount3Months',
+    contextType: ['device', 'group', 'asset'],
+    prop: {
+        c8y_JsonSchema: {
+            properties: {
+                eventCount3Months: {
+                    label: 'Event count 3 months',
+                    type: 'number'
+                }
+            }
+        },
+        name: 'eventCount3Months',
+        label: gettext('Event count 3 months'),
+        type: 'number',
+        config: { type: '' },
+        computed: true,
+        isEditable: false,
+        isStandardProperty: true
+    },
+    loadConfigComponent: () => import('./c8y-ngx-components-computed-asset-properties-event-count-config.component-CaTb9cph.mjs').then(m => m.ComputedPropertyEventCountConfigComponent),
+    value: ({ config, context, metadata }) => eventCount3MonthsValue(config, context, metadata)
+};
+function eventCount3MonthsValue(config, asset, metadata) {
+    const threeMonthsAgo = new Date();
+    threeMonthsAgo.setMonth(threeMonthsAgo.getMonth() - 3);
+    return eventCountValue(config, asset, threeMonthsAgo, metadata);
+}
+
+const configurationSnapshot = {
+    name: 'configurationSnapshot',
+    contextType: ['device', 'asset'],
+    prop: {
+        c8y_JsonSchema: {
+            properties: {
+                configurationSnapshot: {
+                    label: 'Configuration snapshot',
+                    type: 'string'
+                }
+            }
+        },
+        contextType: ['device', 'asset'],
+        name: 'configurationSnapshot',
+        label: gettext('Configuration snapshot'),
+        type: 'string',
+        config: { legacy: true },
+        computed: true,
+        isEditable: false,
+        isStandardProperty: true
+    },
+    loadConfigComponent: () => import('./c8y-ngx-components-computed-asset-properties-configuration-snapshot-config.component-BOmgJI14.mjs').then(m => m.ConfigurationSnapshotConfigComponent),
+    value: ({ config, context }) => configurationSnapshotValue(config, context)
+};
+function configurationSnapshotValue(config, asset) {
+    if (config.legacy) {
+        const configId = asset.c8y_ConfigurationDump?.id;
+        if (!configId) {
+            return of(null);
+        }
+        const injector = inject(Injector);
+        const inventoryService = injector.get(InventoryService);
+        return from(inventoryService.detail(configId)).pipe(switchMap(({ data }) => {
+            return of(data?.name);
+        }));
+    }
+    else {
+        const fragment = `c8y_Configuration_${config.type}`;
+        return of(asset[fragment]?.name);
+    }
+}
+
+const childDevicesCount = {
+    name: 'childDevicesCount',
+    contextType: ['group', 'device', 'asset'],
+    prop: {
+        c8y_JsonSchema: {
+            properties: {
+                childDevicesCount: {
+                    label: 'Number of child devices',
+                    type: 'number'
+                }
+            }
+        },
+        name: 'childDevicesCount',
+        label: gettext('Number of child devices'),
+        type: 'number',
+        computed: true,
+        isEditable: false,
+        isStandardProperty: true
+    },
+    value: ({ context, metadata }) => childDevicesCountValue(context, metadata)
+};
+/**
+ * Creates an Observable that tracks the count of child devices for a specific asset.
+ * Supports real-time updates when child devices are added or removed.
+ *
+ * @param asset - The managed object (asset) to track child devices for
+ * @param metadata - Configuration controlling the behavior of the function
+ * @returns Observable<number> - Stream of child devices count values
+ */
+function childDevicesCountValue(asset, metadata = { mode: 'realtime' }) {
+    return childCountValue(asset, metadata, 'childDevices');
+}
+
+class LastDeviceMessageStrategy {
+    constructor(asset, injector) {
+        this.asset = asset;
+        this.measurementService = injector.get(MeasurementService);
+        this.measurementRealtime = injector.get(MeasurementRealtimeService);
+        this.eventService = injector.get(EventService);
+        this.eventRealtimeService = injector.get(EventRealtimeService);
+        this.alarmService = injector.get(AlarmService);
+        this.alarmRealtimeService = injector.get(AlarmRealtimeService);
+        this.operationService = injector.get(OperationService);
+        this.operationRealtimeService = injector.get(OperationRealtimeService);
+        this.startTime = new Date();
+    }
+    fetchCurrentValue() {
+        const fetchFilter = {
+            source: this.asset.id,
+            pageSize: 1,
+            revert: true
+        };
+        const fetchLatestMeasurement = () => {
+            return from(this.measurementService.list(fetchFilter)).pipe(map(resp => resp.data?.[0]?.time || null), catchError(() => of(null)));
+        };
+        const fetchLatestEvent = () => {
+            return from(this.eventService.list(fetchFilter)).pipe(map(resp => resp.data?.[0]?.time || null), catchError(() => of(null)));
+        };
+        const fetchLatestAlarm = () => {
+            return from(this.alarmService.list(fetchFilter)).pipe(map(resp => resp.data?.[0]?.time || null), catchError(() => of(null)));
+        };
+        const fetchLatestOperation = () => {
+            return from(this.operationService.list(fetchFilter)).pipe(map(resp => resp.data?.[0]?.creationTime || null), catchError(() => of(null)));
+        };
+        return combineLatest([
+            fetchLatestMeasurement(),
+            fetchLatestEvent(),
+            fetchLatestAlarm(),
+            fetchLatestOperation()
+        ]).pipe(map(timestamps => {
+            const validTimestamps = timestamps.filter(Boolean);
+            if (validTimestamps.length === 0) {
+                return null;
+            }
+            const latest = validTimestamps.reduce((latest, current) => {
+                return new Date(current) > new Date(latest) ? current : latest;
+            });
+            // Update start time for realtime filtering
+            this.startTime = new Date();
+            return latest;
+        }));
+    }
+    createRealtimeStream(initialValue) {
+        const measurementStream$ = this.measurementRealtime.onAll$(this.asset.id).pipe(map(({ data }) => data.time), filter(time => new Date(time) > this.startTime));
+        const eventStream$ = this.eventRealtimeService.onAll$(this.asset.id).pipe(map(({ data }) => data.time), filter(time => new Date(time) > this.startTime));
+        const alarmStream$ = this.alarmRealtimeService.onAll$(this.asset.id).pipe(map(({ data }) => data.time), filter(time => time && new Date(time) > this.startTime));
+        const operationStream$ = this.operationRealtimeService.onAll$(this.asset.id).pipe(map(({ data }) => data.creationTime), filter(time => time && new Date(time) > this.startTime));
+        return merge(measurementStream$, eventStream$, alarmStream$, operationStream$).pipe(scan((latestTimestamp, newTimestamp) => {
+            return new Date(newTimestamp) > new Date(latestTimestamp) ? newTimestamp : latestTimestamp;
+        }, initialValue), startWith(initialValue));
+    }
+}
+
+/**
+ * Gets the latest timestamp from events, alarms, measurements, and operations for a device.
+ * Returns the most recent timestamp across all these sources.
+ *
+ * @param asset - The managed object (device/asset) to track
+ * @param metadata - Configuration controlling the behavior of the function
+ * @returns Observable<string> - Stream of latest timestamp values
+ */
+function getLastDeviceMessage(asset, metadata = { mode: 'realtime' }) {
+    const injector = inject(Injector);
+    const strategy = new LastDeviceMessageStrategy(asset, injector);
+    const handler = new RealtimeValueHandler(strategy);
+    return handler.getValue(metadata);
+}
+
+const lastDeviceMessage = {
+    name: 'lastDeviceMessage',
+    contextType: ['device'],
+    prop: {
+        c8y_JsonSchema: {
+            properties: {
+                lastDeviceMessage: {
+                    label: 'Last device message',
+                    type: 'string'
+                }
+            }
+        },
+        name: 'lastDeviceMessage',
+        label: gettext('Last device message'),
+        printFormat: 'datetime',
+        type: 'string',
+        computed: true,
+        isEditable: false,
+        isStandardProperty: true
+    },
+    value: ({ context }) => {
+        return getLastDeviceMessage(context);
+    }
+};
+
+const RESULT_TYPES = {
+    RAW_VALUE: { name: 'RAW_VALUE', value: 'RAW_VALUE', label: gettext('Raw value') },
+    ENUM_VALUE: { name: 'ENUM_VALUE', value: 'ENUM_VALUE', label: gettext('Enum value') }
+};
+
+class FieldbusService {
+    constructor() {
+        this.inventory = inject(InventoryService);
+        this.computedProperties = inject(ComputedPropertiesService);
+    }
+    async getDeviceTypeOf(fieldbusDevice) {
+        const typeRef = fieldbusDevice?.c8y_ModbusDevice?.type;
+        if (!typeRef) {
+            throw new Error('Provided device is missing c8y_ModbusDevice.type.');
+        }
+        const match = /^\/inventory\/managedObjects\/(\d+)$/.exec(typeRef);
+        if (!match) {
+            throw new Error(`Provided Fieldbus type reference ${typeRef} has invalid format, expected: /inventory/managedObjects/{id}`);
+        }
+        const deviceTypeId = match[1];
+        try {
+            const { data } = await this.inventory.detail(deviceTypeId);
+            return data;
+        }
+        catch (ex) {
+            const errorMessage = ex instanceof Error ? ex.message : String(ex);
+            throw new Error(`Could not fetch Fieldbus device type with ID ${deviceTypeId}: ${errorMessage}.`);
+        }
+    }
+    async migrateFieldbusProperty(legacyProperty, fieldbusDevice) {
+        if (!legacyProperty.fieldbus) {
+            throw new Error('Provided property is not a legacy Fieldbus property.');
+        }
+        const computedPropertyName = 'fieldbusItemStatus';
+        const computedProperty = await this.computedProperties.getByName(computedPropertyName);
+        const [statusPropertyName, itemName] = legacyProperty.keyPath;
+        const itemType = statusPropertyName === 'c8y_CoilStatus' ? 'c8y_Coil' : 'c8y_Register';
+        const deviceType = await this.getDeviceTypeOf(fieldbusDevice);
+        const itemListPropertyName = `${itemType}s`;
+        const itemList = deviceType[itemListPropertyName] || [];
+        const item = itemList.find(i => i.name === itemName);
+        const resultType = item.enumValues ? 'ENUM_VALUE' : 'RAW_VALUE';
+        return {
+            ...computedProperty.prop,
+            active: true,
+            temporary: true,
+            asset: {
+                id: fieldbusDevice.id,
+                name: fieldbusDevice.name
+            },
+            config: {
+                itemName,
+                itemType,
+                resultType
+            }
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: FieldbusService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: FieldbusService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: FieldbusService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class FieldbusItemStatusStrategy {
+    constructor(asset, config, injector) {
+        this.asset = asset;
+        this.config = config;
+        this.inventoryService = injector.get(InventoryService);
+        this.moRealtimeService = injector.get(ManagedObjectRealtimeService);
+        this.fieldbusService = injector.get(FieldbusService);
+    }
+    fetchCurrentValue() {
+        return from(this.inventoryService.detail(this.asset.id)).pipe(switchMap(({ data }) => this.getStatus(data)));
+    }
+    createRealtimeStream(initialValue) {
+        return this.moRealtimeService.onAll$(this.asset.id).pipe(switchMap(({ data }) => this.getStatus(data)), startWith(initialValue));
+    }
+    async getStatus(fieldbusDevice) {
+        const fieldbusDeviceType = await this.getFieldbusDeviceType(fieldbusDevice);
+        if (!fieldbusDeviceType) {
+            return null;
+        }
+        const itemListPropertyName = `${this.config.itemType}s`;
+        const statusPropertyName = `${this.config.itemType}Status`;
+        const items = fieldbusDeviceType[itemListPropertyName] ?? [];
+        const item = items.find(i => i.name === this.config.itemName);
+        const statusProperty = get(fieldbusDevice, statusPropertyName);
+        const rawValue = get(statusProperty, this.config.itemName);
+        if (this.config.resultType === RESULT_TYPES.ENUM_VALUE.value && item?.enumValues) {
+            return item.enumValues[rawValue] ?? rawValue;
+        }
+        else {
+            return rawValue;
+        }
+    }
+    async getFieldbusDeviceType(fieldbusDevice) {
+        if (this._fieldbusDeviceType === undefined) {
+            try {
+                this._fieldbusDeviceType = await this.fieldbusService.getDeviceTypeOf(fieldbusDevice);
+            }
+            catch (ex) {
+                this._fieldbusDeviceType = null;
+            }
+        }
+        return this._fieldbusDeviceType;
+    }
+}
+
+const fieldbusItemStatus = {
+    name: 'fieldbusItemStatus',
+    contextType: ['device'],
+    prop: {
+        c8y_JsonSchema: {
+            properties: {
+                fieldbusItemStatus: {
+                    label: gettext('Fieldbus item status'),
+                    type: ['number', 'string']
+                }
+            }
+        },
+        name: 'fieldbusItemStatus',
+        label: gettext('Fieldbus item status'),
+        type: ['number', 'string'],
+        config: {
+            itemName: null,
+            itemType: null,
+            resultType: 'RAW_VALUE'
+        },
+        computed: true,
+        isEditable: false,
+        isStandardProperty: true
+    },
+    loadConfigComponent: () => import('./c8y-ngx-components-computed-asset-properties-fieldbus-item-status-config.component-Bg9mbBkF.mjs').then(m => m.FieldbusItemStatusConfigComponent),
+    value: ({ config, context }) => fieldbusItemStatusValue(context, config)
+};
+function fieldbusItemStatusValue(asset, config, metadata = { mode: 'realtime' }) {
+    const injector = inject(Injector);
+    const strategy = new FieldbusItemStatusStrategy(asset, config, injector);
+    const handler = new RealtimeValueHandler(strategy);
+    return handler.getValue(metadata);
+}
+
+const computedAssetPropertiesProviders = [
+    AlarmRealtimeService,
+    EventRealtimeService,
+    MeasurementRealtimeService,
+    OperationRealtimeService,
+    ManagedObjectRealtimeService,
+    hookComputedProperty([
+        lastMeasurement,
+        lastDeviceMessage,
+        childAssetsCount,
+        childDevicesCount,
+        alarmCount3Months,
+        alarmCountToday,
+        eventCountToday,
+        eventCount3Months,
+        configurationSnapshot,
+        fieldbusItemStatus
+    ])
+];
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { FieldbusService as F, RESULT_TYPES as R, computedAssetPropertiesProviders as c };
+//# sourceMappingURL=c8y-ngx-components-computed-asset-properties-c8y-ngx-components-computed-asset-properties-C5oS4Be-.mjs.map