kirby-ocpp 0.1.0

package/dist/ocpp/types.d.ts

@@ -0,0 +1,106 @@
+export type OcppCall = [2, string, string, Record<string, unknown>];
+export type OcppCallResult = [3, string, Record<string, unknown>];
+export type OcppCallError = [4, string, string, string, Record<string, unknown>];
+export type OcppMessage = OcppCall | OcppCallResult | OcppCallError;
+export type ConnectorStatus = "Available" | "Preparing" | "Charging" | "SuspendedEVSE" | "SuspendedEV" | "Finishing" | "Reserved" | "Unavailable" | "Faulted";
+export type ChargePointErrorCode = "ConnectorLockFailure" | "EVCommunicationError" | "GroundFailure" | "HighTemperature" | "InternalError" | "LocalListConflict" | "NoError" | "OtherError" | "OverCurrentFailure" | "PowerMeterFailure" | "PowerSwitchFailure" | "ReaderFailure" | "ResetFailure" | "UnderVoltage" | "OverVoltage" | "WeakSignal";
+export type AvailabilityType = "Operative" | "Inoperative";
+export type RegistrationStatus = "Accepted" | "Pending" | "Rejected";
+export type DiagnosticsStatus = "Idle" | "Uploaded" | "UploadFailed" | "Uploading";
+export type FirmwareStatus = "Downloaded" | "DownloadFailed" | "Downloading" | "Idle" | "InstallationFailed" | "Installing" | "Installed";
+export type StopReason = "EmergencyStop" | "EVDisconnected" | "HardReset" | "Local" | "Other" | "PowerLoss" | "Reboot" | "Remote" | "SoftReset" | "UnlockCommand" | "DeAuthorized";
+export interface CallResponse {
+    messageId: string;
+    payload: Record<string, unknown>;
+}
+export interface CallErrorResponse {
+    messageId: string;
+    code: string;
+    description: string;
+    details: Record<string, unknown>;
+}
+export interface PendingCall {
+    action: string;
+    resolve: (response: CallResponse) => void;
+    reject: (error: Error) => void;
+    timeout: NodeJS.Timeout;
+}
+export interface StationConfig {
+    centralSystemUrl: string;
+    chargePointId: string;
+    vendor: string;
+    model: string;
+    connectorId: number;
+    connectorCount: number;
+    heartbeatIntervalSeconds: number;
+    persistState: boolean;
+    stateDirectory?: string;
+    webSocketSubprotocol: string;
+    webSocketPingIntervalSeconds: number;
+    webSocketReconnectEnabled: boolean;
+    webSocketReconnectInitialDelayMs: number;
+    webSocketReconnectMaxDelayMs: number;
+    webSocketReconnectMaxAttempts: number;
+    callTimeoutMs: number;
+    tlsRejectUnauthorized: boolean;
+    tlsCaFile?: string;
+    tlsCertFile?: string;
+    tlsKeyFile?: string;
+    tlsServerName?: string;
+}
+export interface ConnectorState {
+    id: number;
+    status: ConnectorStatus;
+    availability: AvailabilityType;
+    errorCode: ChargePointErrorCode;
+    info?: string;
+    vendorId?: string;
+    vendorErrorCode?: string;
+    evConnected: boolean;
+    transactionId?: number;
+    transactionStartedAt?: string;
+    reservationId?: number;
+    reservationIdTag?: string;
+    reservationParentIdTag?: string;
+    reservationExpiryDate?: string;
+    lastIdTag?: string;
+    stopTransactionAtWh?: number;
+    pendingStartTransaction?: PendingStartTransaction;
+    pendingStopTransaction?: PendingStopTransaction;
+    meterWh: number;
+}
+export interface PendingStartTransaction {
+    connectorId: number;
+    idTag: string;
+    meterStart: number;
+    timestamp: string;
+    reservationId?: number;
+}
+export interface PendingStopTransaction {
+    meterStop: number;
+    timestamp: string;
+    reason: StopReason;
+    idTag?: string;
+    transactionData: Record<string, unknown>[];
+}
+export interface StationState {
+    connected: boolean;
+    booted: boolean;
+    registrationStatus: RegistrationStatus | "Unknown";
+    connectorStatus: ConnectorStatus;
+    availability: AvailabilityType;
+    transactionId?: number;
+    reservationId?: number;
+    localListVersion: number;
+    meterWh: number;
+    connectors: ConnectorState[];
+    diagnosticsStatus?: DiagnosticsStatus;
+    firmwareStatus?: FirmwareStatus;
+    lastHeartbeatAt?: Date;
+}
+export interface LogEntry {
+    at: Date;
+    level: "info" | "success" | "warn" | "error" | "in" | "out";
+    message: string;
+    details?: string;
+}

package/dist/ocpp/types.js

@@ -0,0 +1 @@
+export {};

package/dist/station/authorization.d.ts

@@ -0,0 +1,20 @@
+export type IdTagStatus = "Accepted" | "Blocked" | "Expired" | "Invalid" | "ConcurrentTx";
+export interface IdTagInfo {
+    status: IdTagStatus;
+    expiryDate?: string;
+    parentIdTag?: string;
+}
+export interface AuthorizationDecision {
+    accepted: boolean;
+    idTagInfo: IdTagInfo;
+    source: "CentralSystem" | "LocalList" | "AuthorizationCache" | "OfflineUnknown" | "None";
+}
+export declare function authorizeLocally(idTag: string, requireOfflinePermission: boolean, localAuthorizationList: Map<string, Record<string, unknown> | undefined>, authorizationCache: Map<string, Record<string, unknown> | undefined>, configuration: {
+    localAuthListEnabled: boolean;
+    localAuthorizeOffline: boolean;
+    authorizationCacheEnabled: boolean;
+    allowOfflineTxForUnknownId: boolean;
+}): AuthorizationDecision;
+export declare function normalizeIdTagInfo(value: Record<string, unknown> | undefined): IdTagInfo;
+export declare function serializeIdTagInfo(idTagInfo: IdTagInfo): Record<string, unknown>;
+export declare function isAcceptedIdTagInfo(idTagInfo: IdTagInfo): boolean;

package/dist/station/authorization.js

@@ -0,0 +1,78 @@
+export function authorizeLocally(idTag, requireOfflinePermission, localAuthorizationList, authorizationCache, configuration) {
+    if (requireOfflinePermission && !configuration.localAuthorizeOffline) {
+        return {
+            accepted: false,
+            idTagInfo: { status: "Invalid" },
+            source: "None"
+        };
+    }
+    const localListInfo = localAuthorizationList.get(idTag);
+    if (configuration.localAuthListEnabled && localAuthorizationList.has(idTag)) {
+        const idTagInfo = normalizeIdTagInfo(localListInfo);
+        return {
+            accepted: isAcceptedIdTagInfo(idTagInfo),
+            idTagInfo,
+            source: "LocalList"
+        };
+    }
+    if (configuration.authorizationCacheEnabled && authorizationCache.has(idTag)) {
+        const idTagInfo = normalizeIdTagInfo(authorizationCache.get(idTag));
+        return {
+            accepted: isAcceptedIdTagInfo(idTagInfo),
+            idTagInfo,
+            source: "AuthorizationCache"
+        };
+    }
+    if (requireOfflinePermission && configuration.allowOfflineTxForUnknownId) {
+        return {
+            accepted: true,
+            idTagInfo: { status: "Accepted" },
+            source: "OfflineUnknown"
+        };
+    }
+    return {
+        accepted: false,
+        idTagInfo: { status: "Invalid" },
+        source: "None"
+    };
+}
+export function normalizeIdTagInfo(value) {
+    const status = readIdTagStatus(value?.status, "Accepted");
+    const expiryDate = readOptionalString(value?.expiryDate);
+    const parentIdTag = readOptionalString(value?.parentIdTag);
+    const idTagInfo = {
+        status: expiryDate && Date.parse(expiryDate) <= Date.now() ? "Expired" : status
+    };
+    if (expiryDate) {
+        idTagInfo.expiryDate = expiryDate;
+    }
+    if (parentIdTag) {
+        idTagInfo.parentIdTag = parentIdTag;
+    }
+    return idTagInfo;
+}
+export function serializeIdTagInfo(idTagInfo) {
+    const output = { status: idTagInfo.status };
+    if (idTagInfo.expiryDate) {
+        output.expiryDate = idTagInfo.expiryDate;
+    }
+    if (idTagInfo.parentIdTag) {
+        output.parentIdTag = idTagInfo.parentIdTag;
+    }
+    return output;
+}
+export function isAcceptedIdTagInfo(idTagInfo) {
+    return idTagInfo.status === "Accepted";
+}
+function readIdTagStatus(value, fallback) {
+    return value === "Accepted" ||
+        value === "Blocked" ||
+        value === "Expired" ||
+        value === "Invalid" ||
+        value === "ConcurrentTx"
+        ? value
+        : fallback;
+}
+function readOptionalString(value) {
+    return typeof value === "string" ? value : undefined;
+}

package/dist/station/charging-profile-registry.d.ts

@@ -0,0 +1,18 @@
+import { type ChargingProfileEntry } from "./smart-charging.js";
+export declare class ChargingProfileRegistry {
+    private readonly profiles;
+    get length(): number;
+    entries(): ChargingProfileEntry[];
+    replace(entries: ChargingProfileEntry[]): void;
+    set(connectorId: number, profilePayload: unknown, options: {
+        hasConnector: (id: number) => boolean;
+        transactionIdForConnector: (id: number) => number | undefined;
+    }): "Accepted" | "Rejected";
+    clear(payload: Record<string, unknown>): "Accepted" | "Unknown";
+    clearForTransaction(transactionId: number): boolean;
+    pruneExpired(at?: Date): boolean;
+    compositeSchedulePayload(payload: Record<string, unknown>, transactionId: number | undefined, transactionStartedAt?: string): {
+        payload: Record<string, unknown>;
+        prunedExpired: boolean;
+    } | undefined;
+}

package/dist/station/charging-profile-registry.js

@@ -0,0 +1,125 @@
+import { canStoreChargingProfile, effectiveChargingProfiles, isChargingProfileExpired, limitTransitionOffsets, matchesChargingProfileFilter, periodAt, readChargingProfile, readChargingRateUnit } from "./smart-charging.js";
+import { readNumber } from "./payload.js";
+export class ChargingProfileRegistry {
+    profiles = [];
+    get length() {
+        return this.profiles.length;
+    }
+    entries() {
+        return [...this.profiles];
+    }
+    replace(entries) {
+        this.profiles.splice(0, this.profiles.length, ...entries);
+    }
+    set(connectorId, profilePayload, options) {
+        const profile = readChargingProfile(profilePayload);
+        if (!profile || !canStoreChargingProfile(connectorId, profile, options)) {
+            return "Rejected";
+        }
+        const existingIndex = this.profiles.findIndex((entry) => entry.profile.chargingProfileId === profile.chargingProfileId);
+        if (existingIndex >= 0) {
+            this.profiles.splice(existingIndex, 1);
+        }
+        this.profiles.push({ connectorId, profile });
+        return "Accepted";
+    }
+    clear(payload) {
+        this.pruneExpired();
+        const before = this.profiles.length;
+        const remaining = this.profiles.filter((entry) => !matchesChargingProfileFilter(entry, payload));
+        this.profiles.splice(0, this.profiles.length, ...remaining);
+        return before - this.profiles.length > 0 ? "Accepted" : "Unknown";
+    }
+    clearForTransaction(transactionId) {
+        const before = this.profiles.length;
+        const remaining = this.profiles.filter((entry) => entry.profile.chargingProfilePurpose !== "TxProfile" || entry.profile.transactionId !== transactionId);
+        this.profiles.splice(0, this.profiles.length, ...remaining);
+        return this.profiles.length !== before;
+    }
+    pruneExpired(at = new Date()) {
+        const before = this.profiles.length;
+        const remaining = this.profiles.filter((entry) => !isChargingProfileExpired(entry.profile, at));
+        this.profiles.splice(0, this.profiles.length, ...remaining);
+        return this.profiles.length !== before;
+    }
+    compositeSchedulePayload(payload, transactionId, transactionStartedAt) {
+        const prunedExpired = this.pruneExpired();
+        const connectorId = readNumber(payload.connectorId, -1);
+        const duration = readNumber(payload.duration, 0);
+        const requestedUnit = readChargingRateUnit(payload.chargingRateUnit);
+        if (duration <= 0) {
+            return undefined;
+        }
+        const scheduleStart = new Date();
+        const defaultUnit = requestedUnit ?? effectiveChargingProfiles(this.profiles, connectorId, transactionId, scheduleStart)[0]?.profile.chargingSchedule.chargingRateUnit ?? "A";
+        const unit = defaultUnit;
+        const relativeStart = transactionStartedAt ? new Date(transactionStartedAt) : undefined;
+        const composite = compositeSchedule(this.profiles, connectorId, transactionId, unit, scheduleStart, duration, relativeStart);
+        if (composite.chargingSchedulePeriod.length === 0) {
+            return undefined;
+        }
+        const chargingSchedule = {
+            duration,
+            startSchedule: scheduleStart.toISOString(),
+            chargingRateUnit: unit,
+            chargingSchedulePeriod: composite.chargingSchedulePeriod
+        };
+        if (composite.minChargingRate !== undefined) {
+            chargingSchedule.minChargingRate = composite.minChargingRate;
+        }
+        return {
+            prunedExpired,
+            payload: {
+                status: "Accepted",
+                connectorId,
+                scheduleStart: scheduleStart.toISOString(),
+                chargingSchedule
+            }
+        };
+    }
+}
+function compositeSchedule(entries, connectorId, transactionId, unit, scheduleStart, duration, relativeStart) {
+    const offsets = new Set([0]);
+    const unitEntries = entries.filter((entry) => entry.profile.chargingSchedule.chargingRateUnit === unit);
+    for (const entry of unitEntries) {
+        for (const offset of limitTransitionOffsets(entry.profile, scheduleStart, duration, relativeStart)) {
+            offsets.add(offset);
+        }
+    }
+    let minChargingRate;
+    const chargingSchedulePeriod = [...offsets]
+        .sort((left, right) => left - right)
+        .map((offset) => {
+        const at = new Date(scheduleStart.getTime() + offset * 1000);
+        const activeProfiles = effectiveChargingProfiles(unitEntries, connectorId, transactionId, at, unit);
+        const activePeriods = activeProfiles
+            .map((entry) => ({ entry, period: periodAt(entry.profile, at, relativeStart, scheduleStart) }))
+            .filter((item) => item.period !== undefined);
+        for (const { entry } of activePeriods) {
+            const profileMin = entry.profile.chargingSchedule.minChargingRate;
+            if (profileMin !== undefined) {
+                minChargingRate = minChargingRate === undefined ? profileMin : Math.max(minChargingRate, profileMin);
+            }
+        }
+        if (activePeriods.length === 0) {
+            return undefined;
+        }
+        const limit = Math.min(...activePeriods.map(({ period }) => period.limit));
+        const limitingPhases = activePeriods
+            .filter(({ period }) => period.limit === limit)
+            .map(({ period }) => period.numberPhases)
+            .filter((numberPhases) => typeof numberPhases === "number" && Number.isFinite(numberPhases));
+        const period = { startPeriod: offset, limit };
+        if (limitingPhases.length > 0) {
+            period.numberPhases = Math.min(...limitingPhases);
+        }
+        return period;
+    })
+        .filter((period) => period !== undefined);
+    return {
+        chargingSchedulePeriod: chargingSchedulePeriod.filter((period, index) => index === 0 ||
+            period.limit !== chargingSchedulePeriod[index - 1]?.limit ||
+            period.numberPhases !== chargingSchedulePeriod[index - 1]?.numberPhases),
+        minChargingRate
+    };
+}

package/dist/station/configuration-commands.d.ts

@@ -0,0 +1,11 @@
+import type { ConfigurationRegistry } from "./configuration-registry.js";
+export interface ChangeConfigurationResult {
+    status: "Accepted" | "Rejected" | "NotSupported";
+    key: string;
+    value: string;
+}
+export declare function changeConfiguration(configuration: ConfigurationRegistry, payload: Record<string, unknown>): ChangeConfigurationResult;
+export declare function getConfiguration(configuration: ConfigurationRegistry, payload: Record<string, unknown>): {
+    configurationKey: Record<string, unknown>[];
+    unknownKey: string[];
+};

package/dist/station/configuration-commands.js

@@ -0,0 +1,29 @@
+import { readString } from "./payload.js";
+export function changeConfiguration(configuration, payload) {
+    const key = readString(payload.key, "");
+    const value = readString(payload.value, "");
+    const existing = configuration.get(key);
+    if (!existing) {
+        return { status: "NotSupported", key, value };
+    }
+    if (existing.readonly || (existing.validate && !existing.validate(value))) {
+        return { status: "Rejected", key, value };
+    }
+    configuration.setValue(key, value);
+    return { status: "Accepted", key, value };
+}
+export function getConfiguration(configuration, payload) {
+    const requestedKeys = Array.isArray(payload.key) ? payload.key.filter((key) => typeof key === "string") : [];
+    const keys = requestedKeys.length > 0 ? requestedKeys : configuration.keys();
+    const configurationKey = [];
+    const unknownKey = [];
+    for (const key of keys) {
+        const entry = configuration.get(key);
+        if (!entry) {
+            unknownKey.push(key);
+            continue;
+        }
+        configurationKey.push({ key, readonly: entry.readonly, value: entry.value });
+    }
+    return { configurationKey, unknownKey };
+}

package/dist/station/configuration-registry.d.ts

@@ -0,0 +1,13 @@
+import type { StationConfig } from "../ocpp/types.js";
+import { type ConfigurationKey } from "./configuration.js";
+import { type Measurand, type MeteringConfigurationKey } from "./metering.js";
+export declare class ConfigurationRegistry {
+    readonly values: Map<string, ConfigurationKey>;
+    constructor(config: StationConfig);
+    get(key: string): ConfigurationKey | undefined;
+    keys(): string[];
+    setValue(key: string, value: string): void;
+    boolean(key: string, fallback: boolean): boolean;
+    integer(key: string, fallback: number): number;
+    measurands(key: MeteringConfigurationKey): Measurand[];
+}

package/dist/station/configuration-registry.js

@@ -0,0 +1,39 @@
+import { createDefaultConfiguration } from "./configuration.js";
+import { readConfiguredMeasurands } from "./metering.js";
+export class ConfigurationRegistry {
+    values;
+    constructor(config) {
+        this.values = createDefaultConfiguration(config);
+    }
+    get(key) {
+        return this.values.get(key);
+    }
+    keys() {
+        return [...this.values.keys()];
+    }
+    setValue(key, value) {
+        const existing = this.values.get(key);
+        if (!existing) {
+            return;
+        }
+        this.values.set(key, { ...existing, value });
+    }
+    boolean(key, fallback) {
+        const value = this.values.get(key)?.value;
+        if (value === undefined) {
+            return fallback;
+        }
+        return value.toLowerCase() === "true";
+    }
+    integer(key, fallback) {
+        const value = this.values.get(key)?.value;
+        if (value === undefined) {
+            return fallback;
+        }
+        const parsed = Number.parseInt(value, 10);
+        return Number.isSafeInteger(parsed) ? parsed : fallback;
+    }
+    measurands(key) {
+        return readConfiguredMeasurands(this.values.get(key)?.value);
+    }
+}

package/dist/station/configuration.d.ts

@@ -0,0 +1,7 @@
+import type { StationConfig } from "../ocpp/types.js";
+export interface ConfigurationKey {
+    readonly: boolean;
+    value: string;
+    validate?: (value: string) => boolean;
+}
+export declare function createDefaultConfiguration(config: StationConfig): Map<string, ConfigurationKey>;

package/dist/station/configuration.js

@@ -0,0 +1,88 @@
+import { DEFAULT_SAMPLED_DATA, isValidSampledDataConfiguration, MEASURANDS } from "./metering.js";
+const SUPPORTED_FEATURE_PROFILES = [
+    "Core",
+    "FirmwareManagement",
+    "LocalAuthListManagement",
+    "Reservation",
+    "RemoteTrigger",
+    "SmartCharging"
+];
+const CONNECTOR_PHASE_ROTATIONS = new Set([
+    "NotApplicable",
+    "Unknown",
+    "RST",
+    "RTS",
+    "SRT",
+    "STR",
+    "TRS",
+    "TSR"
+]);
+const DEFAULT_SAMPLED_DATA_CONFIGURATION = DEFAULT_SAMPLED_DATA.join(",");
+export function createDefaultConfiguration(config) {
+    const configuration = new Map();
+    const boolean = (value) => isBooleanConfigurationValue(value);
+    const nonNegativeInteger = (value) => isIntegerConfigurationValue(value, 0);
+    const positiveInteger = (value) => isIntegerConfigurationValue(value, 1);
+    const sampledData = (value) => isValidSampledDataConfiguration(value);
+    const set = (key, readonly, value, validate) => {
+        configuration.set(key, { readonly, value, validate });
+    };
+    set("AllowOfflineTxForUnknownId", false, "false", boolean);
+    set("AuthorizationCacheEnabled", false, "true", boolean);
+    set("AuthorizeRemoteTxRequests", false, "false", boolean);
+    set("BlinkRepeat", false, "0", nonNegativeInteger);
+    set("ChargePointModel", true, config.model);
+    set("ChargePointSerialNumber", true, config.chargePointId);
+    set("ChargePointVendor", true, config.vendor);
+    set("ClockAlignedDataInterval", false, "0", nonNegativeInteger);
+    set("ConnectionTimeOut", false, "60", positiveInteger);
+    set("ConnectorPhaseRotation", false, "Unknown", isConnectorPhaseRotationConfiguration);
+    set("ConnectorPhaseRotationMaxLength", true, String(Math.max(1, config.connectorCount)));
+    set("GetConfigurationMaxKeys", true, "50");
+    set("HeartbeatInterval", false, String(config.heartbeatIntervalSeconds), positiveInteger);
+    set("LightIntensity", false, "0", nonNegativeInteger);
+    set("LocalAuthListEnabled", false, "true", boolean);
+    set("LocalAuthListMaxLength", true, "1000");
+    set("LocalAuthorizeOffline", false, "false", boolean);
+    set("LocalPreAuthorize", false, "false", boolean);
+    set("MaxEnergyOnInvalidId", false, "0", nonNegativeInteger);
+    set("MeterValuesAlignedData", false, DEFAULT_SAMPLED_DATA_CONFIGURATION, sampledData);
+    set("MeterValuesAlignedDataMaxLength", true, String(MEASURANDS.size));
+    set("MeterValuesSampledData", false, DEFAULT_SAMPLED_DATA_CONFIGURATION, sampledData);
+    set("MeterValuesSampledDataMaxLength", true, String(MEASURANDS.size));
+    set("MeterValueSampleInterval", false, "60", nonNegativeInteger);
+    set("MinimumStatusDuration", false, "0", nonNegativeInteger);
+    set("NumberOfConnectors", true, String(config.connectorCount));
+    set("ResetRetries", false, "0", nonNegativeInteger);
+    set("SendLocalListMaxLength", true, "1000");
+    set("StopTransactionOnEVSideDisconnect", false, "true", boolean);
+    set("StopTransactionOnInvalidId", false, "false", boolean);
+    set("StopTxnAlignedData", false, DEFAULT_SAMPLED_DATA_CONFIGURATION, sampledData);
+    set("StopTxnAlignedDataMaxLength", true, String(MEASURANDS.size));
+    set("StopTxnSampledData", false, DEFAULT_SAMPLED_DATA_CONFIGURATION, sampledData);
+    set("StopTxnSampledDataMaxLength", true, String(MEASURANDS.size));
+    set("SupportedFeatureProfiles", true, SUPPORTED_FEATURE_PROFILES.join(","));
+    set("SupportedFeatureProfilesMaxLength", true, String(SUPPORTED_FEATURE_PROFILES.length));
+    set("TransactionMessageAttempts", false, "1", positiveInteger);
+    set("TransactionMessageRetryInterval", false, "30", positiveInteger);
+    set("UnlockConnectorOnEVSideDisconnect", false, "false", boolean);
+    set("WebSocketPingInterval", false, "0", nonNegativeInteger);
+    return configuration;
+}
+function isBooleanConfigurationValue(value) {
+    return value === "true" || value === "false";
+}
+function isIntegerConfigurationValue(value, minimum) {
+    if (!/^\d+$/.test(value)) {
+        return false;
+    }
+    const parsed = Number.parseInt(value, 10);
+    return Number.isSafeInteger(parsed) && parsed >= minimum;
+}
+function isConnectorPhaseRotationConfiguration(value) {
+    const items = value
+        .split(",")
+        .map((item) => item.trim())
+        .filter(Boolean);
+    return items.length > 0 && items.every((item) => CONNECTOR_PHASE_ROTATIONS.has(item));
+}

package/dist/station/connector-registry.d.ts

@@ -0,0 +1,25 @@
+import type { ConnectorState } from "../ocpp/types.js";
+export declare class ConnectorRegistry {
+    private readonly primaryConnectorId;
+    private readonly connectors;
+    private onChange?;
+    constructor(primaryConnectorId: number, count: number);
+    setOnChange(onChange: () => void): void;
+    get size(): number;
+    has(id: number): boolean;
+    get(id: number): ConnectorState;
+    find(id: number): ConnectorState | undefined;
+    all(): ConnectorState[];
+    add(): ConnectorState;
+    ensureCount(count: number): void;
+    patch(id: number, patch: Partial<ConnectorState>): void;
+    snapshot(): {
+        connectors: ConnectorState[];
+        primary?: ConnectorState;
+    };
+    findAvailable(): ConnectorState | undefined;
+    findByTransaction(transactionId: number): ConnectorState | undefined;
+    findByReservation(reservationId: number): ConnectorState | undefined;
+    private nextId;
+    private notifyChange;
+}

package/dist/station/connector-registry.js

@@ -0,0 +1,89 @@
+export class ConnectorRegistry {
+    primaryConnectorId;
+    connectors = new Map();
+    onChange;
+    constructor(primaryConnectorId, count) {
+        this.primaryConnectorId = primaryConnectorId;
+        const connectorCount = Math.max(validConnectorCount(count), primaryConnectorId);
+        for (let connectorId = 1; connectorId <= connectorCount; connectorId += 1) {
+            this.connectors.set(connectorId, createConnector(connectorId));
+        }
+    }
+    setOnChange(onChange) {
+        this.onChange = onChange;
+    }
+    get size() {
+        return this.connectors.size;
+    }
+    has(id) {
+        return this.connectors.has(id);
+    }
+    get(id) {
+        const connector = this.connectors.get(id);
+        if (!connector) {
+            throw new Error(`Connector ${id} does not exist`);
+        }
+        return connector;
+    }
+    find(id) {
+        return this.connectors.get(id);
+    }
+    all() {
+        return [...this.connectors.values()].sort((left, right) => left.id - right.id);
+    }
+    add() {
+        const connector = createConnector(this.nextId());
+        this.connectors.set(connector.id, connector);
+        this.notifyChange();
+        return connector;
+    }
+    ensureCount(count) {
+        const initialSize = this.connectors.size;
+        while (this.connectors.size < count) {
+            const connector = createConnector(this.nextId());
+            this.connectors.set(connector.id, connector);
+        }
+        if (this.connectors.size !== initialSize) {
+            this.notifyChange();
+        }
+    }
+    patch(id, patch) {
+        Object.assign(this.get(id), patch);
+        this.notifyChange();
+    }
+    snapshot() {
+        const connectors = this.all().map((connector) => ({ ...connector }));
+        const primary = this.connectors.get(this.primaryConnectorId) ?? connectors[0];
+        return { connectors, primary };
+    }
+    findAvailable() {
+        return this.all().find((connector) => !connector.transactionId &&
+            connector.availability === "Operative" &&
+            connector.status === "Available");
+    }
+    findByTransaction(transactionId) {
+        return this.all().find((connector) => connector.transactionId === transactionId);
+    }
+    findByReservation(reservationId) {
+        return this.all().find((connector) => connector.reservationId === reservationId);
+    }
+    nextId() {
+        return Math.max(0, ...this.connectors.keys()) + 1;
+    }
+    notifyChange() {
+        this.onChange?.();
+    }
+}
+function validConnectorCount(count) {
+    return Number.isInteger(count) && count > 0 ? count : 1;
+}
+function createConnector(id) {
+    return {
+        id,
+        status: "Available",
+        availability: "Operative",
+        errorCode: "NoError",
+        evConnected: false,
+        meterWh: 0
+    };
+}

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

@@ -0,0 +1,7 @@
+import type { AvailabilityType, ChargePointErrorCode, ConnectorState, ConnectorStatus } from "../ocpp/types.js";
+export declare const CONNECTOR_STATUS_SEQUENCE: ConnectorStatus[];
+export declare function nextConnectorStatus(status: ConnectorStatus): ConnectorStatus;
+export declare function faultErrorCode(connector: ConnectorState): ChargePointErrorCode;
+export declare function statusAfterReservationClear(connector: ConnectorState): ConnectorStatus;
+export declare function statusAfterFaultClear(connector: ConnectorState): ConnectorStatus;
+export declare function statusAfterAvailabilityChange(connector: ConnectorState, availability: AvailabilityType): ConnectorStatus;