})
}
if (r.attributeStatus === GetVariableStatusEnumType.Accepted) {
- const entry = grouped.get(key)
- if (entry) {
- entry.attributes.push({
+ const variableGroupEntry = grouped.get(key)
+ if (variableGroupEntry) {
+ variableGroupEntry.attributes.push({
type: r.attributeType ?? AttributeEnumType.Actual,
value: r.attributeValue,
})
connectorId: number,
interval: number
): void {
- const connector = chargingStation.getConnectorStatus(connectorId)
- if (connector == null) {
+ const initialConnectorStatus = chargingStation.getConnectorStatus(connectorId)
+ if (initialConnectorStatus == null) {
logger.error(
`${chargingStation.logPrefix()} ${moduleName}.startPeriodicMeterValues: Connector ${connectorId.toString()} not found`
)
)
return
}
- if (connector.transactionMeterValuesSetInterval != null) {
+ if (initialConnectorStatus.transactionMeterValuesSetInterval != null) {
logger.warn(
`${chargingStation.logPrefix()} ${moduleName}.startPeriodicMeterValues: TxUpdatedInterval already started, stopping first`
)
OCPP20ServiceUtils.stopPeriodicMeterValues(chargingStation, connectorId)
}
- connector.transactionMeterValuesSetInterval = setInterval(() => {
+ initialConnectorStatus.transactionMeterValuesSetInterval = setInterval(() => {
const connectorStatus = chargingStation.getConnectorStatus(connectorId)
if (connectorStatus?.transactionStarted === true && connectorStatus.transactionId != null) {
if (
chargingStation: ChargingStation,
connectorId: number
): void {
- const connector = chargingStation.getConnectorStatus(connectorId)
- if (connector?.transactionMeterValuesSetInterval != null) {
- clearInterval(connector.transactionMeterValuesSetInterval)
- delete connector.transactionMeterValuesSetInterval
+ const connectorStatus = chargingStation.getConnectorStatus(connectorId)
+ if (connectorStatus?.transactionMeterValuesSetInterval != null) {
+ clearInterval(connectorStatus.transactionMeterValuesSetInterval)
+ delete connectorStatus.transactionMeterValuesSetInterval
logger.info(
`${chargingStation.logPrefix()} ${moduleName}.stopPeriodicMeterValues: TxUpdatedInterval stopped`
)
variableData.component.instance,
variableData.variable.name
)
- const entry = pairedBounds.get(varKey) ?? {}
+ const pairedBoundsEntry = pairedBounds.get(varKey) ?? {}
if (resolvedAttr === AttributeEnumType.MinSet) {
- entry.minValue = variableData.attributeValue
+ pairedBoundsEntry.minValue = variableData.attributeValue
} else {
- entry.maxValue = variableData.attributeValue
+ pairedBoundsEntry.maxValue = variableData.attributeValue
}
- pairedBounds.set(varKey, entry)
+ pairedBounds.set(varKey, pairedBoundsEntry)
}
// Pre-apply coherent MinSet/MaxSet pairs so per-item cross-check sees paired values
socMaximumValue: number,
debug: boolean
): void => {
- const connector = chargingStation.getConnectorStatus(connectorId)
+ const connectorStatus = chargingStation.getConnectorStatus(connectorId)
if (
convertToInt(sampledValue.value) > socMaximumValue ||
convertToInt(sampledValue.value) < socMinimumValue ||
`${chargingStation.logPrefix()} ${moduleName}.validateSocMeasurandValue: MeterValues measurand ${
sampledValue.measurand ?? MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER
// eslint-disable-next-line @typescript-eslint/restrict-template-expressions
- }: connector id ${connectorId.toString()}, transaction id ${connector?.transactionId?.toString()}, value: ${socMinimumValue.toString()}/${sampledValue.value.toString()}/${socMaximumValue.toString()}`
+ }: connector id ${connectorId.toString()}, transaction id ${connectorStatus?.transactionId?.toString()}, value: ${socMinimumValue.toString()}/${sampledValue.value.toString()}/${socMaximumValue.toString()}`
)
}
}
}
const updateConnectorEnergyValues = (
- connector: ConnectorStatus | undefined,
+ connectorStatus: ConnectorStatus | undefined,
energyValue: number
): void => {
- if (connector != null) {
+ if (connectorStatus != null) {
if (
- connector.energyActiveImportRegisterValue != null &&
- connector.energyActiveImportRegisterValue >= 0 &&
- connector.transactionEnergyActiveImportRegisterValue != null &&
- connector.transactionEnergyActiveImportRegisterValue >= 0
+ connectorStatus.energyActiveImportRegisterValue != null &&
+ connectorStatus.energyActiveImportRegisterValue >= 0 &&
+ connectorStatus.transactionEnergyActiveImportRegisterValue != null &&
+ connectorStatus.transactionEnergyActiveImportRegisterValue >= 0
) {
- connector.energyActiveImportRegisterValue += energyValue
- connector.transactionEnergyActiveImportRegisterValue += energyValue
+ connectorStatus.energyActiveImportRegisterValue += energyValue
+ connectorStatus.transactionEnergyActiveImportRegisterValue += energyValue
} else {
- connector.energyActiveImportRegisterValue = 0
- connector.transactionEnergyActiveImportRegisterValue = 0
+ connectorStatus.energyActiveImportRegisterValue = 0
+ connectorStatus.transactionEnergyActiveImportRegisterValue = 0
}
}
}
debug: boolean
): void => {
if (energyValue > maxValue || energyValue < minValue || debug) {
- const connector = chargingStation.getConnectorStatus(connectorId)
+ const connectorStatus = chargingStation.getConnectorStatus(connectorId)
logger.error(
`${chargingStation.logPrefix()} ${moduleName}.validateEnergyMeasurandValue: MeterValues measurand ${
sampledValue.measurand ?? MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER
// eslint-disable-next-line @typescript-eslint/restrict-template-expressions
- }: connector id ${connectorId.toString()}, transaction id ${connector?.transactionId?.toString()}, value: ${minValue.toString()}/${energyValue.toString()}/${maxValue.toString()}, duration: ${interval.toString()}ms`
+ }: connector id ${connectorId.toString()}, transaction id ${connectorStatus?.transactionId?.toString()}, value: ${minValue.toString()}/${energyValue.toString()}/${maxValue.toString()}, duration: ${interval.toString()}ms`
)
}
}
const validatePowerMeasurandValue = (
chargingStation: ChargingStation,
connectorId: number,
- connector: ConnectorStatus | undefined,
+ connectorStatus: ConnectorStatus | undefined,
sampledValue: SampledValue,
connectorMaximumPower: number,
connectorMinimumPower: number,
`${chargingStation.logPrefix()} ${moduleName}.validatePowerMeasurandValue: MeterValues measurand ${
sampledValue.measurand ?? MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER
// eslint-disable-next-line @typescript-eslint/restrict-template-expressions
- }: connector id ${connectorId.toString()}, transaction id ${connector?.transactionId?.toString()}, value: ${connectorMinimumPower.toString()}/${sampledValue.value.toString()}/${connectorMaximumPower.toString()}`
+ }: connector id ${connectorId.toString()}, transaction id ${connectorStatus?.transactionId?.toString()}, value: ${connectorMinimumPower.toString()}/${sampledValue.value.toString()}/${connectorMaximumPower.toString()}`
)
}
}
const validateCurrentMeasurandValue = (
chargingStation: ChargingStation,
connectorId: number,
- connector: ConnectorStatus | undefined,
+ connectorStatus: ConnectorStatus | undefined,
sampledValue: SampledValue,
connectorMaximumAmperage: number,
connectorMinimumAmperage: number,
`${chargingStation.logPrefix()} ${moduleName}.validateCurrentMeasurandValue: MeterValues measurand ${
sampledValue.measurand ?? MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER
// eslint-disable-next-line @typescript-eslint/restrict-template-expressions
- }: connector id ${connectorId.toString()}, transaction id ${connector?.transactionId?.toString()}, value: ${connectorMinimumAmperage.toString()}/${sampledValue.value.toString()}/${connectorMaximumAmperage.toString()}`
+ }: connector id ${connectorId.toString()}, transaction id ${connectorStatus?.transactionId?.toString()}, value: ${connectorMinimumAmperage.toString()}/${sampledValue.value.toString()}/${connectorMaximumAmperage.toString()}`
)
}
}
const validateCurrentMeasurandPhaseValue = (
chargingStation: ChargingStation,
connectorId: number,
- connector: ConnectorStatus | undefined,
+ connectorStatus: ConnectorStatus | undefined,
sampledValue: SampledValue,
connectorMaximumAmperage: number,
connectorMinimumAmperage: number,
// eslint-disable-next-line @typescript-eslint/restrict-template-expressions
sampledValue.phase
// eslint-disable-next-line @typescript-eslint/restrict-template-expressions
- }, connector id ${connectorId.toString()}, transaction id ${connector?.transactionId?.toString()}, value: ${connectorMinimumAmperage.toString()}/${sampledValue.value.toString()}/${connectorMaximumAmperage.toString()}`
+ }, connector id ${connectorId.toString()}, transaction id ${connectorStatus?.transactionId?.toString()}, value: ${connectorMinimumAmperage.toString()}/${sampledValue.value.toString()}/${connectorMaximumAmperage.toString()}`
)
}
}
RequestCommand.METER_VALUES
)
}
- const connector = chargingStation.getConnectorStatus(connectorId)
+ const connectorStatus = chargingStation.getConnectorStatus(connectorId)
const meterValue = buildEmptyMeterValue() as OCPP16MeterValue
const buildVersionedSampledValue = (
sampledValueTemplate: SampledValueTemplate,
validatePowerMeasurandValue(
chargingStation,
connectorId,
- connector,
+ connectorStatus,
meterValue.sampledValue[sampledValuesIndex],
connectorMaximumPower / unitDivider,
connectorMinimumPower / unitDivider,
validatePowerMeasurandValue(
chargingStation,
connectorId,
- connector,
+ connectorStatus,
meterValue.sampledValue[sampledValuesPerPhaseIndex],
connectorMaximumPowerPerPhase / unitDivider,
connectorMinimumPowerPerPhase / unitDivider,
validateCurrentMeasurandValue(
chargingStation,
connectorId,
- connector,
+ connectorStatus,
meterValue.sampledValue[sampledValuesIndex],
connectorMaximumAmperage,
connectorMinimumAmperage,
validateCurrentMeasurandPhaseValue(
chargingStation,
connectorId,
- connector,
+ connectorStatus,
meterValue.sampledValue[sampledValuesPerPhaseIndex],
connectorMaximumAmperage,
connectorMinimumAmperage,
// Energy.Active.Import.Register measurand (default)
const energyMeasurand = buildEnergyMeasurandValue(chargingStation, connectorId, interval)
if (energyMeasurand != null) {
- updateConnectorEnergyValues(connector, energyMeasurand.value)
+ updateConnectorEnergyValues(connectorStatus, energyMeasurand.value)
const unitDivider =
energyMeasurand.template.unit === MeterValueUnit.KILO_WATT_HOUR ? 1000 : 1
const energySampledValue = buildVersionedSampledValue(
RequestCommand.METER_VALUES
)
}
- const connector = chargingStation.getConnectorStatus(connectorId)
+ const connectorStatus = chargingStation.getConnectorStatus(connectorId)
const meterValue = buildEmptyMeterValue() as OCPP20MeterValue
const buildVersionedSampledValue = (
sampledValueTemplate: SampledValueTemplate,
evseId
)
if (energyMeasurand != null) {
- updateConnectorEnergyValues(connector, energyMeasurand.value)
+ updateConnectorEnergyValues(connectorStatus, energyMeasurand.value)
const unitDivider =
energyMeasurand.template.unit === MeterValueUnit.KILO_WATT_HOUR ? 1000 : 1
const energySampledValue = buildVersionedSampledValue(
return undefined
}
- const entry = this.cache.get(identifier)
+ const authCacheEntry = this.cache.get(identifier)
// Cache miss
- if (!entry) {
+ if (!authCacheEntry) {
this.stats.misses++
return undefined
}
// Check expiration
const now = Date.now()
- if (now >= entry.expiresAt) {
+ if (now >= authCacheEntry.expiresAt) {
this.stats.expired++
// Transition to EXPIRED status instead of deleting (C10.FR.08)
- entry.result = { ...entry.result, status: AuthorizationStatus.EXPIRED }
+ authCacheEntry.result = { ...authCacheEntry.result, status: AuthorizationStatus.EXPIRED }
// Apply absolute lifetime cap to expired-transition TTL refresh (default-TTL entries only)
- if (!entry.hasExplicitTtl) {
- const absoluteDeadline = entry.createdAt + this.maxAbsoluteLifetimeMs
+ if (!authCacheEntry.hasExplicitTtl) {
+ const absoluteDeadline = authCacheEntry.createdAt + this.maxAbsoluteLifetimeMs
if (absoluteDeadline > now) {
- entry.expiresAt = Math.min(now + this.defaultTtl * 1000, absoluteDeadline)
+ authCacheEntry.expiresAt = Math.min(now + this.defaultTtl * 1000, absoluteDeadline)
}
}
this.lruOrder.set(identifier, now)
logger.debug(
`${moduleName}: Expired entry transitioned to EXPIRED for identifier: ${truncateId(identifier)}`
)
- return entry.result
+ return authCacheEntry.result
}
// Cache hit - update LRU order and reset TTL (C10.FR.08)
// Reset TTL on access for default-TTL entries only; explicit TTL entries (e.g. CSMS
// cacheExpiryDateTime) keep their original expiration per OCPP spec.
- if (!entry.hasExplicitTtl && entry.createdAt + this.maxAbsoluteLifetimeMs > now) {
- entry.expiresAt = now + this.defaultTtl * 1000
+ if (
+ !authCacheEntry.hasExplicitTtl &&
+ authCacheEntry.createdAt + this.maxAbsoluteLifetimeMs > now
+ ) {
+ authCacheEntry.expiresAt = now + this.defaultTtl * 1000
}
logger.debug(`${moduleName}: Cache hit for identifier: ${truncateId(identifier)}`)
- return entry.result
+ return authCacheEntry.result
}
/**
this.stats.rateLimitChecks++
const now = Date.now()
- const entry = this.rateLimits.get(identifier)
+ const rateLimitEntry = this.rateLimits.get(identifier)
// No existing entry - create one
- if (!entry) {
+ if (!rateLimitEntry) {
this.rateLimits.set(identifier, { count: 1, windowStart: now })
this.boundRateLimitsMap()
return true
}
// Check if window has expired
- const windowExpired = now - entry.windowStart >= this.rateLimit.windowMs
+ const windowExpired = now - rateLimitEntry.windowStart >= this.rateLimit.windowMs
if (windowExpired) {
// Reset window
- entry.count = 1
- entry.windowStart = now
+ rateLimitEntry.count = 1
+ rateLimitEntry.windowStart = now
return true
}
// Within window - check count
- if (entry.count >= this.rateLimit.maxRequests) {
+ if (rateLimitEntry.count >= this.rateLimit.maxRequests) {
// Rate limit exceeded
return false
}
// Increment count
- entry.count++
+ rateLimitEntry.count++
return true
}
let candidateTime = Number.POSITIVE_INFINITY
for (const [identifier, accessTime] of this.lruOrder.entries()) {
- const entry = this.cache.get(identifier)
- if (entry?.result.status !== AuthorizationStatus.ACCEPTED && accessTime < candidateTime) {
+ const authCacheEntry = this.cache.get(identifier)
+ if (
+ authCacheEntry?.result.status !== AuthorizationStatus.ACCEPTED &&
+ accessTime < candidateTime
+ ) {
candidateTime = accessTime
candidateIdentifier = identifier
}
: 0
// Get rate limiting stats from cache via remote strategy
- let rateLimitStats:
+ let rateLimitStatistics:
| undefined
| { blockedRequests: number; rateLimitedIdentifiers: number; totalChecks: number }
const remoteStrategy = this.strategies.get('remote')
if (remoteStrategy?.getStats) {
- const strategyStats = await remoteStrategy.getStats()
- if ('cache' in strategyStats) {
- const cacheStats = strategyStats.cache as {
+ const strategyStatistics = await remoteStrategy.getStats()
+ if ('cache' in strategyStatistics) {
+ const cacheStatistics = strategyStatistics.cache as {
rateLimit?: {
blockedRequests: number
rateLimitedIdentifiers: number
totalChecks: number
}
}
- rateLimitStats = cacheStats.rateLimit
+ rateLimitStatistics = cacheStatistics.rateLimit
}
}
failedAuth: this.metrics.failedAuth,
lastUpdatedDate: this.metrics.lastReset,
localUsageRate: Math.round(localUsageRate * 10000) / 100,
- rateLimit: rateLimitStats,
+ rateLimit: rateLimitStatistics,
remoteSuccessRate: Math.round(remoteSuccessRate * 10000) / 100,
successfulAuth: this.metrics.successfulAuth,
totalRequests: this.metrics.totalRequests,
*/
public updateConfiguration (config: Partial<AuthConfiguration>): void {
// Merge new config with existing
- const newConfig = { ...this.config, ...config }
+ const newConfiguration = { ...this.config, ...config }
// Validate merged configuration
- AuthConfigValidator.validate(newConfig)
+ AuthConfigValidator.validate(newConfiguration)
// Apply validated configuration
- this.config = newConfig
+ this.config = newConfiguration
logger.info(
`${this.chargingStation.logPrefix()} ${moduleName}.updateConfiguration: Authentication configuration updated`
* @returns Strategy statistics including hit rates, request counts, and cache status
*/
public getStats (): JsonObject {
- const cacheStats = this.authCache ? this.authCache.getStats() : null
+ const cacheStatistics = this.authCache ? this.authCache.getStats() : null
return {
...this.stats,
cacheHitRate:
this.stats.totalRequests > 0 ? (this.stats.cacheHits / this.stats.totalRequests) * 100 : 0,
- cacheStats,
+ cacheStatistics,
hasAuthCache: !!this.authCache,
hasLocalAuthListManager: !!this.localAuthListManager,
isInitialized: this.isInitialized,
* @returns Strategy statistics including success rates, response times, and error counts
*/
public async getStats (): Promise<JsonObject> {
- const cacheStats = this.authCache ? this.authCache.getStats() : null
+ const cacheStatistics = this.authCache ? this.authCache.getStats() : null
let adapterAvailable = false
if (this.adapter) {
return {
...this.stats,
adapterAvailable,
- cacheStats,
+ cacheStatistics,
hasAdapter: this.adapter != null,
hasAuthCache: !!this.authCache,
isInitialized: this.isInitialized,
return false
}
- const authConfig = config as AuthConfiguration
+ const authConfiguration = config as AuthConfiguration
// Validate required boolean fields exist
if (
- typeof authConfig.authorizationCacheEnabled !== 'boolean' ||
- typeof authConfig.localAuthListEnabled !== 'boolean' ||
- typeof authConfig.offlineAuthorizationEnabled !== 'boolean' ||
- typeof authConfig.allowOfflineTxForUnknownId !== 'boolean' ||
- typeof authConfig.localPreAuthorize !== 'boolean' ||
- typeof authConfig.certificateAuthEnabled !== 'boolean'
+ typeof authConfiguration.authorizationCacheEnabled !== 'boolean' ||
+ typeof authConfiguration.localAuthListEnabled !== 'boolean' ||
+ typeof authConfiguration.offlineAuthorizationEnabled !== 'boolean' ||
+ typeof authConfiguration.allowOfflineTxForUnknownId !== 'boolean' ||
+ typeof authConfiguration.localPreAuthorize !== 'boolean' ||
+ typeof authConfiguration.certificateAuthEnabled !== 'boolean'
) {
return false
}
// Validate authorization timeout (required, must be positive)
- if (typeof authConfig.authorizationTimeout !== 'number' || authConfig.authorizationTimeout <= 0) {
+ if (
+ typeof authConfiguration.authorizationTimeout !== 'number' ||
+ authConfiguration.authorizationTimeout <= 0
+ ) {
return false
}
// Validate optional cache lifetime if provided
if (
- authConfig.authorizationCacheLifetime !== undefined &&
- (typeof authConfig.authorizationCacheLifetime !== 'number' ||
- authConfig.authorizationCacheLifetime < 0)
+ authConfiguration.authorizationCacheLifetime !== undefined &&
+ (typeof authConfiguration.authorizationCacheLifetime !== 'number' ||
+ authConfiguration.authorizationCacheLifetime < 0)
) {
return false
}
// Validate optional max cache entries if provided
if (
- authConfig.maxCacheEntries !== undefined &&
- (typeof authConfig.maxCacheEntries !== 'number' ||
- authConfig.maxCacheEntries < 1 ||
- !Number.isInteger(authConfig.maxCacheEntries))
+ authConfiguration.maxCacheEntries !== undefined &&
+ (typeof authConfiguration.maxCacheEntries !== 'number' ||
+ authConfiguration.maxCacheEntries < 1 ||
+ !Number.isInteger(authConfiguration.maxCacheEntries))
) {
return false
}
}
}
- const entry = trackedIps.get(ipAddress)
+ const ipRateLimitEntry = trackedIps.get(ipAddress)
- if (entry === undefined || now >= entry.resetTime) {
+ if (ipRateLimitEntry === undefined || now >= ipRateLimitEntry.resetTime) {
trackedIps.set(ipAddress, {
count: 1,
resetTime: now + windowMs,
return true
}
- if (entry.count < maxRequests) {
- entry.count++
+ if (ipRateLimitEntry.count < maxRequests) {
+ ipRateLimitEntry.count++
return true
}
const TAIL_BYTES = 65_536
const getLogFilePath = (configField: 'errorFile' | 'file', date?: string): string | undefined => {
- const logConfig = Configuration.getConfigurationSection<LogConfiguration>(
+ const logConfiguration = Configuration.getConfigurationSection<LogConfiguration>(
ConfigurationSection.log
)
- const relativePath = logConfig[configField]
+ const relativePath = logConfiguration[configField]
if (relativePath == null) {
return undefined
}
- if (logConfig.rotate !== true) {
+ if (logConfiguration.rotate !== true) {
return resolve(relativePath)
}
const now = new Date()
if (
Configuration.getConfigurationData()?.['supervisionURLs' as keyof ConfigurationData] != null
) {
- const configData = Configuration.getConfigurationData()
- if (configData != null) {
- configData.supervisionUrls = configData['supervisionURLs' as keyof ConfigurationData] as
- | string
- | string[]
+ const configurationData = Configuration.getConfigurationData()
+ if (configurationData != null) {
+ configurationData.supervisionUrls = configurationData[
+ 'supervisionURLs' as keyof ConfigurationData
+ ] as string | string[]
}
}
return Configuration.getConfigurationData()?.supervisionUrls
}
private static buildLogSection (): LogConfiguration {
- const configData = Configuration.getConfigurationData()
+ const configurationData = Configuration.getConfigurationData()
const deprecatedLogKeyMap: [keyof ConfigurationData, keyof LogConfiguration][] = [
['logEnabled', 'enabled'],
['logFile', 'file'],
]
const deprecatedLogConfiguration: Record<string, unknown> = {}
for (const [deprecatedKey, newKey] of deprecatedLogKeyMap) {
- if (has(deprecatedKey, configData)) {
- deprecatedLogConfiguration[newKey] = configData?.[deprecatedKey]
+ if (has(deprecatedKey, configurationData)) {
+ deprecatedLogConfiguration[newKey] = configurationData?.[deprecatedKey]
}
}
const logConfiguration: LogConfiguration = {
...defaultLogConfiguration,
...(deprecatedLogConfiguration as Partial<LogConfiguration>),
- ...(has(ConfigurationSection.log, configData) && configData?.log),
+ ...(has(ConfigurationSection.log, configurationData) && configurationData?.log),
}
return logConfiguration
}
}
private static buildWorkerSection (): WorkerConfiguration {
- const configData = Configuration.getConfigurationData()
+ const configurationData = Configuration.getConfigurationData()
const deprecatedWorkerKeyMap: [keyof ConfigurationData, keyof WorkerConfiguration][] = [
['workerProcess', 'processType'],
['workerStartDelay', 'startDelay'],
]
const deprecatedWorkerConfiguration: Record<string, unknown> = {}
for (const [deprecatedKey, newKey] of deprecatedWorkerKeyMap) {
- if (has(deprecatedKey, configData)) {
- deprecatedWorkerConfiguration[newKey] = configData?.[deprecatedKey]
+ if (has(deprecatedKey, configurationData)) {
+ deprecatedWorkerConfiguration[newKey] = configurationData?.[deprecatedKey]
}
}
- if (has('elementStartDelay', configData?.worker)) {
+ if (has('elementStartDelay', configurationData?.worker)) {
// eslint-disable-next-line @typescript-eslint/no-deprecated -- intentional deprecated key migration
- deprecatedWorkerConfiguration.elementAddDelay = configData?.worker?.elementStartDelay
+ deprecatedWorkerConfiguration.elementAddDelay = configurationData?.worker?.elementStartDelay
}
- if (configData != null) {
+ if (configurationData != null) {
// eslint-disable-next-line @typescript-eslint/no-deprecated -- intentional deprecated key removal
- delete configData.workerPoolStrategy
+ delete configurationData.workerPoolStrategy
}
const workerConfiguration: WorkerConfiguration = {
...defaultWorkerConfiguration,
...(deprecatedWorkerConfiguration as Partial<WorkerConfiguration>),
- ...(has(ConfigurationSection.worker, configData) && configData?.worker),
+ ...(has(ConfigurationSection.worker, configurationData) && configurationData?.worker),
}
if (workerConfiguration.processType != null) {
checkWorkerProcessType(workerConfiguration.processType)
Configuration.getConfigurationData()?.['stationTemplateURLs' as keyof ConfigurationData] !=
null
) {
- const configData = Configuration.getConfigurationData()
- if (configData != null) {
- configData.stationTemplateUrls = configData[
+ const configurationData = Configuration.getConfigurationData()
+ if (configurationData != null) {
+ configurationData.stationTemplateUrls = configurationData[
'stationTemplateURLs' as keyof ConfigurationData
] as StationTemplateUrl[]
}
if (workerScript.trim().length === 0) {
throw new Error('Worker script is an empty string')
}
- const workerScriptStats = statSync(workerScript, { throwIfNoEntry: false })
- if (workerScriptStats == null) {
+ const workerScriptStatistics = statSync(workerScript, { throwIfNoEntry: false })
+ if (workerScriptStatistics == null) {
throw new Error(`Worker script file does not exist: '${workerScript}'`)
}
- if (!workerScriptStats.isFile()) {
+ if (!workerScriptStatistics.isFile()) {
throw new Error(`Worker script is not a regular file: '${workerScript}'`)
}
this.workerScript = workerScript
repositories / e-mobility-charging-stations-simulator.git / commitdiff
