@matterbridge/core 3.9.5-dev-20260715-33298cd → 3.10.0-dev-20260716-7f8762c

package/dist/jestutils/jestMatterTest.js

@@ -1,281 +0,0 @@
-import '@matter/nodejs';
-import path from 'node:path';
-import { inspect } from 'node:util';
-import { Environment, Lifecycle, LogFormat as MatterLogFormat, LogLevel as MatterLogLevel } from '@matter/general';
-import { Endpoint, ServerNode, ServerNodeStore } from '@matter/node';
-import { AggregatorEndpoint } from '@matter/node/endpoints';
-import { DeviceTypeId, VendorId } from '@matter/types/datatype';
-import { MATTER_STORAGE_DIR } from '@matterbridge/types';
-import { er, rs } from 'node-ansi-logger';
-import { flushAsync } from './flushAsync.js';
-import { HOMEDIR, NAME } from './jestSetupTest.js';
-export let environment;
-export let server;
-export let aggregator;
-export async function createTestEnvironment() {
-    expect(NAME).toBeDefined();
-    expect(typeof NAME).toBe('string');
-    expect(NAME.length).toBeGreaterThanOrEqual(4);
-    environment = Environment.default;
-    environment.vars.set('log.level', MatterLogLevel.DEBUG);
-    environment.vars.set('log.format', MatterLogFormat.ANSI);
-    environment.vars.set('path.root', path.join(HOMEDIR, '.matterbridge', MATTER_STORAGE_DIR));
-    environment.vars.set('runtime.signals', false);
-    environment.vars.set('runtime.exitcode', false);
-    return environment;
-}
-export async function destroyTestEnvironment() {
-}
-export function getPlatformMatterbridge() {
-    return {
-        systemInformation: {
-            interfaceName: 'eth0',
-            macAddress: 'aa:bb:cc:dd:ee:ff',
-            ipv4Address: '192.168.68.100',
-            ipv6Address: 'fd78:cbf8:4939:46e2:51b2:2163:7f88:c33d',
-            nodeVersion: '24.16.0',
-            hostname: 'matterbridge',
-            user: 'test',
-            osType: 'Linux',
-            osRelease: '6.8.0-xxxx',
-            osPlatform: 'linux',
-            osArch: 'arm64',
-            totalMemory: '0 B',
-            freeMemory: '0 B',
-            systemUptime: '0s',
-            processUptime: '0s',
-            cpuUsage: '0%',
-            processCpuUsage: '0%',
-            rss: '0 B',
-            heapTotal: '0 B',
-            heapUsed: '0 B',
-        },
-        rootDirectory: HOMEDIR,
-        homeDirectory: HOMEDIR,
-        matterbridgeDirectory: path.join(HOMEDIR, '.matterbridge'),
-        matterbridgePluginDirectory: path.join(HOMEDIR, 'Matterbridge'),
-        matterbridgeCertDirectory: path.join(HOMEDIR, '.mattercert'),
-        globalModulesDirectory: path.join(HOMEDIR, 'node_modules'),
-        matterbridgeVersion: '3.9.5',
-        matterbridgeLatestVersion: '3.9.5',
-        matterbridgeDevVersion: '3.9.5',
-        frontendVersion: '3.9.5',
-        bridgeMode: '',
-        restartMode: '',
-        virtualMode: 'mounted_switch',
-        aggregatorVendorId: 0xfff1,
-        aggregatorVendorName: 'Matterbridge',
-        aggregatorProductId: 0x8000,
-        aggregatorProductName: 'Matterbridge Jest',
-        addBridgedEndpoint: jest.fn(async () => {
-            return Promise.resolve(true);
-        }),
-        removeBridgedEndpoint: jest.fn(async () => {
-            return Promise.resolve(true);
-        }),
-        removeAllBridgedEndpoints: jest.fn(async () => {
-            return Promise.resolve(true);
-        }),
-        addVirtualEndpoint: jest.fn(async () => {
-            return Promise.resolve();
-        }),
-    };
-}
-export async function flushAllEndpointNumberPersistence(targetServer, rounds = 3, ticks = 1, microTurns = 1, pause = 10) {
-    const nodeStore = targetServer.env.get(ServerNodeStore);
-    for (let i = 0; i < rounds; i++) {
-        await flushAsync(ticks, microTurns, pause);
-        await nodeStore.endpointStores.close();
-    }
-}
-function getRootServerNode(endpoint) {
-    let current = endpoint;
-    while (current.owner) {
-        current = current.owner;
-    }
-    return current;
-}
-function collectAllEndpoints(root) {
-    const list = [];
-    const walk = (ep) => {
-        list.push(ep);
-        if (ep.parts) {
-            for (const child of ep.parts) {
-                walk(child);
-            }
-        }
-    };
-    walk(root);
-    return list;
-}
-export async function assertAllEndpointNumbersPersisted(targetServer) {
-    const nodeStore = targetServer.env.get(ServerNodeStore);
-    await nodeStore.endpointStores.close();
-    const all = collectAllEndpoints(targetServer);
-    for (const ep of all) {
-        const store = nodeStore.storeForEndpoint(ep);
-        if (ep.maybeNumber === 0) {
-            expect(store.number ?? 0).toBe(0);
-        }
-        else {
-            expect(store.number).toBeGreaterThan(0);
-        }
-    }
-    return all.length;
-}
-export async function closeServerNodeStores(targetServer) {
-    if (!targetServer)
-        targetServer = server;
-    await targetServer?.env.get(ServerNodeStore)?.endpointStores.close();
-}
-export async function createServerNode(port, deviceType = DeviceTypeId(0x000e), ticks = 1, microTurns = 1, pause = 10) {
-    const { randomBytes } = await import('node:crypto');
-    const random = randomBytes(8).toString('hex');
-    server = await ServerNode.create({
-        id: NAME + 'ServerNode',
-        environment,
-        productDescription: {
-            name: NAME + 'ServerNode',
-            deviceType: DeviceTypeId(deviceType),
-            vendorId: VendorId(0xfff1),
-            productId: 0x8000,
-        },
-        basicInformation: {
-            vendorId: VendorId(0xfff1),
-            vendorName: 'Matterbridge',
-            productId: 0x8000,
-            productName: ('Matterbridge ' + NAME).slice(0, 32),
-            productLabel: ('Label ' + NAME).slice(0, 64),
-            nodeLabel: (NAME + 'ServerNode').slice(0, 32),
-            hardwareVersion: 1,
-            softwareVersion: 1,
-            reachable: true,
-            serialNumber: 'SN' + random,
-            uniqueId: 'UI' + random,
-        },
-        network: {
-            listeningAddressIpv4: undefined,
-            listeningAddressIpv6: undefined,
-            port,
-            tcp: true,
-            transportPreference: 'udp',
-        },
-        operationalCredentials: {
-            certification: undefined,
-        },
-    });
-    expect(server).toBeDefined();
-    expect(server.lifecycle.isReady).toBeTruthy();
-    aggregator = new Endpoint(AggregatorEndpoint, {
-        id: NAME + 'AggregatorNode',
-    });
-    expect(aggregator).toBeDefined();
-    await server.add(aggregator);
-    expect(server.parts.has(aggregator.id)).toBeTruthy();
-    expect(server.parts.has(aggregator)).toBeTruthy();
-    expect(aggregator.lifecycle.isReady).toBeTruthy();
-    expect(server.lifecycle.isOnline).toBeFalsy();
-    await flushAsync(ticks, microTurns, pause);
-    return [server, aggregator];
-}
-export async function startServerNode(ticks = 1, microTurns = 1, pause = 10) {
-    if (!server || !aggregator) {
-        throw new Error('Server node and aggregator must be created before starting the server. Call createServerNode() first.');
-    }
-    await new Promise((resolve, reject) => {
-        server.lifecycle.online.on(() => {
-            resolve();
-        });
-        server.start().catch((err) => reject(err));
-    });
-    expect(server.lifecycle.isReady).toBeTruthy();
-    expect(server.lifecycle.isOnline).toBeTruthy();
-    expect(server.lifecycle.isCommissioned).toBeFalsy();
-    expect(server.lifecycle.isPartsReady).toBeTruthy();
-    expect(server.lifecycle.hasId).toBeTruthy();
-    expect(server.lifecycle.hasNumber).toBeTruthy();
-    expect(aggregator.lifecycle.isReady).toBeTruthy();
-    expect(aggregator.lifecycle.isInstalled).toBeTruthy();
-    expect(aggregator.lifecycle.isPartsReady).toBeTruthy();
-    expect(aggregator.lifecycle.hasId).toBeTruthy();
-    expect(aggregator.lifecycle.hasNumber).toBeTruthy();
-    await flushAsync(ticks, microTurns, pause);
-    return [server, aggregator];
-}
-export async function stopServerNode(ticks = 1, microTurns = 1, pause = 10) {
-    await flushAllEndpointNumberPersistence(server);
-    await assertAllEndpointNumbersPersisted(server);
-    expect(server).toBeDefined();
-    expect(server.lifecycle.isReady).toBeTruthy();
-    expect(server.lifecycle.isOnline).toBeTruthy();
-    await server.close();
-    expect(server.lifecycle.isReady).toBeFalsy();
-    expect(server.lifecycle.isOnline).toBeFalsy();
-    await flushAsync(ticks, microTurns, pause);
-}
-export async function flushServerNode(ticks = 1, microTurns = 1, pause = 10) {
-    await flushAllEndpointNumberPersistence(server);
-    await assertAllEndpointNumbersPersisted(server);
-    expect(server).toBeDefined();
-    expect(server.lifecycle.isReady).toBeTruthy();
-    expect(server.lifecycle.isOnline).toBeFalsy();
-    await server.close();
-    expect(server.lifecycle.isReady).toBeFalsy();
-    expect(server.lifecycle.isOnline).toBeFalsy();
-    await flushAsync(ticks, microTurns, pause);
-}
-export async function addDevice(owner, device, rounds = 3, pause = 10) {
-    expect(owner).toBeDefined();
-    expect(device).toBeDefined();
-    expect(owner.lifecycle.isReady).toBeTruthy();
-    expect(owner.construction.status).toBe(Lifecycle.Status.Active);
-    expect(owner.lifecycle.isPartsReady).toBeTruthy();
-    const rootServerNode = getRootServerNode(owner);
-    await flushAllEndpointNumberPersistence(rootServerNode, rounds, pause);
-    try {
-        await owner.add(device);
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : error;
-        const errorInspect = inspect(error, { depth: 10 });
-        process.stderr.write(`${er}Error adding device ${device.maybeId}.${device.maybeNumber}: ${errorMessage}${rs}\nStack: ${errorInspect}\n`);
-        return false;
-    }
-    await device.construction.ready;
-    expect(owner.parts.has(device)).toBeTruthy();
-    expect(owner.lifecycle.isPartsReady).toBeTruthy();
-    expect(device.lifecycle.isReady).toBeTruthy();
-    expect(device.lifecycle.isInstalled).toBeTruthy();
-    expect(device.lifecycle.hasId).toBeTruthy();
-    expect(device.lifecycle.hasNumber).toBeTruthy();
-    expect(device.construction.status).toBe(Lifecycle.Status.Active);
-    await flushAllEndpointNumberPersistence(rootServerNode, rounds, pause);
-    return true;
-}
-export async function deleteDevice(owner, device, rounds = 3, pause = 10) {
-    expect(owner).toBeDefined();
-    expect(device).toBeDefined();
-    expect(owner.lifecycle.isReady).toBeTruthy();
-    expect(owner.construction.status).toBe(Lifecycle.Status.Active);
-    expect(owner.lifecycle.isPartsReady).toBeTruthy();
-    const rootServerNode = getRootServerNode(owner);
-    await flushAllEndpointNumberPersistence(rootServerNode, rounds, pause);
-    try {
-        await device.delete();
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : error;
-        const errorInspect = inspect(error, { depth: 10 });
-        process.stderr.write(`${er}Error deleting device ${device.maybeId}.${device.maybeNumber}: ${errorMessage}${rs}\nStack: ${errorInspect}\n`);
-        return false;
-    }
-    expect(owner.parts.has(device)).toBeFalsy();
-    expect(owner.lifecycle.isPartsReady).toBeTruthy();
-    expect(device.lifecycle.isReady).toBeFalsy();
-    expect(device.lifecycle.isInstalled).toBeFalsy();
-    expect(device.lifecycle.hasId).toBeTruthy();
-    expect(device.lifecycle.hasNumber).toBeTruthy();
-    expect(device.construction.status).toBe(Lifecycle.Status.Destroyed);
-    await flushAllEndpointNumberPersistence(rootServerNode, rounds, pause);
-    return true;
-}

package/dist/jestutils/jestMatterbridgeEndpointSpy.d.ts

@@ -1,7 +0,0 @@
-import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
-export declare const setClusterMatterbridgeEndpointSpy: jest.SpiedFunction<typeof MatterbridgeEndpoint.prototype.setCluster>;
-export declare const setAttributeMatterbridgeEndpointSpy: jest.SpiedFunction<typeof MatterbridgeEndpoint.prototype.setAttribute>;
-export declare const updateAttributeMatterbridgeEndpointSpy: jest.SpiedFunction<typeof MatterbridgeEndpoint.prototype.updateAttribute>;
-export declare const subscribeAttributeMatterbridgeEndpointSpy: jest.SpiedFunction<typeof MatterbridgeEndpoint.prototype.subscribeAttribute>;
-export declare const triggerEventMatterbridgeEndpointSpy: jest.SpiedFunction<typeof MatterbridgeEndpoint.prototype.triggerEvent>;
-export declare const triggerSwitchEventMatterbridgeEndpointSpy: jest.SpiedFunction<typeof MatterbridgeEndpoint.prototype.triggerSwitchEvent>;

package/dist/jestutils/jestMatterbridgeEndpointSpy.js

@@ -1,8 +0,0 @@
-import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
-const { jest } = await import('@jest/globals');
-export const setClusterMatterbridgeEndpointSpy = jest.spyOn(MatterbridgeEndpoint.prototype, 'setCluster');
-export const setAttributeMatterbridgeEndpointSpy = jest.spyOn(MatterbridgeEndpoint.prototype, 'setAttribute');
-export const updateAttributeMatterbridgeEndpointSpy = jest.spyOn(MatterbridgeEndpoint.prototype, 'updateAttribute');
-export const subscribeAttributeMatterbridgeEndpointSpy = jest.spyOn(MatterbridgeEndpoint.prototype, 'subscribeAttribute');
-export const triggerEventMatterbridgeEndpointSpy = jest.spyOn(MatterbridgeEndpoint.prototype, 'triggerEvent');
-export const triggerSwitchEventMatterbridgeEndpointSpy = jest.spyOn(MatterbridgeEndpoint.prototype, 'triggerSwitchEvent');

package/dist/jestutils/jestMatterbridgePlatformSpy.d.ts

@@ -1,43 +0,0 @@
-import { MatterbridgePlatform } from '../matterbridgePlatform.js';
-export declare const destroyMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.destroy>;
-export declare const onStartMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.onStart>;
-export declare const onConfigureMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.onConfigure>;
-export declare const onShutdownMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.onShutdown>;
-export declare const onChangeLoggerLevelMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.onChangeLoggerLevel>;
-export declare const onActionMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.onAction>;
-export declare const onConfigChangedMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.onConfigChanged>;
-export declare const saveConfigMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.saveConfig>;
-export declare const getSchemaMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.getSchema>;
-export declare const setSchemaMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.setSchema>;
-export declare const wssSendRestartRequiredMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.wssSendRestartRequired>;
-export declare const wssSendSnackbarMessageMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.wssSendSnackbarMessage>;
-export declare const sizeMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.size>;
-export declare const getDevicesMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.getDevices>;
-export declare const getDeviceByNameMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.getDeviceByName>;
-export declare const getDeviceByUniqueIdMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.getDeviceByUniqueId>;
-export declare const getDeviceBySerialNumberMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.getDeviceBySerialNumber>;
-export declare const getDeviceByIdMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.getDeviceById>;
-export declare const getDeviceByOriginalIdMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.getDeviceByOriginalId>;
-export declare const getDeviceByNumberMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.getDeviceByNumber>;
-export declare const hasDeviceNameMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.hasDeviceName>;
-export declare const hasDeviceUniqueIdMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.hasDeviceUniqueId>;
-export declare const registerVirtualDeviceMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.registerVirtualDevice>;
-export declare const registerDeviceMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.registerDevice>;
-export declare const unregisterDeviceMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.unregisterDevice>;
-export declare const unregisterAllDevicesMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.unregisterAllDevices>;
-export declare const saveSelectsMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.saveSelects>;
-export declare const clearSelectMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.clearSelect>;
-export declare const clearDeviceSelectMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.clearDeviceSelect>;
-export declare const clearEntitySelectMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.clearEntitySelect>;
-export declare const setSelectDeviceMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.setSelectDevice>;
-export declare const getSelectDeviceMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.getSelectDevice>;
-export declare const setSelectDeviceEntityMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.setSelectDeviceEntity>;
-export declare const getSelectDevicesMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.getSelectDevices>;
-export declare const setSelectEntityMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.setSelectEntity>;
-export declare const getSelectEntityMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.getSelectEntity>;
-export declare const getSelectEntitiesMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.getSelectEntities>;
-export declare const verifyMatterbridgeVersionMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.verifyMatterbridgeVersion>;
-export declare const validateDeviceMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.validateDevice>;
-export declare const validateEntityMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.validateEntity>;
-export declare const clearEndpointNumbersMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.clearEndpointNumbers>;
-export declare const checkEndpointNumbersMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.checkEndpointNumbers>;

package/dist/jestutils/jestMatterbridgePlatformSpy.js

@@ -1,44 +0,0 @@
-import { MatterbridgePlatform } from '../matterbridgePlatform.js';
-const { jest } = await import('@jest/globals');
-export const destroyMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'destroy');
-export const onStartMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'onStart');
-export const onConfigureMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'onConfigure');
-export const onShutdownMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'onShutdown');
-export const onChangeLoggerLevelMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'onChangeLoggerLevel');
-export const onActionMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'onAction');
-export const onConfigChangedMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'onConfigChanged');
-export const saveConfigMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'saveConfig');
-export const getSchemaMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'getSchema');
-export const setSchemaMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'setSchema');
-export const wssSendRestartRequiredMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'wssSendRestartRequired');
-export const wssSendSnackbarMessageMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'wssSendSnackbarMessage');
-export const sizeMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'size');
-export const getDevicesMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'getDevices');
-export const getDeviceByNameMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'getDeviceByName');
-export const getDeviceByUniqueIdMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'getDeviceByUniqueId');
-export const getDeviceBySerialNumberMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'getDeviceBySerialNumber');
-export const getDeviceByIdMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'getDeviceById');
-export const getDeviceByOriginalIdMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'getDeviceByOriginalId');
-export const getDeviceByNumberMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'getDeviceByNumber');
-export const hasDeviceNameMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'hasDeviceName');
-export const hasDeviceUniqueIdMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'hasDeviceUniqueId');
-export const registerVirtualDeviceMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'registerVirtualDevice');
-export const registerDeviceMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'registerDevice');
-export const unregisterDeviceMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'unregisterDevice');
-export const unregisterAllDevicesMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'unregisterAllDevices');
-export const saveSelectsMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'saveSelects');
-export const clearSelectMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'clearSelect');
-export const clearDeviceSelectMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'clearDeviceSelect');
-export const clearEntitySelectMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'clearEntitySelect');
-export const setSelectDeviceMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'setSelectDevice');
-export const getSelectDeviceMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'getSelectDevice');
-export const setSelectDeviceEntityMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'setSelectDeviceEntity');
-export const getSelectDevicesMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'getSelectDevices');
-export const setSelectEntityMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'setSelectEntity');
-export const getSelectEntityMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'getSelectEntity');
-export const getSelectEntitiesMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'getSelectEntities');
-export const verifyMatterbridgeVersionMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'verifyMatterbridgeVersion');
-export const validateDeviceMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'validateDevice');
-export const validateEntityMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'validateEntity');
-export const clearEndpointNumbersMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'clearEndpointNumbers');
-export const checkEndpointNumbersMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'checkEndpointNumbers');

package/dist/jestutils/jestMatterbridgeSpy.d.ts

@@ -1,5 +0,0 @@
-import { Matterbridge } from '../matterbridge.js';
-export declare const addBridgedEndpointMatterbridgeSpy: jest.SpiedFunction<typeof Matterbridge.prototype.addBridgedEndpoint>;
-export declare const removeBridgedEndpointMatterbridgeSpy: jest.SpiedFunction<typeof Matterbridge.prototype.removeBridgedEndpoint>;
-export declare const removeAllBridgedEndpointsMatterbridgeSpy: jest.SpiedFunction<typeof Matterbridge.prototype.removeAllBridgedEndpoints>;
-export declare const addVirtualEndpointMatterbridgeSpy: jest.SpiedFunction<typeof Matterbridge.prototype.addVirtualEndpoint>;

package/dist/jestutils/jestMatterbridgeSpy.js

@@ -1,6 +0,0 @@
-import { Matterbridge } from '../matterbridge.js';
-const { jest } = await import('@jest/globals');
-export const addBridgedEndpointMatterbridgeSpy = jest.spyOn(Matterbridge.prototype, 'addBridgedEndpoint');
-export const removeBridgedEndpointMatterbridgeSpy = jest.spyOn(Matterbridge.prototype, 'removeBridgedEndpoint');
-export const removeAllBridgedEndpointsMatterbridgeSpy = jest.spyOn(Matterbridge.prototype, 'removeAllBridgedEndpoints');
-export const addVirtualEndpointMatterbridgeSpy = jest.spyOn(Matterbridge.prototype, 'addVirtualEndpoint');

package/dist/jestutils/jestMatterbridgeTest.d.ts

@@ -1,21 +0,0 @@
-import type { Endpoint, ServerNode } from '@matter/node';
-import type { AggregatorEndpoint } from '@matter/node/endpoints';
-import type { DeviceManager } from '../deviceManager.js';
-import type { Frontend } from '../frontend.js';
-import { Matterbridge } from '../matterbridge.js';
-import type { MatterbridgePlatform } from '../matterbridgePlatform.js';
-import type { PluginManager } from '../pluginManager.js';
-export declare let matterbridge: Matterbridge;
-export declare let frontend: Frontend;
-export declare let plugins: PluginManager;
-export declare let devices: DeviceManager;
-export declare function startMatterbridge(bridgeMode?: 'bridge' | 'childbridge' | 'controller' | '', frontendPort?: number, matterPort?: number, passcode?: number, discriminator?: number, pluginSize?: number, devicesSize?: number): Promise<Matterbridge>;
-export declare function stopMatterbridge(cleanupPause?: number, destroyPause?: number, closeMdns?: boolean, closeRuntime?: boolean): Promise<void>;
-export declare function createMatterbridgeEnvironment(): Promise<Matterbridge>;
-export declare function startMatterbridgeEnvironment(port?: number, createOnly?: boolean): Promise<[ServerNode, Endpoint<AggregatorEndpoint>]>;
-export declare function addMatterbridgePlatform(platform: MatterbridgePlatform, name?: string): void;
-export declare function stopMatterbridgeEnvironment(createOnly?: boolean): Promise<void>;
-export declare function destroyMatterbridgeEnvironment(cleanupPause?: number, destroyPause?: number, closeMdns?: boolean, closeRuntime?: boolean): Promise<void>;
-export declare function destroyInstance(matterbridge: Matterbridge, cleanupPause?: number, destroyPause?: number): Promise<void>;
-export declare function closeMdnsInstance(matterbridge: Matterbridge): Promise<void>;
-export declare function closeRuntimeInstance(matterbridge: Matterbridge): Promise<void>;