@matterbridge/core 3.5.3 → 3.5.4-dev-20260211-520e349

package/dist/helpers.d.ts

@@ -1,48 +1,5 @@
-/**
- * This file contains the helpers functions of Matterbridge.
- *
- * @file helpers.ts
- * @author Luca Liguori
- * @created 2025-05-12
- * @version 1.0.0
- * @license Apache-2.0
- *
- * Copyright 2025, 2026, 2027 Luca Liguori.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 import { Endpoint } from '@matter/node';
 import { AggregatorEndpoint } from '@matter/node/endpoints/aggregator';
 import { Matterbridge } from './matterbridge.js';
-/**
- * Adds a virtual device to the provided endpoint, sets up an event listener for device state changes,
- * and ensures the device is initialized in the off state.
- *
- * @param {Endpoint<AggregatorEndpoint>} aggregatorEndpoint - The aggragator endpoint to which the virtual device will be added.
- * @param {string} name - The name of the virtual device. Spaces in the name are removed to form the device ID.
- * @param {'light' | 'outlet' | 'switch' | 'mounted_switch'} type - The type of the virtual device. Can be 'light', 'outlet', 'switch', or 'mounted_switch'.
- * @param {() => Promise<void>} callback - A callback function that gets executed when the device's on/off state changes to true.
- * @returns {Promise<Endpoint>} A promise that resolves with the created virtual device.
- * @remarks The virtual device is created as an instance of `Endpoint` with the `OnOffPlugInUnitDevice` device type.
- * The onOff state always reverts to false when the device is turned on.
- */
 export declare function addVirtualDevice(aggregatorEndpoint: Endpoint<AggregatorEndpoint>, name: string, type: 'light' | 'outlet' | 'switch' | 'mounted_switch', callback: () => Promise<void>): Promise<Endpoint>;
-/**
- * Creates and add the virtual devices to the aggregator.
- *
- * @param {Matterbridge} matterbridge - The Matterbridge instance.
- * @param {Endpoint<AggregatorEndpoint>} aggregatorEndpoint - The aggregator node to add the virtual devices to.
- * @returns {Promise<void>} A promise that resolves when the virtual devices are added.
- */
 export declare function addVirtualDevices(matterbridge: Matterbridge, aggregatorEndpoint: Endpoint<AggregatorEndpoint>): Promise<void>;
-//# sourceMappingURL=helpers.d.ts.map

package/dist/helpers.js

@@ -1,27 +1,3 @@
-/**
- * This file contains the helpers functions of Matterbridge.
- *
- * @file helpers.ts
- * @author Luca Liguori
- * @created 2025-05-12
- * @version 1.0.0
- * @license Apache-2.0
- *
- * Copyright 2025, 2026, 2027 Luca Liguori.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-// @matter module
 import { OnOff } from '@matter/types/clusters/on-off';
 import { Endpoint } from '@matter/node';
 import { BridgedDeviceBasicInformationServer } from '@matter/node/behaviors/bridged-device-basic-information';
@@ -32,24 +8,8 @@ import { MountedOnOffControlDevice } from '@matter/node/devices/mounted-on-off-c
 import { OnOffLightDevice } from '@matter/node/devices/on-off-light';
 import { OnOffLightSwitchDevice } from '@matter/node/devices/on-off-light-switch';
 import { VendorId } from '@matter/types/datatype';
-// Matterbridge
 import { hasParameter } from '@matterbridge/utils';
-/**
- * Adds a virtual device to the provided endpoint, sets up an event listener for device state changes,
- * and ensures the device is initialized in the off state.
- *
- * @param {Endpoint<AggregatorEndpoint>} aggregatorEndpoint - The aggragator endpoint to which the virtual device will be added.
- * @param {string} name - The name of the virtual device. Spaces in the name are removed to form the device ID.
- * @param {'light' | 'outlet' | 'switch' | 'mounted_switch'} type - The type of the virtual device. Can be 'light', 'outlet', 'switch', or 'mounted_switch'.
- * @param {() => Promise<void>} callback - A callback function that gets executed when the device's on/off state changes to true.
- * @returns {Promise<Endpoint>} A promise that resolves with the created virtual device.
- * @remarks The virtual device is created as an instance of `Endpoint` with the `OnOffPlugInUnitDevice` device type.
- * The onOff state always reverts to false when the device is turned on.
- */
 export async function addVirtualDevice(aggregatorEndpoint, name, type, callback) {
-    // Create a new virtual device by instantiating `Endpoint` with device information.
-    // The device ID is created by replacing all spaces in the name with an empty string.
-    // The node label of the bridged device basic information is set to the given name.
     let deviceType;
     switch (type) {
         case 'light':
@@ -70,9 +30,7 @@ export async function addVirtualDevice(aggregatorEndpoint, name, type, callback)
         bridgedDeviceBasicInformation: { vendorId: VendorId(0xfff1), vendorName: 'Matterbridge', productName: 'Matterbridge Virtual Device', nodeLabel: name.slice(0, 32) },
         onOff: { onOff: false, startUpOnOff: OnOff.StartUpOnOff.Off },
     });
-    // Set up an event listener for when the `onOff` state changes.
     device.events.onOff.onOff$Changed.on((value) => {
-        // If the `onOff` state becomes true, turn off the virtual device and execute the callback.
         if (value) {
             callback();
             process.nextTick(async () => {
@@ -80,14 +38,11 @@ export async function addVirtualDevice(aggregatorEndpoint, name, type, callback)
                     await device.setStateOf(OnOffBaseServer, { onOff: false });
                 }
                 catch (_error) {
-                    // Not necessary to handle the error
                 }
             });
         }
     });
-    // Add the created device to the given endpoint.
     await aggregatorEndpoint.add(device);
-    // Add the OnOffPlugInUnit to MountedOnOffControlDevice (Matter 1.4.2).
     await device.construction.ready;
     if (type === 'mounted_switch') {
         await device.act(async (agent) => {
@@ -95,17 +50,9 @@ export async function addVirtualDevice(aggregatorEndpoint, name, type, callback)
             descriptor.addDeviceTypes('OnOffPlugInUnit');
         });
     }
-    // Initially set the state of the virtual device's `OnOffBaseServer` to false (off).
     await device.setStateOf(OnOffBaseServer, { onOff: false });
     return device;
 }
-/**
- * Creates and add the virtual devices to the aggregator.
- *
- * @param {Matterbridge} matterbridge - The Matterbridge instance.
- * @param {Endpoint<AggregatorEndpoint>} aggregatorEndpoint - The aggregator node to add the virtual devices to.
- * @returns {Promise<void>} A promise that resolves when the virtual devices are added.
- */
 export async function addVirtualDevices(matterbridge, aggregatorEndpoint) {
     if (matterbridge.virtualMode !== 'disabled' && matterbridge.bridgeMode === 'bridge' && aggregatorEndpoint) {
         matterbridge.log.notice(`Creating virtual devices for Matterbridge server node...`);
@@ -117,45 +64,12 @@ export async function addVirtualDevices(matterbridge, aggregatorEndpoint) {
         });
         await addVirtualDevice(aggregatorEndpoint, 'Update Matterbridge', matterbridge.virtualMode, async () => {
             if (hasParameter('shelly')) {
-                /*
-                const { getShelly } = await import('./shelly.js');
-                getShelly('/api/updates/sys/perform', 10 * 1000)
-                  .then(() => {
-                    matterbridge.log.notice('Shelly system updated successfully');
-                    return;
-                  })
-                  .catch((error) => {
-                    matterbridge.log.error(`Error updating shelly system: ${error}`);
-                  });
-                getShelly('/api/updates/main/perform', 10 * 1000)
-                  .then(() => {
-                    matterbridge.log.notice('Shelly software updated successfully');
-                    return;
-                  })
-                  .catch((error) => {
-                    matterbridge.log.error(`Error updating shelly software: ${error}`);
-                  });
-                */
             }
             else {
                 await matterbridge.updateProcess();
             }
         });
         if (hasParameter('shelly')) {
-            /*
-            await addVirtualDevice(aggregatorEndpoint, 'Reboot Matterbridge', matterbridge.virtualMode, async () => {
-              const { postShelly } = await import('./shelly.js');
-              postShelly('/api/system/reboot', {}, 60 * 1000)
-                .then(() => {
-                  matterbridge.log.notice('Rebooting shelly board...');
-                  return;
-                })
-                .catch((error) => {
-                  matterbridge.log.error(`Error rebooting shelly board: ${error}`);
-                });
-            });
-            */
         }
     }
 }
-//# sourceMappingURL=helpers.js.map

package/dist/jestutils/export.d.ts

@@ -1,2 +1 @@
 export * from './jestHelpers.js';
-//# sourceMappingURL=export.d.ts.map

package/dist/jestutils/export.js

@@ -1,2 +1 @@
 export * from './jestHelpers.js';
-//# sourceMappingURL=export.js.map

package/dist/jestutils/jestHelpers.d.ts

@@ -1,25 +1,3 @@
-/**
- * @description This file contains the Jest helpers.
- * @file src/jestHelpers.test.ts
- * @author Luca Liguori
- * @created 2025-09-03
- * @version 1.0.15
- * @license Apache-2.0
- *
- * Copyright 2025, 2026, 2027 Luca Liguori.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 import type { jest } from '@jest/globals';
 import { AnsiLogger } from 'node-ansi-logger';
 import { Environment } from '@matter/general';
@@ -88,262 +66,25 @@ export declare let environment: Environment;
 export declare let server: ServerNode<ServerNode.RootEndpoint>;
 export declare let aggregator: Endpoint<AggregatorEndpoint>;
 export declare let log: AnsiLogger;
-/**
- * Setup the Jest environment:
- * - it will remove any existing home directory
- * - setup the spies for logging
- *
- * @param {string} name The name of the test suite.
- * @param {boolean} debug If true, the logging is not mocked.
- *
- * @example
- * ```typescript
- * import { consoleDebugSpy, consoleErrorSpy, consoleInfoSpy, consoleLogSpy, consoleWarnSpy, loggerLogSpy, setDebug, setupTest } from './jestutils/jestHelpers.js';
- *
- * // Setup the test environment
- * await setupTest(NAME, false);
- * ```
- */
 export declare function setupTest(name: string, debug?: boolean): Promise<void>;
-/**
- * Set or unset the debug mode.
- *
- * @param {boolean} debug If true, the logging is not mocked.
- * @returns {Promise<void>} A promise that resolves when the debug mode is set.
- *
- * @example
- * ```typescript
- * // Set the debug mode in test environment
- * await setDebug(true);
- * ```
- *
- * ```typescript
- * // Reset the debug mode in test environment
- * await setDebug(false);
- * ```
- */
 export declare function setDebug(debug: boolean): Promise<void>;
-/**
- * Create and start a fully initialized Matterbridge instance for testing.
- *
- * @param {('bridge' | 'childbridge' | 'controller' | '')} bridgeMode The bridge mode to start the Matterbridge instance in.
- * @param {number} frontendPort The frontend port number.
- * @param {number} matterPort The matter port number.
- * @param {number} passcode The passcode number.
- * @param {number} discriminator The discriminator number.
- * @param {number} pluginSize The expected number of plugins.
- * @param {number} devicesSize The expected number of devices.
- * @returns {Promise<Matterbridge>} The Matterbridge instance.
- *
- * @example
- * ```typescript
- * // Create and start a fully initialized Matterbridge instance for testing.
- * await startMatterbridge();
- * ```
- */
 export declare function startMatterbridge(bridgeMode?: 'bridge' | 'childbridge' | 'controller' | '', frontendPort?: number, matterPort?: number, passcode?: number, discriminator?: number, pluginSize?: number, devicesSize?: number): Promise<Matterbridge>;
-/**
- * Stop the fully initialized Matterbridge instance.
- *
- * @param {cleanupPause} cleanupPause The pause duration before cleanup. Default is 10 ms.
- * @param {destroyPause} destroyPause The pause duration before destruction. Default is 250 ms.
- *
- * @example
- * ```typescript
- * // Stop the fully initialized Matterbridge instance.
- * await stopMatterbridge();
- * ```
- */
 export declare function stopMatterbridge(cleanupPause?: number, destroyPause?: number): Promise<void>;
-/**
- * Create a Matterbridge instance for testing without initializing it.
- *
- * @param {string} name - Name for the environment (jest/name).
- * @returns {Promise<Matterbridge>} The Matterbridge instance.
- *
- * @example
- * ```typescript
- * // Create Matterbridge environment
- * await createMatterbridgeEnvironment(NAME);
- * await startMatterbridgeEnvironment(MATTER_PORT);
- * ```
- */
 export declare function createMatterbridgeEnvironment(name: string): Promise<Matterbridge>;
-/**
- * Start the matterbridge environment.
- * Only node storage, matter storage and the server and aggregator nodes are started.
- *
- * @param {number} port The matter server port.
- * @returns {Promise<[ServerNode<ServerNode.RootEndpoint>, Endpoint<AggregatorEndpoint>]>} The started server and aggregator.
- *
- * @example
- * ```typescript
- * // Create Matterbridge environment
- * await createMatterbridgeEnvironment(NAME);
- * await startMatterbridgeEnvironment(MATTER_PORT);
- * ```
- */
 export declare function startMatterbridgeEnvironment(port?: number): Promise<[ServerNode<ServerNode.RootEndpoint>, Endpoint<AggregatorEndpoint>]>;
-/**
- * Add a matterbridge platform for testing.
- *
- * @param {MatterbridgePlatform} platform The platform to add.
- * @param {string} [name] Optional name of the platform.
- *
- * @example
- * ```typescript
- * platform = new Platform(matterbridge, log, config);
- * // Add the platform to the Matterbridge environment
- * addMatterbridgePlatform(platform);
- * ```
- */
 export declare function addMatterbridgePlatform(platform: MatterbridgePlatform, name?: string): void;
-/**
- * Stop the matterbridge environment
- *
- * @example
- * ```typescript
- * // Destroy Matterbridge environment
- * await stopMatterbridgeEnvironment();
- * await destroyMatterbridgeEnvironment();
- * ```
- */
 export declare function stopMatterbridgeEnvironment(): Promise<void>;
-/**
- * Destroy the matterbridge environment
- *
- * @param {number} cleanupPause The timeout for the destroy operation (default 10ms).
- * @param {number} destroyPause The pause duration after cleanup before destroying the instance (default 250ms).
- *
- * @example
- * ```typescript
- * // Destroy Matterbridge environment
- * await stopMatterbridgeEnvironment();
- * await destroyMatterbridgeEnvironment();
- * ```
- */
 export declare function destroyMatterbridgeEnvironment(cleanupPause?: number, destroyPause?: number): Promise<void>;
-/**
- * Destroy a matterbridge instance
- *
- * @param {Matterbridge} matterbridge The matterbridge instance to destroy.
- * @param {number} cleanupPause The pause duration to wait for the cleanup to complete in milliseconds (default 10ms).
- * @param {number} destroyPause The pause duration to wait after cleanup before destroying the instance in milliseconds (default 250ms).
- */
 export declare function destroyInstance(matterbridge: Matterbridge, cleanupPause?: number, destroyPause?: number): Promise<void>;
-/**
- * Close the mDNS instance in the matterbridge environment.
- *
- * @param {Matterbridge} matterbridge The matterbridge instance.
- * @returns {Promise<void>} A promise that resolves when the mDNS instance is closed.
- */
 export declare function closeMdnsInstance(matterbridge: Matterbridge): Promise<void>;
-/**
- * Create a matter test environment for testing:
- * - it will remove any existing home directory
- * - setup the matter environment with name, debug logging and ANSI format
- * - setup the mDNS service in the environment
- *
- * @param {string} name - Name for the environment (jest/name).
- * @param {boolean} createOnly - If true, only create the environment without starting the mDNS service (default false).
- * @returns {Environment} - The default matter environment.
- */
 export declare function createTestEnvironment(name: string, createOnly?: boolean): Environment;
-/**
- * Destroy the matter test environment by closing the mDNS service.
- *
- * @param {boolean} createOnly - If true, skip destroying the environment since it was only created without starting the mDNS service (default false).
- * @returns {Promise<void>} A promise that resolves when the test environment is destroyed.
- */
 export declare function destroyTestEnvironment(createOnly?: boolean): Promise<void>;
-/**
- * Advance the Node.js event loop deterministically to allow chained asynchronous work (Promises scheduled in
- * microtasks and follow‑up macrotasks) to complete inside tests without adding arbitrary long timeouts.
- *
- * NOTE: This does not guarantee OS level network IO completion—only JavaScript task queue progression inside the
- *       current process.
- *
- * @param {number} ticks       Number of macrotask (setImmediate) turns to yield (default 3).
- * @param {number} microTurns  Number of microtask drains (Promise.resolve chains) after macrotask yielding (default 10).
- * @param {number} pause       Final timer delay in ms; set 0 to disable (default 250ms).
- * @returns {Promise<void>}        Resolves after the requested event loop advancement has completed.
- */
 export declare function flushAsync(ticks?: number, microTurns?: number, pause?: number): Promise<void>;
-/**
- * Summarize live libuv handles/requests inside a process.
- *
- * @param {AnsiLogger} log - Logger to use for output
- *
- * @returns {number} - The total number of active handles and requests
- */
 export declare function logKeepAlives(log?: AnsiLogger): number;
-/**
- * Flush (await) the lazy endpoint number persistence mechanism used by matter.js.
- *
- * Background:
- *  assignNumber() batches persistence (store.saveNumber + updating __nextNumber__) via an internal promise (#numbersPersisted).
- *  Calling endpointStores.close() waits for the current batch only. If new endpoints were added in the same macrotask
- *  cycle additional micro/macro turns might be needed to ensure the batch started. We defensively yield macrotasks
- *  (setImmediate) and then await close() multiple rounds.
- *
- * @param {ServerNode} targetServer  The server whose endpoint numbering persistence should be flushed.
- * @param {number} rounds Number of macrotask + close cycles to run (2 is usually sufficient; 1 often works).
- * @returns {Promise<void>}          Resolves when pending number persistence batches have completed.
- */
 export declare function flushAllEndpointNumberPersistence(targetServer: ServerNode, rounds?: number): Promise<void>;
-/**
- * Assert that every endpoint attached to the server has an assigned and (batch-)persisted endpoint number.
- *
- * This waits for any outstanding number persistence batch (endpointStores.close()), then traverses the endpoint
- * graph and asserts:
- *  - Root endpoint: number is 0 (allowing undefined to coerce to 0 via nullish coalescing check).
- *  - All other endpoints: number > 0.
- *
- * @param {ServerNode} targetServer The server whose endpoint numbers are verified.
- * @returns {Promise<void>}         Resolves when assertions complete.
- */
 export declare function assertAllEndpointNumbersPersisted(targetServer: ServerNode): Promise<number>;
-/**
- * Close the server node stores to flush any pending endpoint number persistence.
- *
- * @param {ServerNode} targetServer The server whose endpoint stores should be closed.
- * @returns {Promise<void>} Resolves when the stores have been closed.
- */
 export declare function closeServerNodeStores(targetServer?: ServerNode): Promise<void>;
-/**
- * Start a matter server node for testing.
- *
- * @param {string} name Name of the server (used for logging and product description).
- * @param {number} port TCP port to listen on.
- * @param {DeviceTypeId} deviceType Device type identifier for the server node.
- * @param {boolean} createOnly If true, only creates the server and aggregator nodes without starting the server (default false).
- * @returns {Promise<[ServerNode<ServerNode.RootEndpoint>, Endpoint<AggregatorEndpoint>]>} Resolves to an array containing the created ServerNode and its AggregatorNode.
- */
 export declare function startServerNode(name: string, port: number, deviceType?: DeviceTypeId, createOnly?: boolean): Promise<[ServerNode<ServerNode.RootEndpoint>, Endpoint<AggregatorEndpoint>]>;
-/**
- * Stop a matter server node.
- *
- * @param {ServerNode<ServerNode.RootEndpoint>} server The server to stop.
- * @param {boolean} createOnly If true, only creates the server and aggregator nodes without starting the server (default false).
- * @returns {Promise<void>} Resolves when the server has stopped.
- */
 export declare function stopServerNode(server: ServerNode<ServerNode.RootEndpoint>, createOnly?: boolean): Promise<void>;
-/**
- * Add a device (endpoint) to a matter server node or an aggregator.
- *
- * @param {ServerNode<ServerNode.RootEndpoint> | Endpoint<AggregatorEndpoint>} owner The server or aggregator to add the device to.
- * @param {Endpoint} device The device to add.
- * @param {number} pause The pause time in milliseconds after addition (default 10ms).
- * @returns {Promise<void>} Resolves when the device has been added and is ready.
- */
 export declare function addDevice(owner: ServerNode<ServerNode.RootEndpoint> | Endpoint<AggregatorEndpoint>, device: Endpoint, pause?: number): Promise<boolean>;
-/**
- * Delete a device (endpoint) from a matter server node or an aggregator.
- *
- * @param {ServerNode<ServerNode.RootEndpoint> | Endpoint<AggregatorEndpoint>} owner The server or aggregator to remove the device from.
- * @param {Endpoint} device The device to remove.
- * @param {number} pause The pause time in milliseconds after deletion (default 10ms).
- * @returns {Promise<void>} Resolves when the device has been removed and is no longer ready.
- */
 export declare function deleteDevice(owner: ServerNode<ServerNode.RootEndpoint> | Endpoint<AggregatorEndpoint>, device: Endpoint, pause?: number): Promise<boolean>;
-//# sourceMappingURL=jestHelpers.d.ts.map