node-red-contrib-eskomsepush 0.0.18 → 0.1.1

package/.claude/settings.local.json

@@ -0,0 +1,8 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(npm run *)",
+      "Bash(npx jest *)"
+    ]
+  }
+}

package/README.md

@@ -37,10 +37,10 @@ If you don't want to use API quota by searching, and you already know the id of
 
 To fetch the area id manually, make an `areas_search` API call using your API license key `token`, a word of search `text`.  In the response returned by the API, copy the `id` value of the matching area.
 
-In the example below (on MacOS), `curl` is used to query the API and the search text value is 'ballito' (the license key token is invalid and must be replaced with a valid key).  The area id value that will be used from this example is `eskmo-15-ballitokwadukuzakwazulunatal`:
+In the example below (on MacOS), `curl` is used to query the API and the search text value is 'ballito' (the license key token is invalid and must be replaced with a valid key).
 
 ```
-% curl --location --request GET 'https://developer.sepush.co.za/business/2.0/areas_search?text=ballito' --header 'token: 2DFB82AC-46254F6E-A68B26A4-8DF1303E'
+% curl --location --request GET 'https://developer.sepush.co.za/business/3.0/areas_search?text=ballito' --header 'token: 2DFB82AC-46254F6E-A68B26A4-8DF1303E'
 {
   "areas":[
       {"id":"eskmo-15-ballitokwadukuzakwazulunatal","name":"Ballito (15)","region":"Eskom Municipal, Kwadukuza, Kwazulu-Natal"},
@@ -49,6 +49,8 @@ In the example below (on MacOS), `curl` is used to query the API and the search
 }
 ```
 
+> **Note:** The API returns v2-style IDs with a location suffix. When entering the area id in the node, use only the first two dash-separated parts — e.g. use `eskmo-15`, not `eskmo-15-ballitokwadukuzakwazulunatal`. The node will warn you if it detects an old-style ID.
+
 Then you need to fill out which status to follow. This can be either _National_ (Eskom) or _Cape Town_.
 
 If the _test_ checkbox has been selected, test data for the specified area will be fetched instead of the actual schedule. This is useful when debugging.
@@ -114,7 +116,7 @@ a matching _schedule_.
 
 ### Documentation
 
-Documentation for the API can be found [here](https://documenter.getpostman.com/view/1296288/UzQuNk3E)
+Documentation for the API can be found [here](https://developer.sepush.co.za/business/3.0/)
 
 When quota has been exceeded:
 

package/jest.config.js

@@ -0,0 +1,9 @@
+/** @type {import('jest').Config} */
+module.exports = {
+  testEnvironment: 'node',
+  testMatch: ['**/src/__tests__/**/*.test.ts'],
+  collectCoverageFrom: ['src/lib/**/*.ts'],
+  transform: {
+    '^.+\\.tsx?$': ['ts-jest', { tsconfig: 'tsconfig.test.json' }]
+  }
+}

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "node-red-contrib-eskomsepush",
-  "version": "0.0.18",
+  "version": "0.1.1",
   "description": "Node-RED interface for the Eskomsepush API",
-  "main": "index.js",
   "scripts": {
-    "test": "standard --fix"
+    "build": "tsc && cp src/nodes/eskomsepush.html dist/nodes/ && cp -r src/nodes/icons dist/nodes/",
+    "prepare": "npm run build",
+    "test": "jest",
+    "test:coverage": "jest --coverage",
+    "clean": "rm -rf dist"
   },
   "keywords": [
     "node-red",
@@ -19,7 +22,7 @@
   "license": "MIT",
   "node-red": {
     "nodes": {
-      "eskomsepush": "./src/nodes/eskomsepush.js"
+      "eskomsepush": "./dist/nodes/eskomsepush.js"
     },
     "version": ">=3.0.2"
   },
@@ -28,12 +31,16 @@
     "url": "https://github.com/dirkjanfaber/node-red-contrib-eskomsepush"
   },
   "dependencies": {
-    "axios": "^1.3.5"
+    "axios": "^1.17.0"
   },
   "devDependencies": {
-    "standard": "^17.0.0"
+    "@types/jest": "^29.5.14",
+    "@types/node": "^25.9.3",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.4.11",
+    "typescript": "^6.0.3"
   },
   "engines": {
-    "node": ">=14.17.4"
+    "node": ">=18.0.0"
   }
 }

package/src/__tests__/api.test.ts

@@ -0,0 +1,103 @@
+import axios from 'axios'
+import { fetchAllowance, fetchArea, fetchStatus, migrateAreaId, searchAreas } from '../lib/api'
+
+jest.mock('axios')
+const mockedAxios = axios as jest.Mocked<typeof axios>
+
+const V3_BASE = 'https://developer.sepush.co.za/business/3.0'
+const TOKEN = 'TEST-TOKEN-1234'
+
+beforeEach(() => jest.clearAllMocks())
+
+describe('migrateAreaId', () => {
+  it('strips the location suffix from a v2-style ID', () => {
+    expect(migrateAreaId('eskde-10-fourways')).toEqual({ id: 'eskde-10', migrated: true })
+  })
+
+  it('leaves a v3-style ID unchanged', () => {
+    expect(migrateAreaId('eskde-10')).toEqual({ id: 'eskde-10', migrated: false })
+  })
+
+  it('handles long location suffixes', () => {
+    expect(migrateAreaId('eskmo-15-ballitokwadukuzakwazulunatal')).toEqual({
+      id: 'eskmo-15',
+      migrated: true
+    })
+  })
+})
+
+describe('fetchAllowance', () => {
+  it('calls the v3 api_allowance endpoint', async () => {
+    const payload = { allowance: { count: 10, limit: 50, type: 'free' } }
+    mockedAxios.get.mockResolvedValueOnce({ data: payload })
+
+    const result = await fetchAllowance(TOKEN)
+
+    expect(mockedAxios.get).toHaveBeenCalledWith(
+      `${V3_BASE}/api_allowance`,
+      expect.objectContaining({ headers: { token: TOKEN } })
+    )
+    expect(result).toEqual(payload)
+  })
+})
+
+describe('fetchStatus', () => {
+  it('calls the v3 status endpoint', async () => {
+    const payload = { status: { eskom: { stage: '2', name: 'National', next_stages: [], stage_updated: '' } } }
+    mockedAxios.get.mockResolvedValueOnce({ data: payload })
+
+    const result = await fetchStatus(TOKEN)
+
+    expect(mockedAxios.get).toHaveBeenCalledWith(
+      `${V3_BASE}/status`,
+      expect.objectContaining({ headers: { token: TOKEN } })
+    )
+    expect(result).toEqual(payload)
+  })
+})
+
+describe('fetchArea', () => {
+  it('calls the v3 area endpoint with the given area ID', async () => {
+    const payload = { events: [], info: { name: 'Test', region: 'Test' }, schedule: { days: [], source: '' } }
+    mockedAxios.get.mockResolvedValueOnce({ data: payload })
+
+    await fetchArea(TOKEN, 'eskde-10')
+
+    expect(mockedAxios.get).toHaveBeenCalledWith(
+      `${V3_BASE}/area`,
+      expect.objectContaining({
+        headers: { token: TOKEN },
+        params: { id: 'eskde-10' }
+      })
+    )
+  })
+
+  it('appends test=current when testMode is true', async () => {
+    mockedAxios.get.mockResolvedValueOnce({ data: {} })
+
+    await fetchArea(TOKEN, 'eskde-10', true)
+
+    expect(mockedAxios.get).toHaveBeenCalledWith(
+      `${V3_BASE}/area`,
+      expect.objectContaining({ params: { id: 'eskde-10', test: 'current' } })
+    )
+  })
+})
+
+describe('searchAreas', () => {
+  it('calls the v3 areas_search endpoint with text param', async () => {
+    const payload = { areas: [{ id: 'eskde-10', name: 'Fourways 2', region: 'Eskom Direct' }] }
+    mockedAxios.get.mockResolvedValueOnce({ data: payload })
+
+    const result = await searchAreas(TOKEN, 'fourways')
+
+    expect(mockedAxios.get).toHaveBeenCalledWith(
+      `${V3_BASE}/areas_search`,
+      expect.objectContaining({
+        headers: { token: TOKEN },
+        params: { text: 'fourways' }
+      })
+    )
+    expect(result).toEqual(payload)
+  })
+})

package/src/__tests__/loadshedding.test.ts

@@ -0,0 +1,262 @@
+import { calculateCalc, calculateSleepTime, getMinutesToAPIReset } from '../lib/loadshedding'
+import type { AreaInfo, StatusInfo } from '../lib/types'
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeArea(
+  stageSlots: string[][],
+  tomorrowSlots: string[][] = stageSlots,
+  events: AreaInfo['events'] = []
+): AreaInfo {
+  return {
+    events,
+    info: { name: 'Test Area', region: 'Test Region' },
+    schedule: {
+      days: [
+        { date: '2024-01-15', name: 'Monday',  stages: stageSlots    },
+        { date: '2024-01-16', name: 'Tuesday', stages: tomorrowSlots }
+      ],
+      source: 'test'
+    }
+  }
+}
+
+function makeStatus(stage: string, key = 'eskom'): StatusInfo {
+  return { status: { [key]: { stage, name: 'National', next_stages: [], stage_updated: '' } } }
+}
+
+/** Local Date at a specific clock time on 2024-01-15 */
+function at(h: number, m = 0): Date {
+  return new Date(2024, 0, 15, h, m, 0)
+}
+
+// ---------------------------------------------------------------------------
+// getMinutesToAPIReset
+// ---------------------------------------------------------------------------
+
+describe('getMinutesToAPIReset', () => {
+  it('returns 60 minutes when it is 01:00', () => {
+    expect(getMinutesToAPIReset(at(1))).toBe(60)
+  })
+
+  it('returns 23 * 60 minutes when it is 03:00 (reset already passed today)', () => {
+    expect(getMinutesToAPIReset(at(3))).toBe(23 * 60)
+  })
+
+  it('returns 0 minutes at exactly 02:00', () => {
+    expect(getMinutesToAPIReset(at(2))).toBe(0)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// calculateSleepTime
+// ---------------------------------------------------------------------------
+
+describe('calculateSleepTime', () => {
+  it('returns 60 when all allowance is consumed', () => {
+    expect(calculateSleepTime(50, 50, 0, 120)).toBe(60)
+  })
+
+  it('returns 60 when remaining is negative due to buffer', () => {
+    expect(calculateSleepTime(50, 48, 5, 120)).toBe(60)
+  })
+
+  it('enforces a minimum of 10 minutes', () => {
+    // remaining=50, minutesToReset=1 → round(1/ceil(50/2)) = round(1/25) = 0 → min 10
+    expect(calculateSleepTime(50, 0, 0, 1)).toBe(10)
+  })
+
+  it('distributes remaining calls evenly over minutesToReset', () => {
+    // remaining=20, minutesToReset=120 → round(120/ceil(20/2)) = round(120/10) = 12
+    expect(calculateSleepTime(50, 30, 0, 120)).toBe(12)
+  })
+
+  it('applies buffer when calculating remaining calls', () => {
+    // remaining=15 (50-30-5), minutesToReset=120 → round(120/ceil(15/2)) = round(120/8) = 15
+    expect(calculateSleepTime(50, 30, 5, 120)).toBe(15)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// calculateCalc
+// ---------------------------------------------------------------------------
+
+describe('calculateCalc', () => {
+  const SLEEPTIME = 60
+
+  describe('stage 0 (no loadshedding)', () => {
+    it('returns inactive with no next period', () => {
+      const area = makeArea([[], []])
+      const status = makeStatus('0')
+      const result = calculateCalc(area, status, 'eskom', SLEEPTIME, at(13))
+
+      expect(result.active).toBe(false)
+      expect(result.next).toBeUndefined()
+    })
+  })
+
+  describe('schedule-based loadshedding', () => {
+    // Stage 2 slots on 2024-01-15: 04:00–06:30 and 12:00–14:30
+    // Stage 1 slots are in index 0, stage 2 in index 1
+    const stageSlots = [
+      ['20:00-22:30'],                  // stage 1
+      ['04:00-06:30', '12:00-14:30']    // stage 2
+    ]
+    const tomorrowSlots = [
+      ['00:00-02:30'],
+      ['00:00-02:30', '08:00-10:30']
+    ]
+
+    it('detects an active schedule slot', () => {
+      const area = makeArea(stageSlots, tomorrowSlots)
+      const result = calculateCalc(area, makeStatus('2'), 'eskom', SLEEPTIME, at(13))
+
+      expect(result.active).toBe(true)
+      expect(result.type).toBe('schedule')
+      expect(result.stage).toBe('2')
+      expect(result.duration).toBe(2.5 * 3600)
+      expect(result.islong).toBe(false)
+    })
+
+    it('finds the next slot later today when not active', () => {
+      const area = makeArea(stageSlots, tomorrowSlots)
+      const result = calculateCalc(area, makeStatus('2'), 'eskom', SLEEPTIME, at(8))
+
+      expect(result.active).toBe(false)
+      expect(result.next?.type).toBe('schedule')
+      expect(result.next?.duration).toBe(2.5 * 3600)
+      expect(result.next?.islong).toBe(false)
+      // secondstostatechange should be positive (time until 12:00)
+      expect(result.secondstostatechange).toBeGreaterThan(0)
+    })
+
+    it('falls back to the first slot tomorrow when today has no more slots', () => {
+      const area = makeArea(stageSlots, tomorrowSlots)
+      const result = calculateCalc(area, makeStatus('2'), 'eskom', SLEEPTIME, at(23))
+
+      expect(result.active).toBe(false)
+      expect(result.next?.type).toBe('schedule')
+      // The next start should be on 2024-01-16 (tomorrow)
+      expect(new Date(result.next!.start).getDate()).toBe(16)
+    })
+
+    it('marks islong true for a 4-hour-plus slot', () => {
+      const longSlots = [
+        ['12:00-16:00']   // stage 1, exactly 4 h
+      ]
+      const area = makeArea(longSlots)
+      const result = calculateCalc(area, makeStatus('1'), 'eskom', SLEEPTIME, at(10))
+
+      expect(result.next?.islong).toBe(true)
+    })
+
+    it('handles midnight-crossing slots', () => {
+      const midnightSlots = [
+        ['22:00-00:30']   // stage 1, crosses midnight
+      ]
+      const area = makeArea(midnightSlots, midnightSlots)
+      const result = calculateCalc(area, makeStatus('1'), 'eskom', SLEEPTIME, at(23))
+
+      expect(result.active).toBe(true)
+      expect(result.type).toBe('schedule')
+    })
+
+    it('sets secondstostatechange to time until shedding ends when active', () => {
+      const area = makeArea(stageSlots, tomorrowSlots)
+      const result = calculateCalc(area, makeStatus('2'), 'eskom', SLEEPTIME, at(13))
+
+      // 14:30 − 13:00 = 90 minutes = 5400 seconds
+      expect(result.secondstostatechange).toBeCloseTo(5400, -1)
+    })
+
+    it('marks isHigherStage true when the next event has a higher stage than current', () => {
+      // We need the schedule loop to NOT overwrite calc.next, so we use an area
+      // whose stages array has only 1 element — stage 2 (index 1) is out of bounds → break.
+      const eventStartMs = Date.UTC(2024, 0, 15, 20, 0)
+      const eventEndMs   = Date.UTC(2024, 0, 15, 22, 30)
+      const events: AreaInfo['events'] = [{
+        start: new Date(eventStartMs).toISOString(),
+        end:   new Date(eventEndMs).toISOString(),
+        note:  'Stage 4 Loadshedding'
+      }]
+      const area = makeArea([['20:00-22:30']], [['00:00-02:30']], events)
+      const result = calculateCalc(area, makeStatus('2'), 'eskom', SLEEPTIME, at(10))
+
+      expect(result.next?.type).toBe('event')
+      expect(result.next?.stage).toBe('4')
+      expect(result.next?.isHigherStage).toBe(true)
+    })
+  })
+
+  describe('event-based loadshedding', () => {
+    // Events use ISO timestamps with timezone offset — Date.parse handles them in UTC
+    const eventStartMs = Date.UTC(2024, 0, 15, 10, 0)   // 10:00 UTC
+    const eventEndMs   = Date.UTC(2024, 0, 15, 12, 30)  // 12:30 UTC
+    const events: AreaInfo['events'] = [{
+      start: new Date(eventStartMs).toISOString(),
+      end:   new Date(eventEndMs).toISOString(),
+      note:  'Stage 2 Loadshedding'
+    }]
+
+    it('detects an active event', () => {
+      const area = makeArea([[]], [[]], events)
+      const nowUTC = new Date(Date.UTC(2024, 0, 15, 11, 0)) // 11:00 UTC, inside event
+
+      const result = calculateCalc(area, makeStatus('0'), 'eskom', SLEEPTIME, nowUTC)
+
+      expect(result.active).toBe(true)
+      expect(result.type).toBe('event')
+      expect(result.stage).toBe('2') // stage overridden from event note
+    })
+
+    it('finds an upcoming event when not yet started', () => {
+      const area = makeArea([[]], [[]], events)
+      const nowUTC = new Date(Date.UTC(2024, 0, 15, 8, 0)) // 08:00 UTC, before event
+
+      const result = calculateCalc(area, makeStatus('0'), 'eskom', SLEEPTIME, nowUTC)
+
+      expect(result.active).toBe(false)
+      expect(result.next?.type).toBe('event')
+      expect(result.next?.duration).toBe(2.5 * 3600)
+    })
+
+    it('ignores a past event', () => {
+      const area = makeArea([[]], [[]], events)
+      const nowUTC = new Date(Date.UTC(2024, 0, 15, 13, 0)) // 13:00 UTC, after event
+
+      const result = calculateCalc(area, makeStatus('0'), 'eskom', SLEEPTIME, nowUTC)
+
+      expect(result.active).toBe(false)
+      expect(result.next).toBeUndefined()
+    })
+
+    it('does not crash when event note has no stage pattern', () => {
+      const bareEvents: AreaInfo['events'] = [{
+        start: new Date(eventStartMs).toISOString(),
+        end:   new Date(eventEndMs).toISOString(),
+        note:  'Unplanned outage'
+      }]
+      const area = makeArea([[]], [[]], bareEvents)
+      const nowUTC = new Date(Date.UTC(2024, 0, 15, 11, 0))
+
+      expect(() => calculateCalc(area, makeStatus('1'), 'eskom', SLEEPTIME, nowUTC)).not.toThrow()
+    })
+  })
+
+  describe('statusselect', () => {
+    it('reads the stage from the correct statusselect key', () => {
+      const statusInfo: StatusInfo = {
+        status: {
+          eskom:    { stage: '1', name: 'National', next_stages: [], stage_updated: '' },
+          capetown: { stage: '3', name: 'Cape Town', next_stages: [], stage_updated: '' }
+        }
+      }
+      const area = makeArea([['20:00-22:30'], [], ['12:00-14:30', '20:00-22:30']])
+      const result = calculateCalc(area, statusInfo, 'capetown', SLEEPTIME, at(8))
+
+      expect(result.stage).toBe('3')
+    })
+  })
+})

package/src/lib/api.ts

@@ -0,0 +1,45 @@
+import axios from 'axios'
+import type { AllowanceInfo, AreaInfo, AreasSearchResult, StatusInfo } from './types'
+
+const API_BASE = 'https://developer.sepush.co.za/business/3.0'
+
+/** Detects a v2-style area ID (e.g. eskde-10-fourways) and returns the v3 equivalent (eskde-10). */
+export function migrateAreaId(areaId: string): { id: string; migrated: boolean } {
+  const parts = areaId.split('-')
+  if (parts.length > 2) {
+    return { id: parts.slice(0, 2).join('-'), migrated: true }
+  }
+  return { id: areaId, migrated: false }
+}
+
+export async function fetchAllowance(token: string): Promise<AllowanceInfo> {
+  const { data } = await axios.get<AllowanceInfo>(`${API_BASE}/api_allowance`, {
+    headers: { token }
+  })
+  return data
+}
+
+export async function fetchStatus(token: string): Promise<StatusInfo> {
+  const { data } = await axios.get<StatusInfo>(`${API_BASE}/status`, {
+    headers: { token }
+  })
+  return data
+}
+
+export async function fetchArea(token: string, areaId: string, testMode = false): Promise<AreaInfo> {
+  const params: Record<string, string> = { id: areaId }
+  if (testMode) params.test = 'current'
+  const { data } = await axios.get<AreaInfo>(`${API_BASE}/area`, {
+    headers: { token },
+    params
+  })
+  return data
+}
+
+export async function searchAreas(token: string, query: string): Promise<AreasSearchResult> {
+  const { data } = await axios.get<AreasSearchResult>(`${API_BASE}/areas_search`, {
+    headers: { token },
+    params: { text: query }
+  })
+  return data
+}

package/src/lib/loadshedding.ts

@@ -0,0 +1,131 @@
+import type { AreaInfo, CalcResult, StatusInfo } from './types'
+
+export function getMinutesToAPIReset(now: Date = new Date()): number {
+  const resetTime = new Date(now.getFullYear(), now.getMonth(), now.getDate(), 2, 0, 0)
+  if (now > resetTime) {
+    resetTime.setDate(resetTime.getDate() + 1)
+  }
+  return Math.floor((resetTime.getTime() - now.getTime()) / 60_000)
+}
+
+export function calculateSleepTime(
+  limit: number,
+  count: number,
+  buffer: number,
+  minutesToReset: number
+): number {
+  const remaining = limit - buffer - count
+  if (remaining <= 0) return 60
+  const sleeptime = Math.round(minutesToReset / Math.ceil(remaining / 2))
+  return Math.max(sleeptime, 10)
+}
+
+function parseScheduleTime(date: string, time: string): number {
+  const [year, month, day] = date.split('-').map(Number)
+  const [hour, minute] = time.split(':').map(Number)
+  return new Date(year, month - 1, day, hour, minute).getTime()
+}
+
+export function calculateCalc(
+  areaInfo: AreaInfo,
+  statusInfo: StatusInfo,
+  statusselect: string,
+  sleeptime: number,
+  now: Date = new Date()
+): CalcResult {
+  const statusStage = statusInfo.status[statusselect]?.stage ?? '0'
+  const calc: CalcResult = {
+    sleeptime,
+    stage: statusStage,
+    active: false
+  }
+
+  // Check events first — an active event can override the effective stage
+  if (areaInfo.events.length > 0) {
+    const firstEvent = areaInfo.events[0]
+    const eventStart = Date.parse(firstEvent.start)
+    const eventEnd = Date.parse(firstEvent.end)
+
+    if (now.getTime() >= eventStart && now.getTime() < eventEnd) {
+      calc.type = 'event'
+      calc.active = true
+      const stageMatch = firstEvent.note.match(/Stage (\d+)/i)
+      if (stageMatch) calc.stage = stageMatch[1]
+      calc.start = eventStart
+      calc.end = eventEnd
+    } else if (now.getTime() < eventStart) {
+      const stageMatch = firstEvent.note.match(/Stage (\d+)/i)
+      calc.next = {
+        type: 'event',
+        start: eventStart,
+        end: eventEnd,
+        duration: 0,   // computed in post-loop block
+        islong: false, // computed in post-loop block
+        stage: stageMatch ? stageMatch[1] : statusStage
+      }
+    }
+  }
+
+  // Check scheduled downtime — uses local time (schedule times have no timezone info)
+  const effectiveStageNum = parseInt(String(calc.stage), 10)
+  let breakLoop = false
+
+  for (const day of areaInfo.schedule.days) {
+    const stageIndex = effectiveStageNum - 1
+
+    if (stageIndex < 0 || stageIndex >= day.stages.length) {
+      break // Stage 0 or out of range → no scheduled loadshedding
+    }
+
+    const slots = day.stages[stageIndex]
+    if (!Array.isArray(slots)) break
+
+    for (const slot of slots) {
+      const [startStr, endStr] = slot.split('-')
+      let schedStart = parseScheduleTime(day.date, startStr)
+      let schedEnd = parseScheduleTime(day.date, endStr)
+
+      // Handle slots that cross midnight (e.g. "22:00-00:30")
+      if (schedEnd < schedStart) {
+        schedEnd += 24 * 60 * 60 * 1000
+      }
+
+      if (now.getTime() < schedEnd) {
+        breakLoop = true
+        if (now.getTime() >= schedStart) {
+          calc.active = true
+          calc.type = 'schedule'
+          calc.start = schedStart
+          calc.end = schedEnd
+        } else {
+          calc.next = {
+            type: 'schedule',
+            start: schedStart,
+            end: schedEnd,
+            duration: 0,   // computed below
+            islong: false, // computed below
+            stage: calc.stage
+          }
+        }
+        break
+      }
+    }
+    if (breakLoop) break
+  }
+
+  // Compute derived fields — next block runs first so active block can overwrite secondstostatechange
+  if (calc.next) {
+    calc.next.duration = (calc.next.end - calc.next.start) / 1000
+    calc.next.islong = calc.next.duration >= 4 * 3600
+    calc.secondstostatechange = Math.floor((calc.next.start - now.getTime()) / 1000)
+    calc.next.isHigherStage = Number(calc.next.stage) > Number(calc.stage)
+  }
+
+  if (calc.active && calc.start !== undefined && calc.end !== undefined) {
+    calc.duration = (calc.end - calc.start) / 1000
+    calc.islong = calc.duration >= 4 * 3600
+    calc.secondstostatechange = Math.floor((calc.end - now.getTime()) / 1000)
+  }
+
+  return calc
+}