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

package/dist/jestutils/jestMatterbridgeTest.js

@@ -1,252 +0,0 @@
-import path from 'node:path';
-import { Environment, RuntimeService } from '@matter/general';
-import { MdnsService } from '@matter/protocol';
-import { MATTER_STORAGE_DIR, NODE_STORAGE_DIR } from '@matterbridge/types';
-import { rs, UNDERLINE, UNDERLINEOFF } from 'node-ansi-logger';
-import { NodeStorageManager } from 'node-persist-manager';
-import { Matterbridge } from '../matterbridge.js';
-import { flushAsync } from './flushAsync.js';
-import { assertAllEndpointNumbersPersisted, createTestEnvironment, flushAllEndpointNumberPersistence } from './jestMatterTest.js';
-import { HOMEDIR, loggerLogSpy, originalProcessArgv } from './jestSetupTest.js';
-let server;
-let aggregator;
-export let matterbridge;
-export let frontend;
-export let plugins;
-export let devices;
-export async function startMatterbridge(bridgeMode = 'bridge', frontendPort = 8283, matterPort = 5540, passcode = 20252026, discriminator = 3840, pluginSize = 0, devicesSize = 0) {
-    process.env['MATTERBRIDGE_START_MATTER_INTERVAL_MS'] = '100';
-    process.env['MATTERBRIDGE_PAUSE_MATTER_INTERVAL_MS'] = '100';
-    process.argv.length = 0;
-    process.argv.push(...originalProcessArgv, '--novirtual', '--debug', '--verbose', '--logger', 'debug', '--matterlogger', 'debug', bridgeMode === '' ? '--test' : '--' + bridgeMode, '--homedir', HOMEDIR, '--frontend', frontendPort.toString(), '--port', matterPort.toString(), '--passcode', passcode.toString(), '--discriminator', discriminator.toString());
-    expect(Matterbridge.instance).toBeUndefined();
-    matterbridge = await Matterbridge.loadInstance(true);
-    expect(matterbridge.environment).toBeDefined();
-    expect(matterbridge.systemCheckTimeout).toBeDefined();
-    expect(matterbridge.checkUpdateTimeout).toBeDefined();
-    expect(matterbridge.checkUpdateInterval).toBeDefined();
-    clearTimeout(matterbridge.systemCheckTimeout);
-    clearTimeout(matterbridge.checkUpdateTimeout);
-    clearInterval(matterbridge.checkUpdateInterval);
-    expect(matterbridge).toBeDefined();
-    expect(matterbridge.profile).toBeUndefined();
-    expect(matterbridge.bridgeMode).toBe(bridgeMode);
-    frontend = matterbridge.frontend;
-    plugins = matterbridge.plugins;
-    devices = matterbridge.devices;
-    expect(matterbridge.initialized).toBeTruthy();
-    expect(matterbridge.log).toBeDefined();
-    expect(matterbridge.rootDirectory).toBe(path.resolve('./'));
-    expect(matterbridge.homeDirectory).toBe(path.join(HOMEDIR));
-    expect(matterbridge.matterbridgeDirectory).toBe(path.join(HOMEDIR, '.matterbridge'));
-    expect(matterbridge.matterbridgePluginDirectory).toBe(path.join(HOMEDIR, 'Matterbridge'));
-    expect(matterbridge.matterbridgeCertDirectory).toBe(path.join(HOMEDIR, '.mattercert'));
-    expect(plugins).toBeDefined();
-    expect(plugins.size).toBe(pluginSize);
-    expect(devices).toBeDefined();
-    expect(devices.size).toBe(devicesSize);
-    expect(frontend).toBeDefined();
-    expect(frontend.listening).toBeTruthy();
-    expect(frontend.httpServer).toBeDefined();
-    expect(frontend.httpsServer).toBeUndefined();
-    expect(frontend.expressApp).toBeDefined();
-    expect(frontend.webSocketServer).toBeDefined();
-    expect(matterbridge.nodeStorage).toBeDefined();
-    expect(matterbridge.nodeContext).toBeDefined();
-    expect(Environment.default.vars.get('path.root')).toBe(path.join(matterbridge.matterbridgeDirectory, MATTER_STORAGE_DIR));
-    expect(matterbridge.matterStorageService).toBeDefined();
-    expect(matterbridge.matterStorageManager).toBeDefined();
-    expect(matterbridge.matterbridgeContext).toBeDefined();
-    expect(matterbridge.controllerContext).toBeUndefined();
-    if (bridgeMode === 'bridge') {
-        expect(matterbridge.serverNode).toBeDefined();
-        expect(matterbridge.aggregatorNode).toBeDefined();
-    }
-    expect(matterbridge.mdnsInterface).toBe(undefined);
-    expect(matterbridge.port).toBe(matterPort + (bridgeMode === 'bridge' ? 1 : 0));
-    expect(matterbridge.passcode).toBe(passcode + (bridgeMode === 'bridge' ? 1 : 0));
-    expect(matterbridge.discriminator).toBe(discriminator + (bridgeMode === 'bridge' ? 1 : 0));
-    if (bridgeMode === 'bridge') {
-        const started = new Promise((resolve) => {
-            matterbridge.once('bridge_started', () => {
-                resolve();
-            });
-        });
-        const online = new Promise((resolve) => {
-            matterbridge.once('online', (name) => {
-                if (name === 'Matterbridge')
-                    resolve();
-            });
-        });
-        await Promise.all([started, online]);
-    }
-    else if (bridgeMode === 'childbridge') {
-        await new Promise((resolve) => {
-            matterbridge.once('childbridge_started', () => {
-                resolve();
-            });
-        });
-    }
-    expect(loggerLogSpy).toHaveBeenCalledWith("info", `The frontend http server is listening on ${UNDERLINE}http://${matterbridge.systemInformation.ipv4Address}:${frontendPort}${UNDERLINEOFF}${rs}`);
-    if (bridgeMode === 'bridge') {
-        expect(loggerLogSpy).toHaveBeenCalledWith("notice", `Starting Matterbridge server node`);
-        expect(loggerLogSpy).toHaveBeenCalledWith("notice", `Server node for Matterbridge is online`);
-        expect(loggerLogSpy).toHaveBeenCalledWith("debug", `Starting start matter interval in bridge mode...`);
-        expect(loggerLogSpy).toHaveBeenCalledWith("debug", `Cleared startMatterInterval interval in bridge mode`);
-        expect(loggerLogSpy).toHaveBeenCalledWith("notice", `Matterbridge bridge started successfully`);
-    }
-    else if (bridgeMode === 'childbridge') {
-        expect(loggerLogSpy).toHaveBeenCalledWith("debug", `Starting start matter interval in childbridge mode...`);
-        expect(loggerLogSpy).toHaveBeenCalledWith("debug", `Cleared startMatterInterval interval in childbridge mode`);
-        expect(loggerLogSpy).toHaveBeenCalledWith("notice", `Matterbridge childbridge started successfully`);
-    }
-    return matterbridge;
-}
-export async function stopMatterbridge(cleanupPause = 10, destroyPause = 250, closeMdns = false, closeRuntime = false) {
-    await destroyMatterbridgeEnvironment(cleanupPause, destroyPause, closeMdns, closeRuntime);
-}
-export async function createMatterbridgeEnvironment() {
-    matterbridge = await Matterbridge.loadInstance(false);
-    expect(matterbridge).toBeDefined();
-    expect(matterbridge).toBeInstanceOf(Matterbridge);
-    matterbridge.matterbridgeVersion = '3.9.5';
-    matterbridge.bridgeMode = 'bridge';
-    matterbridge.rootDirectory = path.join(HOMEDIR);
-    matterbridge.homeDirectory = path.join(HOMEDIR);
-    matterbridge.matterbridgeDirectory = path.join(HOMEDIR, '.matterbridge');
-    matterbridge.matterbridgePluginDirectory = path.join(HOMEDIR, 'Matterbridge');
-    matterbridge.matterbridgeCertDirectory = path.join(HOMEDIR, '.mattercert');
-    matterbridge.log.logLevel = "debug";
-    frontend = matterbridge.frontend;
-    plugins = matterbridge.plugins;
-    devices = matterbridge.devices;
-    const environment = await createTestEnvironment();
-    expect(environment).toBeDefined();
-    expect(environment).toBeInstanceOf(Environment);
-    matterbridge.environment = environment;
-    return matterbridge;
-}
-export async function startMatterbridgeEnvironment(port = 5540, createOnly = false) {
-    matterbridge.nodeStorage = new NodeStorageManager({
-        dir: path.join(matterbridge.matterbridgeDirectory, NODE_STORAGE_DIR),
-        writeQueue: false,
-        expiredInterval: undefined,
-        logging: false,
-    });
-    matterbridge.nodeContext = await matterbridge.nodeStorage.createStorage('matterbridge');
-    await matterbridge.startMatterStorage();
-    expect(matterbridge.matterStorageService).toBeDefined();
-    expect(matterbridge.matterStorageManager).toBeDefined();
-    expect(matterbridge.matterbridgeContext).toBeDefined();
-    server = await matterbridge.createServerNode(matterbridge.matterbridgeContext, port);
-    expect(server).toBeDefined();
-    expect(server).toBeDefined();
-    expect(server.lifecycle.isReady).toBeTruthy();
-    matterbridge.serverNode = server;
-    aggregator = await matterbridge.createAggregatorNode(matterbridge.matterbridgeContext);
-    expect(aggregator).toBeDefined();
-    matterbridge.aggregatorNode = aggregator;
-    expect(await server.add(aggregator)).toBeDefined();
-    expect(server.parts.has(aggregator.id)).toBeTruthy();
-    expect(server.parts.has(aggregator)).toBeTruthy();
-    expect(aggregator.lifecycle.isReady).toBeTruthy();
-    if (createOnly) {
-        await flushAsync();
-        return [server, aggregator];
-    }
-    expect(server.lifecycle.isOnline).toBeFalsy();
-    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();
-    return [server, aggregator];
-}
-export function addMatterbridgePlatform(platform, name) {
-    expect(platform).toBeDefined();
-    platform.setMatterNode?.(matterbridge.addBridgedEndpoint.bind(matterbridge), matterbridge.removeBridgedEndpoint.bind(matterbridge), matterbridge.removeAllBridgedEndpoints.bind(matterbridge), matterbridge.addVirtualEndpoint.bind(matterbridge));
-    if (name)
-        platform.config.name = name;
-    expect(platform.config.name).toBeDefined();
-    expect(platform.config.type).toBeDefined();
-    expect(platform.type).toBeDefined();
-    expect(platform.config.version).toBeDefined();
-    expect(platform.version).toBeDefined();
-    expect(platform.config.debug).toBeDefined();
-    expect(platform.config.unregisterOnShutdown).toBeDefined();
-    matterbridge.plugins._plugins.set(platform.config.name, {
-        name: platform.config.name,
-        path: './',
-        type: platform.type,
-        version: platform.version,
-        description: 'Plugin ' + platform.config.name,
-        author: 'Unknown',
-        enabled: true,
-        registeredDevices: 0,
-    });
-    platform['name'] = platform.config.name;
-}
-export async function stopMatterbridgeEnvironment(createOnly = false) {
-    expect(matterbridge).toBeDefined();
-    expect(server).toBeDefined();
-    expect(aggregator).toBeDefined();
-    await flushAllEndpointNumberPersistence(server);
-    await assertAllEndpointNumbersPersisted(server);
-    expect(server.lifecycle.isReady).toBeTruthy();
-    if (!createOnly) {
-        expect(server.lifecycle.isOnline).toBeTruthy();
-    }
-    await server.close();
-    expect(server.lifecycle.isReady).toBeFalsy();
-    expect(server.lifecycle.isOnline).toBeFalsy();
-    await matterbridge.stopMatterStorage();
-    expect(matterbridge.matterStorageService).not.toBeDefined();
-    expect(matterbridge.matterStorageManager).not.toBeDefined();
-    expect(matterbridge.matterbridgeContext).not.toBeDefined();
-    await matterbridge.nodeContext?.close();
-    matterbridge.nodeContext = undefined;
-    await matterbridge.nodeStorage?.close();
-    matterbridge.nodeStorage = undefined;
-    await flushAsync();
-}
-export async function destroyMatterbridgeEnvironment(cleanupPause = 10, destroyPause = 100, closeMdns = false, closeRuntime = false) {
-    await destroyInstance(matterbridge, cleanupPause, destroyPause);
-    if (closeMdns) {
-        await closeMdnsInstance(matterbridge);
-    }
-    if (closeRuntime) {
-        await closeRuntimeInstance(matterbridge);
-    }
-    Matterbridge.instance = undefined;
-}
-export async function destroyInstance(matterbridge, cleanupPause = 10, destroyPause = 10) {
-    await matterbridge.cleanup('destroying instance...', false, cleanupPause);
-    if (destroyPause > 0)
-        await flushAsync(undefined, undefined, destroyPause);
-}
-export async function closeMdnsInstance(matterbridge) {
-    const environment = matterbridge.environment;
-    const mdns = environment.maybeGet(MdnsService);
-    if (!mdns)
-        return;
-    await mdns.close();
-    environment.delete(MdnsService, mdns);
-}
-export async function closeRuntimeInstance(matterbridge) {
-    const environment = matterbridge.environment;
-    const runtime = environment.maybeGet(RuntimeService);
-    await runtime?.close();
-}

package/dist/jestutils/jestPluginManagerSpy.d.ts

@@ -1,40 +0,0 @@
-import { PluginManager } from '../pluginManager.js';
-export declare const destroyPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.destroy>;
-export declare const checkDependenciesPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.checkDependencies>;
-export declare const lengthPluginSpy: jest.SpiedGetter<typeof PluginManager.prototype.length>;
-export declare const sizePluginSpy: jest.SpiedGetter<typeof PluginManager.prototype.size>;
-export declare const hasPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.has>;
-export declare const getPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.get>;
-export declare const setPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.set>;
-export declare const clearPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.clear>;
-export declare const arrayPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.array>;
-export declare const storagePluginArraySpy: jest.SpiedFunction<typeof PluginManager.prototype.storagePluginArray>;
-export declare const apiPluginArraySpy: jest.SpiedFunction<typeof PluginManager.prototype.apiPluginArray>;
-export declare const iteratorPluginSpy: jest.SpiedFunction<(typeof PluginManager.prototype)[typeof Symbol.iterator]>;
-export declare const forEachPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.forEach>;
-export declare const logLevelPluginSpy: jest.SpiedSetter<typeof PluginManager.prototype.logLevel>;
-export declare const loadFromStoragePluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.loadFromStorage>;
-export declare const saveToStoragePluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.saveToStorage>;
-export declare const resolvePluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.resolve>;
-export declare const installPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.install>;
-export declare const uninstallPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.uninstall>;
-export declare const getAuthorPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.getAuthor>;
-export declare const getDescriptionPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.getDescription>;
-export declare const getHomepagePluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.getHomepage>;
-export declare const getHelpPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.getHelp>;
-export declare const getChangelogPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.getChangelog>;
-export declare const getFundingPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.getFunding>;
-export declare const parsePluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.parse>;
-export declare const addPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.add>;
-export declare const enablePluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.enable>;
-export declare const disablePluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.disable>;
-export declare const removePluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.remove>;
-export declare const loadPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.load>;
-export declare const startPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.start>;
-export declare const configurePluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.configure>;
-export declare const shutdownPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.shutdown>;
-export declare const loadConfigPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.loadConfig>;
-export declare const saveConfigFromPluginPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.saveConfigFromPlugin>;
-export declare const saveConfigFromJsonPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.saveConfigFromJson>;
-export declare const loadSchemaPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.loadSchema>;
-export declare const getDefaultSchemaPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.getDefaultSchema>;

package/dist/jestutils/jestPluginManagerSpy.js

@@ -1,41 +0,0 @@
-import { PluginManager } from '../pluginManager.js';
-const { jest } = await import('@jest/globals');
-export const destroyPluginSpy = jest.spyOn(PluginManager.prototype, 'destroy');
-export const checkDependenciesPluginSpy = jest.spyOn(PluginManager.prototype, 'checkDependencies');
-export const lengthPluginSpy = jest.spyOn(PluginManager.prototype, 'length', 'get');
-export const sizePluginSpy = jest.spyOn(PluginManager.prototype, 'size', 'get');
-export const hasPluginSpy = jest.spyOn(PluginManager.prototype, 'has');
-export const getPluginSpy = jest.spyOn(PluginManager.prototype, 'get');
-export const setPluginSpy = jest.spyOn(PluginManager.prototype, 'set');
-export const clearPluginSpy = jest.spyOn(PluginManager.prototype, 'clear');
-export const arrayPluginSpy = jest.spyOn(PluginManager.prototype, 'array');
-export const storagePluginArraySpy = jest.spyOn(PluginManager.prototype, 'storagePluginArray');
-export const apiPluginArraySpy = jest.spyOn(PluginManager.prototype, 'apiPluginArray');
-export const iteratorPluginSpy = jest.spyOn(PluginManager.prototype, Symbol.iterator);
-export const forEachPluginSpy = jest.spyOn(PluginManager.prototype, 'forEach');
-export const logLevelPluginSpy = jest.spyOn(PluginManager.prototype, 'logLevel', 'set');
-export const loadFromStoragePluginSpy = jest.spyOn(PluginManager.prototype, 'loadFromStorage');
-export const saveToStoragePluginSpy = jest.spyOn(PluginManager.prototype, 'saveToStorage');
-export const resolvePluginSpy = jest.spyOn(PluginManager.prototype, 'resolve');
-export const installPluginSpy = jest.spyOn(PluginManager.prototype, 'install');
-export const uninstallPluginSpy = jest.spyOn(PluginManager.prototype, 'uninstall');
-export const getAuthorPluginSpy = jest.spyOn(PluginManager.prototype, 'getAuthor');
-export const getDescriptionPluginSpy = jest.spyOn(PluginManager.prototype, 'getDescription');
-export const getHomepagePluginSpy = jest.spyOn(PluginManager.prototype, 'getHomepage');
-export const getHelpPluginSpy = jest.spyOn(PluginManager.prototype, 'getHelp');
-export const getChangelogPluginSpy = jest.spyOn(PluginManager.prototype, 'getChangelog');
-export const getFundingPluginSpy = jest.spyOn(PluginManager.prototype, 'getFunding');
-export const parsePluginSpy = jest.spyOn(PluginManager.prototype, 'parse');
-export const addPluginSpy = jest.spyOn(PluginManager.prototype, 'add');
-export const enablePluginSpy = jest.spyOn(PluginManager.prototype, 'enable');
-export const disablePluginSpy = jest.spyOn(PluginManager.prototype, 'disable');
-export const removePluginSpy = jest.spyOn(PluginManager.prototype, 'remove');
-export const loadPluginSpy = jest.spyOn(PluginManager.prototype, 'load');
-export const startPluginSpy = jest.spyOn(PluginManager.prototype, 'start');
-export const configurePluginSpy = jest.spyOn(PluginManager.prototype, 'configure');
-export const shutdownPluginSpy = jest.spyOn(PluginManager.prototype, 'shutdown');
-export const loadConfigPluginSpy = jest.spyOn(PluginManager.prototype, 'loadConfig');
-export const saveConfigFromPluginPluginSpy = jest.spyOn(PluginManager.prototype, 'saveConfigFromPlugin');
-export const saveConfigFromJsonPluginSpy = jest.spyOn(PluginManager.prototype, 'saveConfigFromJson');
-export const loadSchemaPluginSpy = jest.spyOn(PluginManager.prototype, 'loadSchema');
-export const getDefaultSchemaPluginSpy = jest.spyOn(PluginManager.prototype, 'getDefaultSchema');

package/dist/jestutils/jestSetupTest.d.ts

@@ -1,20 +0,0 @@
-import { AnsiLogger } from 'node-ansi-logger';
-export declare const originalProcessArgv: readonly string[];
-export declare const originalProcessEnv: Readonly<Record<string, string | undefined>>;
-export declare let loggerLogSpy: jest.SpiedFunction<typeof AnsiLogger.prototype.log>;
-export declare let loggerDebugSpy: jest.SpiedFunction<typeof AnsiLogger.prototype.debug>;
-export declare let loggerInfoSpy: jest.SpiedFunction<typeof AnsiLogger.prototype.info>;
-export declare let loggerNoticeSpy: jest.SpiedFunction<typeof AnsiLogger.prototype.notice>;
-export declare let loggerWarnSpy: jest.SpiedFunction<typeof AnsiLogger.prototype.warn>;
-export declare let loggerErrorSpy: jest.SpiedFunction<typeof AnsiLogger.prototype.error>;
-export declare let loggerFatalSpy: jest.SpiedFunction<typeof AnsiLogger.prototype.fatal>;
-export declare let consoleLogSpy: jest.SpiedFunction<typeof console.log>;
-export declare let consoleDebugSpy: jest.SpiedFunction<typeof console.debug>;
-export declare let consoleInfoSpy: jest.SpiedFunction<typeof console.info>;
-export declare let consoleWarnSpy: jest.SpiedFunction<typeof console.warn>;
-export declare let consoleErrorSpy: jest.SpiedFunction<typeof console.error>;
-export declare let NAME: string;
-export declare let HOMEDIR: string;
-export declare let log: AnsiLogger;
-export declare function setupTest(name: string, debug?: boolean): Promise<void>;
-export declare function setDebug(debug: boolean): Promise<void>;

package/dist/jestutils/jestSetupTest.js

@@ -1,79 +0,0 @@
-import { mkdirSync, rmSync } from 'node:fs';
-import path from 'node:path';
-import { AnsiLogger } from 'node-ansi-logger';
-export const originalProcessArgv = Object.freeze([...process.argv]);
-export const originalProcessEnv = Object.freeze({ ...process.env });
-export let loggerLogSpy;
-export let loggerDebugSpy;
-export let loggerInfoSpy;
-export let loggerNoticeSpy;
-export let loggerWarnSpy;
-export let loggerErrorSpy;
-export let loggerFatalSpy;
-export let consoleLogSpy;
-export let consoleDebugSpy;
-export let consoleInfoSpy;
-export let consoleWarnSpy;
-export let consoleErrorSpy;
-const noop = () => undefined;
-export let NAME;
-export let HOMEDIR;
-export let log;
-export async function setupTest(name, debug = false) {
-    expect(name).toBeDefined();
-    expect(typeof name).toBe('string');
-    expect(name.length).toBeGreaterThanOrEqual(4);
-    NAME = name;
-    HOMEDIR = path.join('.cache', 'jest', name);
-    log = new AnsiLogger({ logName: name, logTimestampFormat: 4, logLevel: "debug" });
-    rmSync(HOMEDIR, { recursive: true, force: true });
-    mkdirSync(HOMEDIR, { recursive: true });
-    const { jest } = await import('@jest/globals');
-    loggerDebugSpy = jest.spyOn(AnsiLogger.prototype, 'debug');
-    loggerInfoSpy = jest.spyOn(AnsiLogger.prototype, 'info');
-    loggerNoticeSpy = jest.spyOn(AnsiLogger.prototype, 'notice');
-    loggerWarnSpy = jest.spyOn(AnsiLogger.prototype, 'warn');
-    loggerErrorSpy = jest.spyOn(AnsiLogger.prototype, 'error');
-    loggerFatalSpy = jest.spyOn(AnsiLogger.prototype, 'fatal');
-    if (debug) {
-        loggerLogSpy = jest.spyOn(AnsiLogger.prototype, 'log');
-        consoleLogSpy = jest.spyOn(console, 'log');
-        consoleDebugSpy = jest.spyOn(console, 'debug');
-        consoleInfoSpy = jest.spyOn(console, 'info');
-        consoleWarnSpy = jest.spyOn(console, 'warn');
-        consoleErrorSpy = jest.spyOn(console, 'error');
-    }
-    else {
-        loggerLogSpy = jest.spyOn(AnsiLogger.prototype, 'log').mockImplementation(noop);
-        consoleLogSpy = jest.spyOn(console, 'log').mockImplementation(noop);
-        consoleDebugSpy = jest.spyOn(console, 'debug').mockImplementation(noop);
-        consoleInfoSpy = jest.spyOn(console, 'info').mockImplementation(noop);
-        consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation(noop);
-        consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(noop);
-    }
-}
-export async function setDebug(debug) {
-    const { jest } = await import('@jest/globals');
-    if (debug) {
-        loggerLogSpy.mockRestore();
-        consoleLogSpy.mockRestore();
-        consoleDebugSpy.mockRestore();
-        consoleInfoSpy.mockRestore();
-        consoleWarnSpy.mockRestore();
-        consoleErrorSpy.mockRestore();
-        loggerLogSpy = jest.spyOn(AnsiLogger.prototype, 'log');
-        consoleLogSpy = jest.spyOn(console, 'log');
-        consoleDebugSpy = jest.spyOn(console, 'debug');
-        consoleInfoSpy = jest.spyOn(console, 'info');
-        consoleWarnSpy = jest.spyOn(console, 'warn');
-        consoleErrorSpy = jest.spyOn(console, 'error');
-    }
-    else {
-        loggerLogSpy = jest.spyOn(AnsiLogger.prototype, 'log').mockImplementation(noop);
-        consoleLogSpy = jest.spyOn(console, 'log').mockImplementation(noop);
-        consoleDebugSpy = jest.spyOn(console, 'debug').mockImplementation(noop);
-        consoleInfoSpy = jest.spyOn(console, 'info').mockImplementation(noop);
-        consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation(noop);
-        consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(noop);
-    }
-}

package/dist/jestutils/logKeepAlives.d.ts

@@ -1,2 +0,0 @@
-import { type AnsiLogger } from 'node-ansi-logger';
-export declare function logKeepAlives(log?: AnsiLogger): number;

package/dist/jestutils/logKeepAlives.js

@@ -1,31 +0,0 @@
-import { inspect } from 'node:util';
-import { rs } from 'node-ansi-logger';
-export function logKeepAlives(log) {
-    const handles = process._getActiveHandles?.() ?? [];
-    const requests = process._getActiveRequests?.() ?? [];
-    const fmtHandle = (h, i) => {
-        const ctor = h?.constructor?.name ?? 'Unknown';
-        const hasRef = typeof h?.hasRef === 'function' ? h.hasRef() : undefined;
-        const isPort = h?.constructor?.name?.includes('MessagePort');
-        const fd = h?.fd ?? h?._handle?.fd;
-        return { i, type: ctor, hasRef, isPort, fd };
-    };
-    const fmtReq = (r, i) => {
-        const ctor = r?.constructor?.name ?? 'Unknown';
-        return { i, type: ctor };
-    };
-    const summary = {
-        handles: handles.map(fmtHandle),
-        requests: requests.map(fmtReq),
-    };
-    if (summary.handles.length === 0 && summary.requests.length === 0) {
-        log?.debug('KeepAlive: no active handles or requests.');
-    }
-    else {
-        log?.debug(`KeepAlive:${rs}\n${inspect(summary, { depth: 5, colors: true })}`);
-        if (!log) {
-            process.stdout.write(`KeepAlive:\n${inspect(summary, { depth: 5, colors: true })}\n`);
-        }
-    }
-    return summary.handles.length + summary.requests.length;
-}

package/dist/jestutils/matterRequest.d.ts

@@ -1,10 +0,0 @@
-import { ColorControl } from '@matter/types/clusters/color-control';
-import type { LevelControl } from '@matter/types/clusters/level-control';
-export declare function getMoveToLevelRequest(level: number, transitionTime: number, executeIfOff: boolean): LevelControl.MoveToLevelRequest;
-export declare function getMoveToColorTemperatureRequest(colorTemperatureMireds: number, transitionTime: number, executeIfOff: boolean): ColorControl.MoveToColorTemperatureRequest;
-export declare function getMoveToHueRequest(hue: number, transitionTime: number, executeIfOff: boolean): ColorControl.MoveToHueRequest;
-export declare function getEnhancedMoveToHueRequest(enhancedHue: number, transitionTime: number, executeIfOff: boolean): ColorControl.EnhancedMoveToHueRequest;
-export declare function getMoveToSaturationRequest(saturation: number, transitionTime: number, executeIfOff: boolean): ColorControl.MoveToSaturationRequest;
-export declare function getMoveToHueAndSaturationRequest(hue: number, saturation: number, transitionTime: number, executeIfOff: boolean): ColorControl.MoveToHueAndSaturationRequest;
-export declare function getEnhancedMoveToHueAndSaturationRequest(enhancedHue: number, saturation: number, transitionTime: number, executeIfOff: boolean): ColorControl.EnhancedMoveToHueAndSaturationRequest;
-export declare function getMoveToColorRequest(colorX: number, colorY: number, transitionTime: number, executeIfOff: boolean): ColorControl.MoveToColorRequest;

package/dist/jestutils/matterRequest.js

@@ -1,78 +0,0 @@
-import { ColorControl } from '@matter/types/clusters/color-control';
-export function getMoveToLevelRequest(level, transitionTime, executeIfOff) {
-    const request = {
-        level,
-        transitionTime,
-        optionsMask: { executeIfOff, coupleColorTempToLevel: false },
-        optionsOverride: { executeIfOff, coupleColorTempToLevel: false },
-    };
-    return request;
-}
-export function getMoveToColorTemperatureRequest(colorTemperatureMireds, transitionTime, executeIfOff) {
-    const request = {
-        colorTemperatureMireds,
-        transitionTime,
-        optionsMask: { executeIfOff },
-        optionsOverride: { executeIfOff },
-    };
-    return request;
-}
-export function getMoveToHueRequest(hue, transitionTime, executeIfOff) {
-    const request = {
-        hue,
-        transitionTime,
-        direction: ColorControl.Direction.Shortest,
-        optionsMask: { executeIfOff },
-        optionsOverride: { executeIfOff },
-    };
-    return request;
-}
-export function getEnhancedMoveToHueRequest(enhancedHue, transitionTime, executeIfOff) {
-    const request = {
-        enhancedHue,
-        transitionTime,
-        direction: ColorControl.Direction.Shortest,
-        optionsMask: { executeIfOff },
-        optionsOverride: { executeIfOff },
-    };
-    return request;
-}
-export function getMoveToSaturationRequest(saturation, transitionTime, executeIfOff) {
-    const request = {
-        saturation,
-        transitionTime,
-        optionsMask: { executeIfOff },
-        optionsOverride: { executeIfOff },
-    };
-    return request;
-}
-export function getMoveToHueAndSaturationRequest(hue, saturation, transitionTime, executeIfOff) {
-    const request = {
-        hue,
-        saturation,
-        transitionTime,
-        optionsMask: { executeIfOff },
-        optionsOverride: { executeIfOff },
-    };
-    return request;
-}
-export function getEnhancedMoveToHueAndSaturationRequest(enhancedHue, saturation, transitionTime, executeIfOff) {
-    const request = {
-        enhancedHue,
-        saturation,
-        transitionTime,
-        optionsMask: { executeIfOff },
-        optionsOverride: { executeIfOff },
-    };
-    return request;
-}
-export function getMoveToColorRequest(colorX, colorY, transitionTime, executeIfOff) {
-    const request = {
-        colorX,
-        colorY,
-        transitionTime,
-        optionsMask: { executeIfOff },
-        optionsOverride: { executeIfOff },
-    };
-    return request;
-}