kirby-ocpp 0.1.2 → 0.3.0

package/dist/station/persistence.js

@@ -1,206 +0,0 @@
-import { DEFAULT_SAMPLED_DATA } from "./metering.js";
-import { readChargingProfileEntry, readLegacyChargingProfileEntry } from "./smart-charging.js";
-export function buildPersistedStationState(options) {
-    const primaryConnector = options.connectors.find((connector) => connector.id === options.connectorId) ?? options.connectors[0];
-    return {
-        version: 1,
-        chargePointId: options.chargePointId,
-        connectorCount: options.connectors.length,
-        connectorMeterValues: serializeConnectorMeterValues(options.connectors),
-        connectorReservations: serializeConnectorReservations(options.connectors),
-        connectorTransactions: serializeConnectorTransactions(options.connectors),
-        localListVersion: options.localListVersion,
-        localAuthorizationList: serializeAuthorizationEntries(options.localAuthorizationList),
-        authorizationCache: serializeAuthorizationEntries(options.authorizationCache),
-        chargingProfiles: options.chargingProfiles,
-        configurationValues: serializeMutableConfiguration(options.configuration),
-        meterWh: primaryConnector?.meterWh ?? 0
-    };
-}
-export function restorePersistedStationState(options) {
-    const { persisted } = options;
-    const persistedConnectorCount = Math.max(persisted.connectorCount ?? 1, options.connectorId);
-    options.connectors.ensureCount(persistedConnectorCount);
-    options.configuration.setValue("NumberOfConnectors", String(options.connectors.size));
-    const chargingProfiles = persisted.chargingProfiles
-        .map((entry) => readChargingProfileEntry(entry) ?? readLegacyChargingProfileEntry(entry, options.connectorId))
-        .filter(isDefined);
-    for (const [connectorId, meterWh] of Object.entries(persisted.connectorMeterValues ?? {})) {
-        const numericConnectorId = Number.parseInt(connectorId, 10);
-        if (Number.isInteger(numericConnectorId) && options.connectors.has(numericConnectorId)) {
-            options.connectors.patch(numericConnectorId, { meterWh });
-        }
-    }
-    for (const [connectorId, reservation] of Object.entries(persisted.connectorReservations ?? {})) {
-        const numericConnectorId = Number.parseInt(connectorId, 10);
-        if (!Number.isInteger(numericConnectorId) || !options.connectors.has(numericConnectorId)) {
-            continue;
-        }
-        if (Date.parse(reservation.expiryDate) <= Date.now()) {
-            continue;
-        }
-        options.connectors.patch(numericConnectorId, {
-            reservationId: reservation.reservationId,
-            reservationIdTag: reservation.idTag,
-            reservationParentIdTag: reservation.parentIdTag,
-            reservationExpiryDate: reservation.expiryDate,
-            status: "Reserved"
-        });
-        options.scheduleReservation(numericConnectorId);
-    }
-    for (const [connectorId, transaction] of Object.entries(persisted.connectorTransactions ?? {})) {
-        const numericConnectorId = Number.parseInt(connectorId, 10);
-        if (!Number.isInteger(numericConnectorId) || !options.connectors.has(numericConnectorId)) {
-            continue;
-        }
-        options.connectors.patch(numericConnectorId, {
-            transactionId: transaction.transactionId,
-            transactionStartedAt: transaction.transactionStartedAt,
-            lastIdTag: transaction.lastIdTag,
-            evConnected: transaction.evConnected,
-            status: readPersistedConnectorStatus(transaction.status),
-            stopTransactionAtWh: transaction.stopTransactionAtWh,
-            pendingStartTransaction: readPersistedPendingStart(transaction.pendingStartTransaction),
-            pendingStopTransaction: readPersistedPendingStop(transaction.pendingStopTransaction)
-        });
-    }
-    if (Object.keys(persisted.connectorMeterValues ?? {}).length === 0 && options.connectors.has(options.connectorId)) {
-        options.connectors.patch(options.connectorId, { meterWh: persisted.meterWh });
-    }
-    options.localAuthorizationList.clear();
-    for (const entry of persisted.localAuthorizationList) {
-        options.localAuthorizationList.set(entry.idTag, entry.idTagInfo);
-    }
-    options.authorizationCache.clear();
-    for (const entry of persisted.authorizationCache ?? []) {
-        options.authorizationCache.set(entry.idTag, entry.idTagInfo);
-    }
-    for (const [key, value] of Object.entries(persisted.configurationValues)) {
-        options.configuration.setValue(key, restoredConfigurationValue(key, value));
-    }
-    return { localListVersion: persisted.localListVersion, chargingProfiles };
-}
-function restoredConfigurationValue(key, value) {
-    if (isMeteringConfigurationKey(key) && value === "Energy.Active.Import.Register") {
-        return DEFAULT_SAMPLED_DATA.join(",");
-    }
-    return value;
-}
-function isMeteringConfigurationKey(key) {
-    return key === "MeterValuesAlignedData" ||
-        key === "MeterValuesSampledData" ||
-        key === "StopTxnAlignedData" ||
-        key === "StopTxnSampledData";
-}
-function serializeAuthorizationEntries(entries) {
-    return [...entries.entries()].map(([idTag, idTagInfo]) => {
-        if (!idTagInfo) {
-            return { idTag };
-        }
-        return { idTag, idTagInfo };
-    });
-}
-function serializeMutableConfiguration(configuration) {
-    return Object.fromEntries([...configuration.entries()].filter(([, value]) => !value.readonly).map(([key, value]) => [key, value.value]));
-}
-function serializeConnectorMeterValues(connectors) {
-    return Object.fromEntries(connectors.map((connector) => [String(connector.id), connector.meterWh]));
-}
-function serializeConnectorReservations(connectors) {
-    return Object.fromEntries(connectors
-        .filter((connector) => connector.reservationId && connector.reservationIdTag && connector.reservationExpiryDate)
-        .map((connector) => {
-        const reservation = {
-            reservationId: connector.reservationId ?? 0,
-            idTag: connector.reservationIdTag ?? "",
-            expiryDate: connector.reservationExpiryDate ?? ""
-        };
-        if (connector.reservationParentIdTag) {
-            reservation.parentIdTag = connector.reservationParentIdTag;
-        }
-        return [String(connector.id), reservation];
-    }));
-}
-function serializeConnectorTransactions(connectors) {
-    return Object.fromEntries(connectors
-        .filter((connector) => connector.transactionId || connector.pendingStartTransaction || connector.pendingStopTransaction)
-        .map((connector) => [
-        String(connector.id),
-        {
-            transactionId: connector.transactionId ?? 0,
-            transactionStartedAt: connector.transactionStartedAt,
-            lastIdTag: connector.lastIdTag,
-            evConnected: connector.evConnected,
-            status: connector.status,
-            stopTransactionAtWh: connector.stopTransactionAtWh,
-            pendingStartTransaction: connector.pendingStartTransaction,
-            pendingStopTransaction: connector.pendingStopTransaction
-        }
-    ]));
-}
-function readPersistedConnectorStatus(value) {
-    return value === "Available" ||
-        value === "Preparing" ||
-        value === "Charging" ||
-        value === "SuspendedEVSE" ||
-        value === "SuspendedEV" ||
-        value === "Finishing" ||
-        value === "Reserved" ||
-        value === "Unavailable" ||
-        value === "Faulted"
-        ? value
-        : "Charging";
-}
-function readPersistedPendingStart(value) {
-    if (!value) {
-        return undefined;
-    }
-    const connectorId = typeof value.connectorId === "number" ? value.connectorId : undefined;
-    const idTag = typeof value.idTag === "string" ? value.idTag : undefined;
-    const meterStart = typeof value.meterStart === "number" ? value.meterStart : undefined;
-    const timestamp = typeof value.timestamp === "string" ? value.timestamp : undefined;
-    if (connectorId === undefined || idTag === undefined || meterStart === undefined || timestamp === undefined) {
-        return undefined;
-    }
-    const pendingStart = { connectorId, idTag, meterStart, timestamp };
-    if (typeof value.reservationId === "number") {
-        return { ...pendingStart, reservationId: value.reservationId };
-    }
-    return pendingStart;
-}
-function readPersistedPendingStop(value) {
-    if (!value) {
-        return undefined;
-    }
-    const meterStop = typeof value.meterStop === "number" ? value.meterStop : undefined;
-    const timestamp = typeof value.timestamp === "string" ? value.timestamp : undefined;
-    const reason = typeof value.reason === "string" ? value.reason : undefined;
-    const transactionData = Array.isArray(value.transactionData) ? value.transactionData.filter(isRecord) : [];
-    if (meterStop === undefined || timestamp === undefined || !isStopReason(reason)) {
-        return undefined;
-    }
-    const pendingStop = { meterStop, timestamp, reason, transactionData };
-    if (typeof value.idTag === "string") {
-        return { ...pendingStop, idTag: value.idTag };
-    }
-    return pendingStop;
-}
-function isStopReason(value) {
-    return value === "EmergencyStop" ||
-        value === "EVDisconnected" ||
-        value === "HardReset" ||
-        value === "Local" ||
-        value === "Other" ||
-        value === "PowerLoss" ||
-        value === "Reboot" ||
-        value === "Remote" ||
-        value === "SoftReset" ||
-        value === "UnlockCommand" ||
-        value === "DeAuthorized";
-}
-function isRecord(value) {
-    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-function isDefined(value) {
-    return value !== undefined;
-}

package/dist/station/reservation-rules.d.ts

@@ -1,3 +0,0 @@
-import type { ConnectorState } from "../ocpp/types.js";
-export type ReserveNowStatus = "Accepted" | "Faulted" | "Occupied" | "Rejected" | "Unavailable";
-export declare function reserveNowRejection(connector: ConnectorState | undefined, expiryDate: string): Exclude<ReserveNowStatus, "Accepted"> | undefined;

package/dist/station/reservation-rules.js

@@ -1,18 +0,0 @@
-export function reserveNowRejection(connector, expiryDate) {
-    if (!connector) {
-        return "Unavailable";
-    }
-    if (connector.transactionId || connector.reservationId || connector.status === "Reserved") {
-        return "Occupied";
-    }
-    if (connector.status === "Faulted") {
-        return "Faulted";
-    }
-    if (connector.availability === "Inoperative" || connector.status === "Unavailable") {
-        return "Unavailable";
-    }
-    if (!expiryDate || Date.parse(expiryDate) <= Date.now()) {
-        return "Rejected";
-    }
-    return undefined;
-}

package/dist/station/reservation-scheduler.d.ts

@@ -1,11 +0,0 @@
-export declare class ReservationScheduler {
-    private readonly options;
-    private readonly timers;
-    constructor(options: {
-        expiryDate: (connectorId: number) => string | undefined;
-        expire: (connectorId: number) => void;
-    });
-    schedule(connectorId: number): void;
-    clear(connectorId: number): void;
-    clearAll(): void;
-}

package/dist/station/reservation-scheduler.js

@@ -1,33 +0,0 @@
-export class ReservationScheduler {
-    options;
-    timers = new Map();
-    constructor(options) {
-        this.options = options;
-    }
-    schedule(connectorId) {
-        this.clear(connectorId);
-        const expiryDate = this.options.expiryDate(connectorId);
-        if (!expiryDate) {
-            return;
-        }
-        const delay = Date.parse(expiryDate) - Date.now();
-        if (delay <= 0) {
-            this.options.expire(connectorId);
-            return;
-        }
-        this.timers.set(connectorId, setTimeout(() => this.options.expire(connectorId), delay));
-    }
-    clear(connectorId) {
-        const timer = this.timers.get(connectorId);
-        if (!timer) {
-            return;
-        }
-        clearTimeout(timer);
-        this.timers.delete(connectorId);
-    }
-    clearAll() {
-        for (const connectorId of [...this.timers.keys()]) {
-            this.clear(connectorId);
-        }
-    }
-}

package/dist/station/smart-charging.d.ts

@@ -1,45 +0,0 @@
-export type ChargingProfilePurpose = "ChargePointMaxProfile" | "TxDefaultProfile" | "TxProfile";
-export type ChargingProfileKind = "Absolute" | "Recurring" | "Relative";
-export type ChargingRateUnit = "A" | "W";
-export interface ChargingSchedulePeriod {
-    startPeriod: number;
-    limit: number;
-    numberPhases?: number;
-}
-export interface ChargingSchedule {
-    duration?: number;
-    startSchedule?: string;
-    chargingRateUnit: ChargingRateUnit;
-    chargingSchedulePeriod: ChargingSchedulePeriod[];
-    minChargingRate?: number;
-}
-export interface ChargingProfile {
-    chargingProfileId: number;
-    transactionId?: number;
-    stackLevel: number;
-    chargingProfilePurpose: ChargingProfilePurpose;
-    chargingProfileKind: ChargingProfileKind;
-    recurrencyKind?: "Daily" | "Weekly";
-    validFrom?: string;
-    validTo?: string;
-    chargingSchedule: ChargingSchedule;
-}
-export interface ChargingProfileEntry {
-    connectorId: number;
-    profile: ChargingProfile;
-}
-export declare function readChargingProfile(value: unknown): ChargingProfile | undefined;
-export declare function readChargingProfileEntry(value: unknown): ChargingProfileEntry | undefined;
-export declare function readLegacyChargingProfileEntry(value: unknown, defaultConnectorId: number): ChargingProfileEntry | undefined;
-export declare function readChargingRateUnit(value: unknown): ChargingRateUnit | undefined;
-export declare function canStoreChargingProfile(connectorId: number, profile: ChargingProfile, options: {
-    hasConnector: (connectorId: number) => boolean;
-    transactionIdForConnector: (connectorId: number) => number | undefined;
-}): boolean;
-export declare function matchesChargingProfileFilter(entry: ChargingProfileEntry, payload: Record<string, unknown>): boolean;
-export declare function applicableChargingProfiles(entries: ChargingProfileEntry[], connectorId: number, transactionId: number | undefined, at: Date): ChargingProfileEntry[];
-export declare function effectiveChargingProfiles(entries: ChargingProfileEntry[], connectorId: number, transactionId: number | undefined, at: Date, chargingRateUnit?: ChargingRateUnit): ChargingProfileEntry[];
-export declare function limitAt(profile: ChargingProfile, at: Date, relativeStart?: Date, defaultStart?: Date): number | undefined;
-export declare function periodAt(profile: ChargingProfile, at: Date, relativeStart?: Date, defaultStart?: Date): ChargingSchedulePeriod | undefined;
-export declare function limitTransitionOffsets(profile: ChargingProfile, scheduleStart: Date, duration: number, relativeStart?: Date): number[];
-export declare function isChargingProfileExpired(profile: ChargingProfile, at: Date): boolean;

package/dist/station/smart-charging.js

@@ -1,251 +0,0 @@
-const PURPOSE_PRIORITY = ["TxProfile", "TxDefaultProfile", "ChargePointMaxProfile"];
-export function readChargingProfile(value) {
-    const payload = readObject(value);
-    const chargingSchedule = readChargingSchedule(payload.chargingSchedule);
-    const chargingProfilePurpose = readChargingProfilePurpose(payload.chargingProfilePurpose);
-    const chargingProfileKind = readChargingProfileKind(payload.chargingProfileKind);
-    if (!chargingSchedule || !chargingProfilePurpose || !chargingProfileKind) {
-        return undefined;
-    }
-    const profile = {
-        chargingProfileId: readNumber(payload.chargingProfileId, -1),
-        stackLevel: readNumber(payload.stackLevel, -1),
-        chargingProfilePurpose,
-        chargingProfileKind,
-        chargingSchedule
-    };
-    const transactionId = readOptionalNumber(payload.transactionId);
-    const recurrencyKind = readRecurrencyKind(payload.recurrencyKind);
-    const validFrom = readOptionalString(payload.validFrom);
-    const validTo = readOptionalString(payload.validTo);
-    if (transactionId !== undefined) {
-        profile.transactionId = transactionId;
-    }
-    if (recurrencyKind) {
-        profile.recurrencyKind = recurrencyKind;
-    }
-    if (validFrom) {
-        profile.validFrom = validFrom;
-    }
-    if (validTo) {
-        profile.validTo = validTo;
-    }
-    return profile.chargingProfileId >= 0 && profile.stackLevel >= 0 ? profile : undefined;
-}
-export function readChargingProfileEntry(value) {
-    const payload = readObject(value);
-    const connectorId = readOptionalNumber(payload.connectorId);
-    const profile = readChargingProfile(payload.profile);
-    if (connectorId === undefined || !profile) {
-        return undefined;
-    }
-    return { connectorId, profile };
-}
-export function readLegacyChargingProfileEntry(value, defaultConnectorId) {
-    const profile = readChargingProfile(value);
-    return profile ? { connectorId: defaultConnectorId, profile } : undefined;
-}
-export function readChargingRateUnit(value) {
-    return value === "A" || value === "W" ? value : undefined;
-}
-export function canStoreChargingProfile(connectorId, profile, options) {
-    if (!Number.isInteger(connectorId) || connectorId < 0) {
-        return false;
-    }
-    if (profile.chargingProfilePurpose === "ChargePointMaxProfile") {
-        return connectorId === 0;
-    }
-    if (connectorId !== 0 && !options.hasConnector(connectorId)) {
-        return false;
-    }
-    if (profile.chargingProfilePurpose === "TxProfile") {
-        const transactionId = connectorId > 0 ? options.transactionIdForConnector(connectorId) : undefined;
-        if (!transactionId) {
-            return false;
-        }
-        return profile.transactionId === undefined || profile.transactionId === transactionId;
-    }
-    return true;
-}
-export function matchesChargingProfileFilter(entry, payload) {
-    const hasFilter = "id" in payload || "connectorId" in payload || "chargingProfilePurpose" in payload || "stackLevel" in payload;
-    if (!hasFilter) {
-        return true;
-    }
-    const id = readOptionalNumber(payload.id);
-    const connectorId = readOptionalNumber(payload.connectorId);
-    const purpose = readChargingProfilePurpose(payload.chargingProfilePurpose);
-    const stackLevel = readOptionalNumber(payload.stackLevel);
-    return ((id === undefined || entry.profile.chargingProfileId === id) &&
-        (connectorId === undefined || entry.connectorId === connectorId) &&
-        (purpose === undefined || entry.profile.chargingProfilePurpose === purpose) &&
-        (stackLevel === undefined || entry.profile.stackLevel === stackLevel));
-}
-export function applicableChargingProfiles(entries, connectorId, transactionId, at) {
-    return entries
-        .filter((entry) => entry.connectorId === 0 || entry.connectorId === connectorId)
-        .filter((entry) => isChargingProfileActive(entry.profile, at))
-        .filter((entry) => {
-        if (entry.profile.chargingProfilePurpose !== "TxProfile") {
-            return true;
-        }
-        return Boolean(transactionId) && (entry.profile.transactionId === undefined || entry.profile.transactionId === transactionId);
-    })
-        .sort((left, right) => right.profile.stackLevel - left.profile.stackLevel);
-}
-export function effectiveChargingProfiles(entries, connectorId, transactionId, at, chargingRateUnit) {
-    const applicable = applicableChargingProfiles(entries, connectorId, transactionId, at).filter((entry) => chargingRateUnit === undefined || entry.profile.chargingSchedule.chargingRateUnit === chargingRateUnit);
-    return PURPOSE_PRIORITY.flatMap((purpose) => {
-        const candidates = applicable.filter((entry) => entry.profile.chargingProfilePurpose === purpose);
-        if (candidates.length === 0) {
-            return [];
-        }
-        return candidates.reduce((best, entry) => (entry.profile.stackLevel >= best.profile.stackLevel ? entry : best));
-    });
-}
-export function limitAt(profile, at, relativeStart, defaultStart) {
-    return periodAt(profile, at, relativeStart, defaultStart)?.limit;
-}
-export function periodAt(profile, at, relativeStart, defaultStart) {
-    if (!isChargingProfileActive(profile, at)) {
-        return undefined;
-    }
-    const schedule = profile.chargingSchedule;
-    const elapsedSeconds = scheduleElapsedSeconds(profile, at, relativeStart, defaultStart);
-    if (schedule.duration !== undefined && elapsedSeconds >= schedule.duration) {
-        return undefined;
-    }
-    let activePeriod;
-    for (const period of schedule.chargingSchedulePeriod) {
-        if (period.startPeriod <= elapsedSeconds) {
-            activePeriod = period;
-        }
-    }
-    return activePeriod;
-}
-export function limitTransitionOffsets(profile, scheduleStart, duration, relativeStart) {
-    const offsets = new Set();
-    const elapsedSeconds = scheduleElapsedSeconds(profile, scheduleStart, relativeStart, scheduleStart);
-    const schedule = profile.chargingSchedule;
-    offsets.add(0);
-    if (profile.validTo) {
-        addOffset(offsets, Math.ceil((Date.parse(profile.validTo) - scheduleStart.getTime()) / 1000), duration);
-    }
-    if (profile.validFrom) {
-        addOffset(offsets, Math.ceil((Date.parse(profile.validFrom) - scheduleStart.getTime()) / 1000), duration);
-    }
-    if (profile.chargingProfileKind === "Recurring") {
-        const recurrenceSeconds = profile.recurrencyKind === "Weekly" ? 7 * 24 * 60 * 60 : 24 * 60 * 60;
-        for (let cycle = 0; cycle <= elapsedSeconds + duration + recurrenceSeconds; cycle += recurrenceSeconds) {
-            addScheduleOffsets(offsets, schedule, duration, elapsedSeconds, cycle);
-        }
-        return [...offsets].sort((left, right) => left - right);
-    }
-    addScheduleOffsets(offsets, schedule, duration, elapsedSeconds, 0);
-    return [...offsets].sort((left, right) => left - right);
-}
-export function isChargingProfileExpired(profile, at) {
-    const validTo = profile.validTo ? Date.parse(profile.validTo) : undefined;
-    return validTo !== undefined && !Number.isNaN(validTo) && at.getTime() > validTo;
-}
-function readChargingSchedule(value) {
-    const payload = readObject(value);
-    const chargingRateUnit = readChargingRateUnit(payload.chargingRateUnit);
-    const periods = Array.isArray(payload.chargingSchedulePeriod)
-        ? payload.chargingSchedulePeriod.map((period) => readChargingSchedulePeriod(period)).filter(isDefined)
-        : [];
-    if (!chargingRateUnit || periods.length === 0) {
-        return undefined;
-    }
-    const schedule = {
-        chargingRateUnit,
-        chargingSchedulePeriod: periods.sort((left, right) => left.startPeriod - right.startPeriod)
-    };
-    const duration = readOptionalNumber(payload.duration);
-    const startSchedule = readOptionalString(payload.startSchedule);
-    const minChargingRate = readOptionalNumber(payload.minChargingRate);
-    if (duration !== undefined) {
-        schedule.duration = duration;
-    }
-    if (startSchedule) {
-        schedule.startSchedule = startSchedule;
-    }
-    if (minChargingRate !== undefined) {
-        schedule.minChargingRate = minChargingRate;
-    }
-    return schedule;
-}
-function readChargingSchedulePeriod(value) {
-    const payload = readObject(value);
-    const startPeriod = readOptionalNumber(payload.startPeriod);
-    const limit = readOptionalNumber(payload.limit);
-    if (startPeriod === undefined || limit === undefined) {
-        return undefined;
-    }
-    const period = { startPeriod, limit };
-    const numberPhases = readOptionalNumber(payload.numberPhases);
-    if (numberPhases !== undefined) {
-        period.numberPhases = numberPhases;
-    }
-    return period;
-}
-function readChargingProfilePurpose(value) {
-    return value === "ChargePointMaxProfile" || value === "TxDefaultProfile" || value === "TxProfile" ? value : undefined;
-}
-function readChargingProfileKind(value) {
-    return value === "Absolute" || value === "Recurring" || value === "Relative" ? value : undefined;
-}
-function readRecurrencyKind(value) {
-    return value === "Daily" || value === "Weekly" ? value : undefined;
-}
-function isChargingProfileActive(profile, at) {
-    const validFrom = profile.validFrom ? Date.parse(profile.validFrom) : undefined;
-    const validTo = profile.validTo ? Date.parse(profile.validTo) : undefined;
-    const time = at.getTime();
-    return ((validFrom === undefined || Number.isNaN(validFrom) || time >= validFrom) &&
-        (validTo === undefined || Number.isNaN(validTo) || time <= validTo));
-}
-function addScheduleOffsets(offsets, schedule, duration, elapsedSeconds, elapsedBase) {
-    for (const period of schedule.chargingSchedulePeriod) {
-        addOffset(offsets, elapsedBase + period.startPeriod - elapsedSeconds, duration);
-    }
-    if (schedule.duration !== undefined) {
-        addOffset(offsets, elapsedBase + schedule.duration - elapsedSeconds, duration);
-    }
-}
-function addOffset(offsets, offset, duration) {
-    if (Number.isInteger(offset) && offset > 0 && offset < duration) {
-        offsets.add(offset);
-    }
-}
-function scheduleElapsedSeconds(profile, at, relativeStart, defaultStart) {
-    if (profile.chargingProfileKind === "Relative") {
-        return Math.max(0, Math.floor((at.getTime() - (relativeStart?.getTime() ?? at.getTime())) / 1000));
-    }
-    const start = profile.chargingSchedule.startSchedule
-        ? Date.parse(profile.chargingSchedule.startSchedule)
-        : profile.validFrom
-            ? Date.parse(profile.validFrom)
-            : defaultStart?.getTime() ?? at.getTime();
-    const rawElapsed = Math.max(0, Math.floor((at.getTime() - (Number.isNaN(start) ? at.getTime() : start)) / 1000));
-    if (profile.chargingProfileKind !== "Recurring") {
-        return rawElapsed;
-    }
-    const periodSeconds = profile.recurrencyKind === "Weekly" ? 7 * 24 * 60 * 60 : 24 * 60 * 60;
-    return rawElapsed % periodSeconds;
-}
-function readObject(value) {
-    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
-}
-function readNumber(value, fallback) {
-    return typeof value === "number" && Number.isFinite(value) ? value : fallback;
-}
-function readOptionalNumber(value) {
-    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
-}
-function readOptionalString(value) {
-    return typeof value === "string" ? value : undefined;
-}
-function isDefined(value) {
-    return value !== undefined;
-}

package/dist/station/status-scheduler.d.ts

@@ -1,16 +0,0 @@
-import type { ConnectorStatus } from "../ocpp/types.js";
-export declare class StatusNotificationScheduler {
-    private readonly options;
-    private readonly pending;
-    private readonly lastSent;
-    constructor(options: {
-        minimumSeconds: () => number;
-        currentStatus: (connectorId: number) => ConnectorStatus | undefined;
-        send: (connectorId: number, status: ConnectorStatus) => void;
-    });
-    schedule(connectorId: number, status: ConnectorStatus): boolean;
-    markSent(connectorId: number, status: ConnectorStatus): void;
-    clear(connectorId: number): void;
-    clearAll(): void;
-    flush(): void;
-}

package/dist/station/status-scheduler.js

@@ -1,58 +0,0 @@
-export class StatusNotificationScheduler {
-    options;
-    pending = new Map();
-    lastSent = new Map();
-    constructor(options) {
-        this.options = options;
-    }
-    schedule(connectorId, status) {
-        const pending = this.pending.get(connectorId);
-        if (pending?.status === status) {
-            return true;
-        }
-        if (pending) {
-            this.clear(connectorId);
-        }
-        if (this.lastSent.get(connectorId) === status) {
-            return true;
-        }
-        const minimumSeconds = this.options.minimumSeconds();
-        if (minimumSeconds <= 0) {
-            return false;
-        }
-        this.pending.set(connectorId, {
-            status,
-            timer: setTimeout(() => {
-                this.pending.delete(connectorId);
-                this.options.send(connectorId, status);
-            }, minimumSeconds * 1000)
-        });
-        return true;
-    }
-    markSent(connectorId, status) {
-        this.lastSent.set(connectorId, status);
-    }
-    clear(connectorId) {
-        const pending = this.pending.get(connectorId);
-        if (!pending) {
-            return;
-        }
-        clearTimeout(pending.timer);
-        this.pending.delete(connectorId);
-    }
-    clearAll() {
-        for (const connectorId of [...this.pending.keys()]) {
-            this.clear(connectorId);
-        }
-    }
-    flush() {
-        const connectorIds = [...this.pending.keys()];
-        this.clearAll();
-        for (const connectorId of connectorIds) {
-            const status = this.options.currentStatus(connectorId);
-            if (status) {
-                this.options.send(connectorId, status);
-            }
-        }
-    }
-}

package/dist/station/transaction-message-retry.d.ts

@@ -1,3 +0,0 @@
-export declare const TRANSACTION_MESSAGE_ACTIONS: Set<string>;
-export declare function isTransactionMessage(action: string): boolean;
-export declare function retryDelay(intervalSeconds: number): Promise<void>;

package/dist/station/transaction-message-retry.js

@@ -1,7 +0,0 @@
-export const TRANSACTION_MESSAGE_ACTIONS = new Set(["StartTransaction", "StopTransaction", "MeterValues"]);
-export function isTransactionMessage(action) {
-    return TRANSACTION_MESSAGE_ACTIONS.has(action);
-}
-export function retryDelay(intervalSeconds) {
-    return new Promise((resolve) => setTimeout(resolve, Math.max(0, intervalSeconds) * 1000));
-}

package/dist/station/transaction-rules.d.ts

@@ -1,7 +0,0 @@
-import type { AvailabilityType, ConnectorState, ConnectorStatus, StopReason } from "../ocpp/types.js";
-export declare function startTransactionRejection(connector: ConnectorState, idTag: string): string | undefined;
-export declare function canRemoteStart(connector: ConnectorState | undefined): boolean;
-export declare function statusAfterStopTransaction(reason: StopReason, evConnected: boolean, availability: AvailabilityType): {
-    evConnected: boolean;
-    status: ConnectorStatus;
-};