node-red-contrib-power-saver 5.0.0 → 5.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-power-saver",
-  "version": "5.0.0",
+  "version": "5.1.0",
   "description": "A module for Node-RED that you can use to turn on and off a switch based on power prices",
   "main": "index.js",
   "scripts": {
@@ -47,27 +47,26 @@
     "url": "https://github.com/ottopaulsen/node-red-contrib-power-saver.git"
   },
   "devDependencies": {
-    "@vuepress/bundler-vite": "2.0.0-rc.19",
-    "@vuepress/plugin-google-analytics": "2.0.0-rc.66",
-    "@vuepress/plugin-register-components": "2.0.0-rc.66",
-    "@vuepress/plugin-search": "2.0.0-rc.66",
-    "@vuepress/theme-default": "2.0.0-rc.66",
-    "@vuepress/utils": "2.0.0-rc.19",
-    "chai": "^4.3.10",
-    "eslint": "9.17.0",
-    "expect": "29.7.0",
-    "mocha": "^11.0.1",
-    "node-red": "^4.0.8",
-    "node-red-node-test-helper": "0.3.4",
-    "sass-embedded": "^1.83.1",
-    "sass-loader": "^16.0.4",
-    "vuepress": "2.0.0-rc.19"
+    "@vuepress/bundler-vite": "2.0.0-rc.26",
+    "@vuepress/plugin-google-analytics": "2.0.0-rc.123",
+    "@vuepress/plugin-register-components": "2.0.0-rc.123",
+    "@vuepress/plugin-search": "2.0.0-rc.123",
+    "@vuepress/theme-default": "2.0.0-rc.123",
+    "@vuepress/utils": "2.0.0-rc.26",
+    "chai": "6.2.2",
+    "eslint": "10.0.0",
+    "expect": "30.2.0",
+    "mocha": "^11.7.5",
+    "node-red": "^4.1.5",
+    "node-red-node-test-helper": "0.3.6",
+    "sass-embedded": "^1.97.3",
+    "sass-loader": "^16.0.7",
+    "vuepress": "2.0.0-rc.26"
   },
   "dependencies": {
     "floating-vue": "5.2.2",
     "lodash.clonedeep": "4.5.0",
     "luxon": "3.5.0",
-    "nano-time": "1.0.0",
-    "node-fetch": "2.6.7"
+    "nano-time": "1.0.0"
   }
 }

package/src/elvia/elvia-api.js

@@ -1,4 +1,4 @@
-const fetch = require("node-fetch");
+// const fetch = require("node-fetch");
 
 function ping(node, subscriptionKey, setResultStatus = true) {
   const url = "https://elvia.azure-api.net/grid-tariff/Ping";

package/src/light-saver-functions.js

@@ -1,6 +1,18 @@
 // Business logic functions for light-saver node
 // These functions are exported for testing
 
+/**
+ * Debug logging wrapper - only logs if debugLog is enabled in config
+ * @param {object} config - Configuration object with debugLog boolean
+ * @param {object} node - Node-RED node object for logging
+ * @param {string} message - Message to log
+ */
+function debugLog(config, node, message) {
+  if (config && config.debugLog === true) {
+    node.log(message);
+  }
+}
+
 /**
  * Parse a timestamp string as UTC, handling timezone offsets
  * Home Assistant may return timestamps with or without 'Z' or timezone offsets like +00:00
@@ -124,7 +136,7 @@ function isBrightnessAllowingLights(config) {
 function handleStateChange(event, config, state, node, homeAssistant, clock = null) {
   const now = clock ? clock.now() : new Date();
   
-  node.log("State change event received: " + JSON.stringify(event).substring(0, 200));
+    debugLog(config, node, "State change event received: " + JSON.stringify(event).substring(0, 200));
   
   if (!event || !event.event) return;
   
@@ -136,7 +148,7 @@ function handleStateChange(event, config, state, node, homeAssistant, clock = nu
     return;
   }
   
-  node.log(`Processing state change for ${entityId}: ${newState.state}`);
+    debugLog(config, node, `Processing state change for ${entityId}: ${newState.state}`);
   
   const timestamp = now.toISOString().substring(0, 19); // Format: yyyy-mm-ddTHH:MM:SS
   const timeOnly = now.toISOString().substring(11, 19); // Format: HH:MM:SS
@@ -147,24 +159,25 @@ function handleStateChange(event, config, state, node, homeAssistant, clock = nu
     trigger.lastChanged = timestamp;
     trigger.state = newState.state;
     
-    node.log(`Updated trigger ${entityId}: state=${trigger.state}, lastChanged=${trigger.lastChanged}`);
+    debugLog(config, node, `Updated trigger ${entityId}: state=${trigger.state}, lastChanged=${trigger.lastChanged}`);
     
     // If trigger turned on and timedOut is true, activate lights
     if (newState.state === 'on' && state.timedOut === true) {
-      node.log(`Trigger ${entityId} turned on while timedOut=true, checking brightness and activating lights`);
+    debugLog(config, node, `Trigger ${entityId} turned on while timedOut=true, checking brightness and activating lights`);
       state.timedOut = false; // Reset timedOut after activating lights
       
       // Check brightness limit before turning on lights
       if (isBrightnessAllowingLights(config)) {
         const level = findCurrentLevel(config, node, clock);
         if (level !== null) {
-          controlLights(config.lights, level, node, homeAssistant);
+          controlLights(config, config.lights, level, node, homeAssistant);
         }
       } else {
-        node.log('Brightness limit prevents lights from turning on');
+    debugLog(config, node, 'Brightness limit prevents lights from turning on');
       }
     }
     
+    
     // Update timedOut status: if any trigger is on, timedOut = false
     if (newState.state === 'on') {
       state.timedOut = false;
@@ -184,7 +197,7 @@ function handleStateChange(event, config, state, node, homeAssistant, clock = nu
     config.nightSensor.lastChanged = timestamp;
     config.nightSensor.state = newState.state;
     
-    node.log(`Updated night sensor ${entityId}: state=${config.nightSensor.state}, lastChanged=${config.nightSensor.lastChanged}`);
+    debugLog(config, node, `Updated night sensor ${entityId}: state=${config.nightSensor.state}, lastChanged=${config.nightSensor.lastChanged}`);
     
     node.status({ 
       fill: "green", 
@@ -206,7 +219,7 @@ function handleStateChange(event, config, state, node, homeAssistant, clock = nu
     config.awaySensor.lastChanged = timestamp;
     config.awaySensor.state = newState.state;
     
-    node.log(`Updated away sensor ${entityId}: state=${config.awaySensor.state}, lastChanged=${config.awaySensor.lastChanged}`);
+    debugLog(config, node, `Updated away sensor ${entityId}: state=${config.awaySensor.state}, lastChanged=${config.awaySensor.lastChanged}`);
     
     node.status({ 
       fill: "green", 
@@ -229,7 +242,7 @@ function handleStateChange(event, config, state, node, homeAssistant, clock = nu
     config.brightnessSensor.lastChanged = timestamp;
     config.brightnessSensor.state = newState.state;
     
-    node.log(`Updated brightness sensor ${entityId}: state=${config.brightnessSensor.state}, lastChanged=${config.brightnessSensor.lastChanged}`);
+    debugLog(config, node, `Updated brightness sensor ${entityId}: state=${config.brightnessSensor.state}, lastChanged=${config.brightnessSensor.lastChanged}`);
     
     node.status({ 
       fill: "green", 
@@ -243,16 +256,16 @@ function handleStateChange(event, config, state, node, homeAssistant, clock = nu
       // Brightness crossed threshold - lights are now allowed
       // If lights are off and there was motion within timeout (timedOut is false), turn lights on
       if (state.timedOut === false) {
-        node.log('Brightness crossed threshold and motion detected within timeout, turning lights on');
+    debugLog(config, node, 'Brightness crossed threshold and motion detected within timeout, turning lights on');
         const level = findCurrentLevel(config, node, clock);
         if (level !== null) {
-          controlLights(config.lights, level, node, homeAssistant);
+          controlLights(config, config.lights, level, node, homeAssistant);
         }
       }
     } else if (wasBrightnessAllowing && !isNowBrightnessAllowing) {
       // Brightness crossed threshold - lights are no longer allowed
       // We don't turn lights off here, let the timeout mechanism handle it
-      node.log('Brightness crossed threshold, lights no longer allowed to turn on (but staying on if already on)');
+    debugLog(config, node, 'Brightness crossed threshold, lights no longer allowed to turn on (but staying on if already on)');
     }
     
     return;
@@ -261,6 +274,43 @@ function handleStateChange(event, config, state, node, homeAssistant, clock = nu
   node.warn(`Received state change for ${entityId} but not found in triggers, nightSensor, awaySensor, or brightnessSensor`);
 }
 
+/**
+ * Find the level config object for the current time
+ * @param {object} config - Configuration object with levels
+ * @param {object} clock - Clock abstraction for getting current time (for testing)
+ * @returns {object|null} The level config object or null if not found
+ */
+function findLevelConfig(config, clock = null) {
+  const now = clock ? clock.now() : new Date();
+  
+  if (!config.levels || config.levels.length === 0) {
+    return null;
+  }
+  
+  const currentTime = now.getHours() * 60 + now.getMinutes();
+  
+  // Sort levels by fromTime
+  const sortedLevels = config.levels.slice().sort((a, b) => {
+    const [aHour, aMin] = a.fromTime.split(':').map(Number);
+    const [bHour, bMin] = b.fromTime.split(':').map(Number);
+    const aMinutes = aHour * 60 + aMin;
+    const bMinutes = bHour * 60 + bMin;
+    return aMinutes - bMinutes;
+  });
+  
+  // Find the latest level that started before current time
+  for (let i = sortedLevels.length - 1; i >= 0; i--) {
+    const [hour, min] = sortedLevels[i].fromTime.split(':').map(Number);
+    const levelTime = hour * 60 + min;
+    
+    if (levelTime <= currentTime) {
+      return sortedLevels[i];
+    }
+  }
+  
+  return null;
+}
+
 /**
  * Find the appropriate light level based on time and night sensor
  * @param {object} config - Configuration object with awaySensor, nightSensor, levels
@@ -275,13 +325,13 @@ function findCurrentLevel(config, node, clock = null) {
   
   // If away sensor is active and awayLevel is set, use that
   if (isAwayMode(config) && config.awaySensor?.level !== null && config.awaySensor?.level !== undefined) {
-    node.log(`Using away level: ${config.awaySensor.level}%`);
+    debugLog(config, node, `Using away level: ${config.awaySensor.level}%`);
     return config.awaySensor.level;
   }
   
   // If night sensor is active and nightLevel is set, use that
   if (isNightMode(config) && config.nightSensor?.level !== null && config.nightSensor?.level !== undefined) {
-    node.log(`Using night level: ${config.nightSensor.level}%`);
+    debugLog(config, node, `Using night level: ${config.nightSensor.level}%`);
     return config.nightSensor.level;
   }
   
@@ -310,7 +360,7 @@ function findCurrentLevel(config, node, clock = null) {
     
     if (levelTime <= currentTime) {
       selectedLevel = sortedLevels[i].level;
-      node.log(`Found level ${selectedLevel}% from ${sortedLevels[i].fromTime}`);
+      debugLog(config, node, `Found level ${selectedLevel}% from ${sortedLevels[i].fromTime}`);
       break;
     }
   }
@@ -318,7 +368,7 @@ function findCurrentLevel(config, node, clock = null) {
   // If no level found (current time is before all levels), use the last level (wraps from previous day)
   if (selectedLevel === null && sortedLevels.length > 0) {
     selectedLevel = sortedLevels[sortedLevels.length - 1].level;
-    node.log(`Using last level ${selectedLevel}% (wrapped from previous day)`);
+    debugLog(config, node, `Using last level ${selectedLevel}% (wrapped from previous day)`);
   }
   
   return selectedLevel;
@@ -326,18 +376,18 @@ function findCurrentLevel(config, node, clock = null) {
 
 /**
  * Control lights by sending commands to Home Assistant
+ * @param {object} config - Configuration object with debugLog flag
  * @param {array} lights - Array of light entities
  * @param {number} level - Level to set (0-100)
  * @param {object} node - Node-RED node object for logging
  * @param {object} homeAssistant - Home Assistant integration object
  */
-function controlLights(lights, level, node, homeAssistant) {
+function controlLights(config, lights, level, node, homeAssistant) {
   if (level === null || level === undefined) {
     node.warn('Cannot control lights: no valid level found');
     return;
   }
-  
-  node.log(`Controlling lights with level: ${level}%`);
+  debugLog(config, node, `Controlling lights with level: ${level}%`);
   
   lights.forEach(light => {
     const entityId = light.entity_id;
@@ -349,7 +399,7 @@ function controlLights(lights, level, node, homeAssistant) {
     if (domain === 'switch') {
       // For switches: turn off if level is 0, on if level > 0
       const service = level === 0 ? 'turn_off' : 'turn_on';
-      node.log(`Calling ${domain}.${service} for ${entityId}`);
+      debugLog(config, node, `Calling ${domain}.${service} for ${entityId}`);
       
       homeAssistant.websocket.send({
         type: 'call_service',
@@ -362,7 +412,7 @@ function controlLights(lights, level, node, homeAssistant) {
     } else if (domain === 'light') {
       // For lights: set brightness percentage
       if (level === 0) {
-        node.log(`Calling ${domain}.turn_off for ${entityId}`);
+        debugLog(config, node, `Calling ${domain}.turn_off for ${entityId}`);
         homeAssistant.websocket.send({
           type: 'call_service',
           domain: domain,
@@ -372,7 +422,7 @@ function controlLights(lights, level, node, homeAssistant) {
           }
         });
       } else {
-        node.log(`Calling ${domain}.turn_on for ${entityId} with brightness ${level}%`);
+        debugLog(config, node, `Calling ${domain}.turn_on for ${entityId} with brightness ${level}%`);
         homeAssistant.websocket.send({
           type: 'call_service',
           domain: domain,
@@ -389,12 +439,13 @@ function controlLights(lights, level, node, homeAssistant) {
 
 /**
  * Turn off all lights
+ * @param {object} config - Configuration object with debugLog flag
  * @param {array} lights - Array of light entities
  * @param {object} node - Node-RED node object for logging
  * @param {object} homeAssistant - Home Assistant integration object
  */
-function turnOffAllLights(lights, node, homeAssistant) {
-  node.log('Turning off all lights (timeout reached)');
+function turnOffAllLights(config, lights, node, homeAssistant) {
+    debugLog(config, node, 'Turning off all lights (timeout reached)');
   
   lights.forEach(light => {
     const entityId = light.entity_id;
@@ -403,7 +454,7 @@ function turnOffAllLights(lights, node, homeAssistant) {
     // Store that we're setting level to 0
     light.setLevel = 0;
     
-    node.log(`Calling ${domain}.turn_off for ${entityId}`);
+    debugLog(config, node, `Calling ${domain}.turn_off for ${entityId}`);
     homeAssistant.websocket.send({
       type: 'call_service',
       domain: domain,
@@ -430,12 +481,12 @@ function checkTimeouts(config, state, node, homeAssistant, clock = null) {
   const anyOn = config.triggers.some(t => t.state === 'on');
   
   if (anyOn) {
-    node.log('At least one trigger is on, no timeout check needed');
+    debugLog(config, node, 'At least one trigger is on, no timeout check needed');
     return;
   }
   
   // All triggers are off, check if they've been off long enough
-  node.log('All triggers are off, checking timeouts...');
+    debugLog(config, node, 'All triggers are off, checking timeouts...');
   
   let allTimedOut = true;
   
@@ -445,7 +496,7 @@ function checkTimeouts(config, state, node, homeAssistant, clock = null) {
     
     // If trigger has no state or lastChanged, we can't check timeout
     if (!trigger.state || !trigger.lastChanged) {
-      node.log(`Trigger ${trigger.entity_id} has no state/lastChanged, skipping`);
+    debugLog(config, node, `Trigger ${trigger.entity_id} has no state/lastChanged, skipping`);
       allTimedOut = false;
       continue;
     }
@@ -460,20 +511,37 @@ function checkTimeouts(config, state, node, homeAssistant, clock = null) {
     const lastChangedTime = parseUTCTimestamp(trigger.lastChanged);
     const minutesOff = (now - lastChangedTime) / 1000 / 60;
     
-    node.log(`Trigger ${trigger.entity_id}: off for ${minutesOff.toFixed(1)} minutes, timeout is ${timeoutMinutes} minutes`);
+    debugLog(config, node, `Trigger ${trigger.entity_id}: off for ${minutesOff.toFixed(1)} minutes, timeout is ${timeoutMinutes} minutes`);
     
     if (minutesOff < timeoutMinutes) {
       allTimedOut = false;
-      node.log(`Trigger ${trigger.entity_id} has not timed out yet`);
+    debugLog(config, node, `Trigger ${trigger.entity_id} has not timed out yet`);
     }
   }
   
   if (allTimedOut && config.triggers.length > 0) {
-    node.log('All triggers have timed out, turning off lights');
-    turnOffAllLights(config.lights, node, homeAssistant);
+    debugLog(config, node, 'All triggers have timed out, turning off lights');
+    turnOffAllLights(config, config.lights, node, homeAssistant);
     state.timedOut = true;
     node.status({ fill: "yellow", shape: "ring", text: "Timed out - lights off" });
   }
+  
+  // Check for immediate levels when motion is detected (timedOut = false)
+  if (!state.timedOut && !allTimedOut) {
+    const levelConfig = findLevelConfig(config, clock);
+    // Only apply immediate level if this is a NEW immediate period (fromTime changed)
+    if (levelConfig && levelConfig.immediate === true && levelConfig.fromTime !== state.lastImmediateTime && isBrightnessAllowingLights(config)) {
+      const currentLevel = findCurrentLevel(config, node, clock);
+      if (currentLevel !== null) {
+    debugLog(config, node, `Immediate level ${currentLevel}% found for time ${levelConfig.fromTime}, applying...`);
+        controlLights(config, config.lights, currentLevel, node, homeAssistant);
+        state.lastImmediateTime = levelConfig.fromTime; // Mark this immediate period as applied
+      }
+    }
+  } else if (state.timedOut) {
+    // Reset lastImmediateTime when timeout occurs (next immediate period will apply)
+    state.lastImmediateTime = null;
+  }
 }
 
 /**
@@ -511,19 +579,19 @@ function fetchMissingStates(config, state, node, homeAssistant, clock = null) {
   }
   
   if (entitiesToFetch.length === 0) {
-    node.log('All entities already have states');
+    debugLog(config, node, 'All entities already have states');
   } else {
-    node.log(`Fetching states for ${entitiesToFetch.length} entities: ${entitiesToFetch.map(e => e.id).join(', ')}`);
+    debugLog(config, node, `Fetching states for ${entitiesToFetch.length} entities: ${entitiesToFetch.map(e => e.id).join(', ')}`);
     
     try {
       // Access states from the websocket - it's stored as a flat object
       const states = homeAssistant.websocket.states;
-      node.log(`States object type: ${typeof states}, keys count: ${states ? Object.keys(states).length : 0}`);
+    debugLog(config, node, `States object type: ${typeof states}, keys count: ${states ? Object.keys(states).length : 0}`);
       
       if (states && typeof states === 'object') {
         entitiesToFetch.forEach(entity => {
           const stateObj = states[entity.id];
-          node.log(`Looking for ${entity.id}, found: ${stateObj ? 'yes' : 'no'}`);
+    debugLog(config, node, `Looking for ${entity.id}, found: ${stateObj ? 'yes' : 'no'}`);
           
           if (stateObj) {
             if (entity.type === 'trigger') {
@@ -531,20 +599,20 @@ function fetchMissingStates(config, state, node, homeAssistant, clock = null) {
               if (trigger) {
                 trigger.state = stateObj.state;
                 trigger.lastChanged = stateObj.last_changed || stateObj.last_updated;
-                node.log(`Fetched state for trigger ${entity.id}: ${stateObj.state}`);
+    debugLog(config, node, `Fetched state for trigger ${entity.id}: ${stateObj.state}`);
               }
             } else if (entity.type === 'nightSensor') {
               config.nightSensor.state = stateObj.state;
               config.nightSensor.lastChanged = stateObj.last_changed || stateObj.last_updated;
-              node.log(`Fetched state for night sensor ${entity.id}: ${stateObj.state}`);
+    debugLog(config, node, `Fetched state for night sensor ${entity.id}: ${stateObj.state}`);
             } else if (entity.type === 'awaySensor') {
               config.awaySensor.state = stateObj.state;
               config.awaySensor.lastChanged = stateObj.last_changed || stateObj.last_updated;
-              node.log(`Fetched state for away sensor ${entity.id}: ${stateObj.state}`);
+    debugLog(config, node, `Fetched state for away sensor ${entity.id}: ${stateObj.state}`);
             } else if (entity.type === 'brightnessSensor') {
               config.brightnessSensor.state = stateObj.state;
               config.brightnessSensor.lastChanged = stateObj.last_changed || stateObj.last_updated;
-              node.log(`Fetched state for brightness sensor ${entity.id}: ${stateObj.state}`);
+    debugLog(config, node, `Fetched state for brightness sensor ${entity.id}: ${stateObj.state}`);
             }
           } else {
             node.warn(`State not found for ${entity.id}`);
@@ -569,7 +637,7 @@ function fetchMissingStates(config, state, node, homeAssistant, clock = null) {
       // If any trigger is ON, not timed out
       if (trigger.state === 'on') {
         allTimedOut = false;
-        node.log(`Trigger ${trigger.entity_id} is ON, not timed out`);
+    debugLog(config, node, `Trigger ${trigger.entity_id} is ON, not timed out`);
         break;
       }
       
@@ -581,21 +649,32 @@ function fetchMissingStates(config, state, node, homeAssistant, clock = null) {
         
         if (minutesOff < timeoutMinutes) {
           allTimedOut = false;
-          node.log(`Trigger ${trigger.entity_id} off for ${minutesOff.toFixed(1)} min, timeout is ${timeoutMinutes} min - NOT timed out yet`);
+    debugLog(config, node, `Trigger ${trigger.entity_id} off for ${minutesOff.toFixed(1)} min, timeout is ${timeoutMinutes} min - NOT timed out yet`);
           break;
         } else {
-          node.log(`Trigger ${trigger.entity_id} off for ${minutesOff.toFixed(1)} min, timeout is ${timeoutMinutes} min - timed out`);
+    debugLog(config, node, `Trigger ${trigger.entity_id} off for ${minutesOff.toFixed(1)} min, timeout is ${timeoutMinutes} min - timed out`);
         }
       } else if (!trigger.state) {
         // No state info, can't determine timeout - assume not timed out to be safe
         allTimedOut = false;
-        node.log(`Trigger ${trigger.entity_id} has no state, assuming not timed out`);
+    debugLog(config, node, `Trigger ${trigger.entity_id} has no state, assuming not timed out`);
         break;
       }
     }
     
     state.timedOut = allTimedOut;
-    node.log(`Initial timedOut set to ${state.timedOut} (all triggers actually timed out: ${allTimedOut})`);
+    debugLog(config, node, `Initial timedOut set to ${state.timedOut} (all triggers actually timed out: ${allTimedOut})`);
+    
+    // If motion is detected at startup (timedOut is false), turn lights on
+    if (!allTimedOut) {
+    debugLog(config, node, 'Motion detected at startup, turning lights on');
+      const level = findCurrentLevel(config, node, clock);
+      if (level !== null && isBrightnessAllowingLights(config)) {
+        controlLights(config, config.lights, level, node, homeAssistant);
+    debugLog(config, node, `Lights turned on to ${level}% at startup (motion detected)`);
+      }
+    }
+    
     return true; // Indicates that initial timedOut was set
   }
   
@@ -611,6 +690,7 @@ module.exports = {
   isBrightnessAllowingLights,
   handleStateChange,
   findCurrentLevel,
+  findLevelConfig,
   controlLights,
   turnOffAllLights,
   checkTimeouts,

package/src/light-saver.html

@@ -19,7 +19,7 @@
       brightnessSensor: { value: null },
       brightnessLimit: { value: null },
       brightnessMode: { value: 'max' },
-      levels: { value: [{ fromTime: "00:00", level: 100 }] },
+      levels: { value: [{ fromTime: "00:00", level: 100, immediate: false }] },
       override: { value: 'auto' },
       contextStorage: { value: "default", required: false },
       debugLog: { value: false }
@@ -502,11 +502,11 @@
         // Add existing levels
         if (node.levels && node.levels.length > 0) {
           node.levels.forEach(level => {
-            addLevelRow($list, level.fromTime || '', level.level !== undefined ? level.level : '');
+            addLevelRow($list, level.fromTime || '', level.level !== undefined ? level.level : '', level.immediate === true);
           });
         } else {
           // Add one default row
-          addLevelRow($list, '00:00', 100);
+          addLevelRow($list, '00:00', 100, false);
         }
         
         // Add button handler
@@ -756,7 +756,7 @@
         $container.append(sensorRow);
       };
       
-      const addLevelRow = function($list, fromTime, level) {
+      const addLevelRow = function($list, fromTime, level, immediate) {
         const row = $('<li/>').css({
           padding: '5px',
           border: '1px solid #ccc',
@@ -876,6 +876,32 @@
         
         levelWrapper.append(levelLabel).append(levelSlider).append(levelInput).append(levelUnit);
         
+        // Immediate checkbox
+        const immediateWrapper = $('<div/>').css({
+          display: 'flex',
+          alignItems: 'center',
+          gap: '5px',
+          width: '70px'
+        });
+        
+        const immediateCheckbox = $('<input type="checkbox" class="immediate-checkbox keeper-ignore"/>').css({
+          width: '16px',
+          height: '16px'
+        });
+        
+        // Set checkbox state if immediate was passed
+        if (immediate === true) {
+          immediateCheckbox.prop('checked', true);
+        }
+        
+        const immediateLabel = $('<label/>').text('Immediate').css({
+          fontSize: '11px',
+          whiteSpace: 'nowrap',
+          marginTop: '2px'
+        });
+        
+        immediateWrapper.append(immediateCheckbox).append(immediateLabel);
+        
         const deleteButton = $('<button type="button" class="editor-button editor-button-small" title="Delete Level"><i class="fa fa-trash"></i></button>');
         
         deleteButton.on('click', function(e) {
@@ -888,7 +914,7 @@
           }
         });
         
-        row.append(fromTimeWrapper).append(levelWrapper).append(deleteButton);
+        row.append(fromTimeWrapper).append(levelWrapper).append(immediateWrapper).append(deleteButton);
         $list.append(row);
       };
       
@@ -1094,10 +1120,12 @@
       $("#levels-list li").each(function() {
         const fromTime = $(this).find('.from-time-input').val().trim();
         const level = $(this).find('.level-input').val();
+        const immediate = $(this).find('.immediate-checkbox').prop('checked') === true;
         if (fromTime && level !== '') {
           levels.push({ 
             fromTime: fromTime,
-            level: parseInt(level)
+            level: parseInt(level),
+            immediate: immediate
           });
         }
       });
@@ -1262,6 +1290,7 @@
   - **Light levels**: Time-based brightness levels throughout the day
     - **From time**: Time when this level becomes active (HH:MM format, 24-hour)
     - **Level**: Brightness percentage (0-100%)
+    - **Immediate**: When checked, this level is applied immediately when the time is reached (if motion was detected within the timeout period). When unchecked (default), level is only applied when motion is detected.
   - **Override**: Manual control to override automatic behavior
     - **Off**: Turn all lights off and block automatic control
     - **On**: Set lights to their normal automatic level
@@ -1281,6 +1310,7 @@
   - When away sensor activates, lights are set to away level after configured delay
   - When night sensor activates, lights are set to night level after configured delay
   - Both night and away sensors can be inverted to reverse their logic
+  - **Immediate levels**: If a time-based level has "Immediate" checked and the scheduled time is reached while motion was detected within the timeout, that level is applied immediately without waiting for new motion
   - Override mode blocks all automatic behavior until returned to auto
   - If brightness limit is configured, lights only turn on when brightness passes the threshold
   - When brightness crosses threshold (lights allowed to be on) and motion was detected within timeout, lights turn on automatically

package/src/light-saver.js

@@ -103,7 +103,8 @@ module.exports = function (RED) {
     
     // Mutable state
     const state = {
-      timedOut: undefined // Tracks if all triggers are currently off
+      timedOut: undefined, // Tracks if all triggers are currently off
+      lastImmediateTime: null // Tracks the last fromTime when immediate level was applied
     };
     
     let timeoutCheckInterval = null; // Timer for checking timeouts every minute
@@ -188,7 +189,7 @@ module.exports = function (RED) {
           debugLog('Applying night level to lights');
           const level = funcs.findCurrentLevel(nodeConfig, nodeWrapper);
           if (level !== null) {
-            funcs.controlLights(nodeConfig.lights, level, nodeWrapper, homeAssistant);
+            funcs.controlLights(nodeConfig, nodeConfig.lights, level, nodeWrapper, homeAssistant);
             node.status({ fill: "blue", shape: "dot", text: `Night mode: ${level}%` });
           } else {
             node.warn('Could not determine level for night mode');
@@ -209,7 +210,7 @@ module.exports = function (RED) {
         awayActivationTimer = setTimeout(() => {
           debugLog('Applying away level to lights');
           const level = nodeConfig.awaySensor.level !== null && nodeConfig.awaySensor.level !== undefined ? nodeConfig.awaySensor.level : 0;
-          funcs.controlLights(nodeConfig.lights, level, nodeWrapper, homeAssistant);
+          funcs.controlLights(nodeConfig, nodeConfig.lights, level, nodeWrapper, homeAssistant);
           node.status({ fill: "yellow", shape: "dot", text: `Away mode: ${level}%` });
         }, nodeConfig.awaySensor.delay * 1000);
       }
@@ -396,24 +397,24 @@ module.exports = function (RED) {
         // Apply override actions immediately after config is sent
         if (payload.config.override !== undefined) {
           if (nodeConfig.override === 'off') {
-            funcs.turnOffAllLights(nodeConfig.lights, nodeWrapper, homeAssistant);
+            funcs.turnOffAllLights(nodeConfig, nodeConfig.lights, nodeWrapper, homeAssistant);
             node.status({ fill: "red", shape: "dot", text: "Override: OFF" });
             debugLog('Override: OFF - lights turned off');
           } else if (nodeConfig.override === 'on') {
             // Set lights to the appropriate automatic level and keep them there
             const level = funcs.findCurrentLevel(nodeConfig, nodeWrapper);
             if (level !== null) {
-              funcs.controlLights(nodeConfig.lights, level, nodeWrapper, homeAssistant);
+              funcs.controlLights(nodeConfig, nodeConfig.lights, level, nodeWrapper, homeAssistant);
               node.status({ fill: "green", shape: "dot", text: `Override: ON (${level}%)` });
               debugLog(`Override: ON - lights set to ${level}% (locked)`);
             } else {
               node.warn('Override ON: Could not determine level, using 100%');
-              funcs.controlLights(nodeConfig.lights, 100, nodeWrapper, homeAssistant);
+              funcs.controlLights(nodeConfig, nodeConfig.lights, 100, nodeWrapper, homeAssistant);
               node.status({ fill: "green", shape: "dot", text: "Override: ON (100%)" });
               debugLog('Override: ON - lights set to 100% (fallback)');
             }
           } else if (typeof nodeConfig.override === 'number' && nodeConfig.override >= 0 && nodeConfig.override <= 100) {
-            funcs.controlLights(nodeConfig.lights, nodeConfig.override, nodeWrapper, homeAssistant);
+            funcs.controlLights(nodeConfig, nodeConfig.lights, nodeConfig.override, nodeWrapper, homeAssistant);
             node.status({ fill: "green", shape: "dot", text: `Override: ${nodeConfig.override}%` });
             debugLog(`Override: ${nodeConfig.override}% - lights set to ${nodeConfig.override}%`);
           } else if (nodeConfig.override === 'auto') {
@@ -425,13 +426,13 @@ module.exports = function (RED) {
               debugLog('Triggers active, setting lights to appropriate level');
               const level = funcs.findCurrentLevel(nodeConfig, nodeWrapper);
               if (level !== null) {
-                funcs.controlLights(nodeConfig.lights, level, nodeWrapper, homeAssistant);
+                funcs.controlLights(nodeConfig, nodeConfig.lights, level, nodeWrapper, homeAssistant);
                 node.status({ fill: "green", shape: "dot", text: `AUTO: ${level}%` });
                 debugLog(`Lights set to ${level}% (auto mode with active triggers)`);
               }
             } else if (state.timedOut === true) {
               debugLog('Triggers timed out, turning lights off');
-              funcs.controlLights(nodeConfig.lights, 0, nodeWrapper, homeAssistant);
+              funcs.controlLights(nodeConfig, nodeConfig.lights, 0, nodeWrapper, homeAssistant);
               node.status({ fill: "yellow", shape: "ring", text: "AUTO: Timed out (off)" });
               debugLog('Lights turned off (auto mode with timed out triggers)');
             }
@@ -447,12 +448,12 @@ module.exports = function (RED) {
         debugLog(`Level input received: ${level}`);
         
         if (level === 'off') {
-          funcs.turnOffAllLights(nodeConfig.lights, nodeWrapper, homeAssistant);
+          funcs.turnOffAllLights(nodeConfig, nodeConfig.lights, nodeWrapper, homeAssistant);
           debugLog('Level: OFF - lights turned off');
         } else if (level === 'on') {
           const currentLevel = funcs.findCurrentLevel(nodeConfig, nodeWrapper);
           if (currentLevel !== null) {
-            funcs.controlLights(nodeConfig.lights, currentLevel, nodeWrapper, homeAssistant);
+            funcs.controlLights(nodeConfig, nodeConfig.lights, currentLevel, nodeWrapper, homeAssistant);
             debugLog(`Level: ON - lights set to ${currentLevel}%`);
           } else {
             node.warn('Level: ON - could not determine level');
@@ -462,15 +463,15 @@ module.exports = function (RED) {
           if (state.timedOut === false) {
             const currentLevel = funcs.findCurrentLevel(nodeConfig, nodeWrapper);
             if (currentLevel !== null) {
-              funcs.controlLights(nodeConfig.lights, currentLevel, nodeWrapper, homeAssistant);
+              funcs.controlLights(nodeConfig, nodeConfig.lights, currentLevel, nodeWrapper, homeAssistant);
               debugLog(`Level: AUTO - lights set to ${currentLevel}% (triggers active)`);
             }
           } else {
-            funcs.turnOffAllLights(nodeConfig.lights, nodeWrapper, homeAssistant);
+            funcs.turnOffAllLights(nodeConfig, nodeConfig.lights, nodeWrapper, homeAssistant);
             debugLog('Level: AUTO - lights turned off (timed out)');
           }
         } else if (typeof level === 'number' && level >= 0 && level <= 100) {
-          funcs.controlLights(nodeConfig.lights, level, nodeWrapper, homeAssistant);
+          funcs.controlLights(nodeConfig, nodeConfig.lights, level, nodeWrapper, homeAssistant);
           debugLog(`Level: ${level}% - lights set to ${level}%`);
         } else {
           node.warn(`Invalid level value: ${level}`);
@@ -606,24 +607,24 @@ module.exports = function (RED) {
           if (nodeConfig.override !== 'auto') {
             debugLog(`Applying override from config: ${nodeConfig.override}`);
             if (nodeConfig.override === 'off') {
-              funcs.turnOffAllLights(nodeConfig.lights, nodeWrapper, homeAssistant);
+              funcs.turnOffAllLights(nodeConfig, nodeConfig.lights, nodeWrapper, homeAssistant);
               node.status({ fill: "red", shape: "dot", text: "Override: OFF" });
               debugLog('Override: OFF applied on startup');
             } else if (nodeConfig.override === 'on') {
               // Set lights to the appropriate automatic level and keep them there
               const level = funcs.findCurrentLevel(nodeConfig, nodeWrapper);
               if (level !== null) {
-                funcs.controlLights(nodeConfig.lights, level, nodeWrapper, homeAssistant);
+                funcs.controlLights(nodeConfig, nodeConfig.lights, level, nodeWrapper, homeAssistant);
                 node.status({ fill: "green", shape: "dot", text: `Override: ON (${level}%)` });
                 debugLog(`Override: ON applied on startup - ${level}% (locked)`);
               } else {
                 node.warn('Override ON on startup: Could not determine level, using 100%');
-                funcs.controlLights(nodeConfig.lights, 100, nodeWrapper, homeAssistant);
+                funcs.controlLights(nodeConfig, nodeConfig.lights, 100, nodeWrapper, homeAssistant);
                 node.status({ fill: "green", shape: "dot", text: "Override: ON (100%)" });
                 debugLog('Override: ON applied on startup - 100% (fallback)');
               }
             } else if (typeof nodeConfig.override === 'number') {
-              funcs.controlLights(nodeConfig.lights, nodeConfig.override, nodeWrapper, homeAssistant);
+              funcs.controlLights(nodeConfig, nodeConfig.lights, nodeConfig.override, nodeWrapper, homeAssistant);
               node.status({ fill: "green", shape: "dot", text: `Override: ${nodeConfig.override}%` });
               debugLog(`Override: ${nodeConfig.override}% applied on startup`);
             }