@project-chip/matter.js 0.13.0-alpha.0-20250304-d4a7592a4 → 0.13.0-alpha.0-20250307-ebf84a05a

package/src/cluster/server/LevelControlServer.ts

@@ -1,74 +0,0 @@
-/**
- * @license
- * Copyright 2022-2025 Matter.js Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { LevelControl } from "#clusters";
-import { NamedHandler, NotImplementedError } from "#general";
-import { WrapCommandHandler } from "../../device/Device.js";
-import { ClusterServer } from "./ClusterServer.js";
-import { AttributeInitialValues, ClusterServerHandlers } from "./ClusterServerTypes.js";
-
-export const LevelControlDefaultClusterHandler: () => ClusterServerHandlers<typeof LevelControl.Complete> = () => ({
-    moveToLevel: async ({ request: { level }, attributes: { currentLevel } }) => {
-        currentLevel.setLocal(level);
-    },
-
-    // TODO: How much this capability should be in the library vs. in the caller of the library? Doing the
-    // move/step/stop (withOnOff) in the library would be making assumptions about the capabilities of the
-    // underlying hardware. But how to expose these parameters to the caller of the library? Callback with
-    // temporary options?
-    move: async () => {
-        throw new NotImplementedError("Not implemented");
-    },
-
-    step: async () => {
-        throw new NotImplementedError("Not implemented");
-    },
-
-    stop: async () => {
-        throw new NotImplementedError("Not implemented");
-    },
-
-    moveToLevelWithOnOff: async function ({ request: { level }, attributes: { currentLevel } }) {
-        /* TODO: Need to be able to access or check existence of optional attributes
-        if ( level <= minLevel.get() && associated onOff device on){
-           // turn associated onOff device off
-        } else if associated onOff device off {
-           // turn associated onOff device on
-        }
-        */
-
-        currentLevel.setLocal(level);
-    },
-
-    moveWithOnOff: async () => {
-        throw new NotImplementedError("Not implemented");
-    },
-
-    stepWithOnOff: async () => {
-        throw new NotImplementedError("Not implemented");
-    },
-
-    stopWithOnOff: async () => {
-        throw new NotImplementedError("Not implemented");
-    },
-});
-
-export const createDefaultLevelControlClusterServer = (
-    commandHandler: NamedHandler<any>,
-    attributeInitialValues?: AttributeInitialValues<typeof LevelControl.Cluster.attributes>,
-) =>
-    ClusterServer(
-        LevelControl.Cluster,
-        attributeInitialValues ?? {
-            currentLevel: 0,
-            onLevel: 0,
-            options: {
-                executeIfOff: false,
-                coupleColorTempToLevel: false,
-            },
-        },
-        WrapCommandHandler(LevelControlDefaultClusterHandler(), commandHandler),
-    );

package/src/cluster/server/OnOffServer.ts

@@ -1,146 +0,0 @@
-/**
- * @license
- * Copyright 2022-2025 Matter.js Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { OnOff } from "#clusters";
-import { NamedHandler, NotImplementedError, Time, Timer } from "#general";
-import { AttributeServer } from "#protocol";
-import { WrapCommandHandler } from "../../device/Device.js";
-import { ClusterServer } from "./ClusterServer.js";
-import { AttributeInitialValues, ClusterServerHandlers } from "./ClusterServerTypes.js";
-
-const Cluster = OnOff.Cluster.with("Lighting");
-
-export const OnOffClusterDefaultHandler: () => ClusterServerHandlers<typeof Cluster> = () => {
-    let timedOnTimer: Timer | undefined;
-    let delayedOffTimer: Timer | undefined;
-
-    const getTimedOnTimer = (onTime: AttributeServer<number>, onOff: AttributeServer<boolean>) => {
-        if (timedOnTimer === undefined) {
-            timedOnTimer = Time.getPeriodicTimer("Delayed on", 100, () => {
-                let time = onTime.getLocal() ?? 0 - 0.1;
-                if (time <= 0) {
-                    time = 0;
-                    timedOnTimer?.stop();
-                    onOff.setLocal(false); // Timed on state end by turning off
-                }
-                onTime.setLocal(time);
-            });
-        }
-        return timedOnTimer;
-    };
-
-    const getDelayedOffTimer = (offWaitTime: AttributeServer<number>) => {
-        if (delayedOffTimer === undefined) {
-            delayedOffTimer = Time.getTimer("Delayed off", 100, () => {
-                let time = offWaitTime.getLocal() ?? 0 - 0.1;
-                if (time <= 0) {
-                    time = 0;
-                    delayedOffTimer?.stop(); //Delayed off
-                }
-                offWaitTime.setLocal(time);
-            });
-        }
-        return delayedOffTimer;
-    };
-
-    return {
-        initializeClusterServer: ({ attributes: { onOff, startUpOnOff } }) => {
-            const startUpOnOffValue = startUpOnOff?.getLocal() ?? null;
-            if (startUpOnOffValue !== null) {
-                const currentOnOffStatus = onOff.getLocal();
-                const targetOnOffValue =
-                    startUpOnOffValue === OnOff.StartUpOnOff.Toggle
-                        ? !currentOnOffStatus
-                        : startUpOnOffValue === OnOff.StartUpOnOff.On;
-                if (targetOnOffValue !== currentOnOffStatus) {
-                    onOff.setLocal(targetOnOffValue);
-                }
-            }
-        },
-        destroyClusterServer: () => {
-            timedOnTimer?.stop();
-            delayedOffTimer?.stop();
-        },
-        on: async ({ attributes: { onOff } }) => {
-            onOff.setLocal(true);
-        },
-        off: async ({ attributes: { onOff } }) => {
-            onOff.setLocal(false);
-        },
-        toggle: async ({ attributes: { onOff } }) => {
-            if (onOff.getLocal()) {
-                onOff.setLocal(false);
-            } else {
-                onOff.setLocal(true);
-            }
-        },
-        offWithEffect: async () => {
-            throw new NotImplementedError("Not implemented");
-        },
-        onWithRecallGlobalScene: async () => {
-            throw new NotImplementedError("Not implemented");
-        },
-        onWithTimedOff: async ({
-            request: { onOffControl, onTime: reqOnTime, offWaitTime: reqOffWaitTime },
-            attributes: { onOff, onTime, offWaitTime },
-        }) => {
-            if (onTime === undefined || offWaitTime === undefined) return; // Should never happen that this method is called without these attributes
-
-            const timedOnTimer = getTimedOnTimer(onTime, onOff);
-            const delayedOffTimer = getDelayedOffTimer(offWaitTime);
-            const onOffState = onOff.getLocal();
-
-            if (!onOffState && onOffControl.acceptOnlyWhenOn) {
-                return;
-            }
-
-            if (delayedOffTimer.isRunning && !onOffState) {
-                // we are already in "Delayed off state" - this means reqOffWaitTime attribute > 0 and the device is off now
-                offWaitTime.setLocal(Math.min(reqOffWaitTime ?? 0, offWaitTime.getLocal() ?? 0));
-                delayedOffTimer.start();
-                timedOnTimer.stop();
-            } else {
-                onTime.setLocal(Math.max(reqOnTime ?? 0, onTime.getLocal() ?? 0));
-                offWaitTime.setLocal(reqOffWaitTime);
-                timedOnTimer.start();
-                delayedOffTimer.stop();
-            }
-        },
-    };
-};
-
-export const createDefaultOnOffClusterServer = (
-    commandHandler?: NamedHandler<any>,
-    attributeInitialValues?: AttributeInitialValues<typeof OnOff.Complete.attributes>,
-    isLighting = false,
-) => {
-    if (isLighting) {
-        return ClusterServer(
-            OnOff.Cluster.with(OnOff.Feature.Lighting),
-            {
-                onOff: false,
-                globalSceneControl: false,
-                onTime: 0,
-                offWaitTime: 0,
-                startUpOnOff: null,
-                ...attributeInitialValues,
-            },
-            WrapCommandHandler(OnOffClusterDefaultHandler(), commandHandler),
-        );
-    }
-
-    return ClusterServer(
-        OnOff.Cluster,
-        {
-            onOff: false,
-            ...attributeInitialValues,
-        },
-        WrapCommandHandler(
-            OnOffClusterDefaultHandler(),
-            commandHandler,
-        ) as unknown as ClusterServerHandlers<OnOff.Cluster>,
-    );
-};