signalk-polar-performance-plugin 1.3.3 → 2.0.0

package/plugin/SI.js

@@ -1,21 +0,0 @@
-class SI {
-  /**
-   * Utility class for unit conversions.
-   */
-  static toKnots(metersPerSecond) {
-    return metersPerSecond * 1.94384;
-  }
-
-  static fromKnots(knots) {
-    return knots / 1.94384;
-  }
-
-  static toDegrees(radians) {
-    return radians * (180 / Math.PI);
-  }
-
-  static fromDegrees(degrees) {
-    return degrees * (Math.PI / 180);
-  }
-}
-module.exports = SI; 

package/plugin/import/ExpeditionImporter.js

@@ -1,152 +0,0 @@
-'use strict'
-
-const SI = require('../SI')
-const { createCanonicalResource } = require('./canonical')
-
-function parseNumber(value) {
-  if (typeof value !== 'string') return Number.NaN
-  const normalized = value.replace(/^"|"$/g, '').trim()
-  if (!normalized) return Number.NaN
-  return Number(normalized)
-}
-
-class ExpeditionImporter {
-  constructor() {
-    this.id = 'expedition'
-    this.name = 'Expedition'
-    this.description = 'Expedition polar text with one TWS row followed by repeated TWA/boat-speed pairs and optional inline beat/run target points.'
-    this.defaultSource = 'expedition'
-  }
-
-  parse(content) {
-    const lines = content
-      .replace(/^\uFEFF/, '')
-      .split(/\r?\n/)
-      .map(line => line.trim())
-      .filter(Boolean)
-
-    if (lines.length === 0) {
-      throw new Error('Import text is empty')
-    }
-
-    let sailnumber = null
-    let startIndex = 0
-    if (lines[0].startsWith('!')) {
-      sailnumber = lines[0].slice(1).trim() || null
-      startIndex = 1
-    }
-
-    const rowData = []
-    const angleFrequency = new Map()
-
-    for (const rawLine of lines.slice(startIndex)) {
-      const cells = rawLine.split(/\t+/).map(cell => cell.trim()).filter(cell => cell.length > 0)
-      if (cells.length < 3) continue
-
-      const twsKnots = parseNumber(cells[0])
-      if (!Number.isFinite(twsKnots) || twsKnots <= 0) {
-        throw new Error(`Invalid Expedition TWS value '${cells[0]}'`)
-      }
-
-      if ((cells.length - 1) % 2 !== 0) {
-        throw new Error(`Expedition row for TWS ${cells[0]} has an incomplete TWA/BSP pair`)
-      }
-
-      const pairs = []
-      for (let index = 1; index < cells.length; index += 2) {
-        const angleDeg = parseNumber(cells[index])
-        const speedKnots = parseNumber(cells[index + 1])
-        if (!Number.isFinite(angleDeg) || angleDeg < 0 || angleDeg > 180) {
-          throw new Error(`Invalid Expedition TWA value '${cells[index]}'`)
-        }
-        if (!Number.isFinite(speedKnots) || speedKnots < 0) {
-          throw new Error(`Invalid Expedition boat speed value '${cells[index + 1]}'`)
-        }
-
-        const angleKey = angleDeg.toFixed(6)
-        angleFrequency.set(angleKey, (angleFrequency.get(angleKey) || 0) + 1)
-        pairs.push({
-          angleDeg,
-          angleRad: SI.fromDegrees(angleDeg),
-          speed: SI.fromKnots(speedKnots)
-        })
-      }
-
-      rowData.push({
-        tws: SI.fromKnots(twsKnots),
-        pairs
-      })
-    }
-
-    if (rowData.length === 0) {
-      throw new Error('No Expedition polar rows were found')
-    }
-
-    const commonAngleKeys = new Set(
-      Array.from(angleFrequency.entries())
-        .filter(([, count]) => count > 1)
-        .map(([key]) => key)
-    )
-
-    const twaAxis = Array.from(commonAngleKeys)
-      .map(key => SI.fromDegrees(Number(key)))
-      .sort((left, right) => left - right)
-
-    if (twaAxis.length === 0) {
-      throw new Error('No repeated Expedition TWA grid was detected')
-    }
-
-    const boatSpeedMatrix = []
-    const derivedRows = []
-
-    rowData.forEach((row) => {
-      const pairByKey = new Map(row.pairs.map(pair => [pair.angleDeg.toFixed(6), pair]))
-      const uncommonPairs = row.pairs.filter(pair => !commonAngleKeys.has(pair.angleDeg.toFixed(6)) && pair.speed > 0)
-      const beatPair = uncommonPairs.length ? uncommonPairs[0] : null
-      const runPair = uncommonPairs.length > 1 ? uncommonPairs[uncommonPairs.length - 1] : null
-
-      boatSpeedMatrix.push(
-        twaAxis.map((angleRad) => {
-          const pair = pairByKey.get(SI.toDegrees(angleRad).toFixed(6))
-          return pair ? pair.speed : 0
-        })
-      )
-
-      if (beatPair || runPair) {
-        derivedRows.push({
-          tws: row.tws,
-          ...(beatPair ? {
-            beat: {
-              twa: beatPair.angleRad,
-              tbs: beatPair.speed,
-              vmg: beatPair.speed * Math.abs(Math.cos(beatPair.angleRad))
-            }
-          } : {}),
-          ...(runPair ? {
-            run: {
-              twa: runPair.angleRad,
-              tbs: runPair.speed,
-              vmg: runPair.speed * Math.abs(Math.cos(runPair.angleRad))
-            }
-          } : {})
-        })
-      }
-    })
-
-    return {
-      resource: {
-        ...createCanonicalResource({
-          axes: {
-            tws: rowData.map(row => row.tws),
-            twa: twaAxis
-          },
-          values: { boatSpeedMatrix },
-          ...(derivedRows.length ? { derived: { rows: derivedRows } } : {})
-        }),
-        ...(sailnumber ? { sailnumber } : {})
-      }
-    }
-  }
-}
-
-module.exports = ExpeditionImporter

package/plugin/import/FormatRegistry.js

@@ -1,21 +0,0 @@
-'use strict'
-
-class FormatRegistry {
-  constructor(importers = []) {
-    this.importers = new Map(importers.map(importer => [importer.id, importer]))
-  }
-
-  get(id) {
-    return this.importers.get(id)
-  }
-
-  list() {
-    return Array.from(this.importers.values()).map(importer => ({
-      id: importer.id,
-      name: importer.name,
-      description: importer.description
-    }))
-  }
-}
-
-module.exports = FormatRegistry

package/plugin/import/ImportService.js

@@ -1,199 +0,0 @@
-'use strict'
-
-const FormatRegistry = require('./FormatRegistry')
-const SourceRegistry = require('./SourceRegistry')
-const OrcSource = require('./OrcSource')
-const JieterImporter = require('./JieterImporter')
-const ExpeditionImporter = require('./ExpeditionImporter')
-const { applyMetadata, validateCanonicalPolarResourceBody } = require('./canonical')
-
-class ImportError extends Error {
-  constructor(status, message) {
-    super(message)
-    this.status = status
-  }
-}
-
-function autoId(value, fallback = 'imported-polar') {
-  const slug = String(value || '')
-    .trim()
-    .toLowerCase()
-    .replace(/[^a-z0-9._-]+/g, '-')
-    .replace(/-+/g, '-')
-    .replace(/^-|-$/g, '')
-  return slug || fallback
-}
-
-function timestampIdPart(now = Date.now()) {
-  const date = now instanceof Date ? now : new Date(now)
-  const pad = value => String(value).padStart(2, '0')
-  return [
-    date.getUTCFullYear(),
-    pad(date.getUTCMonth() + 1),
-    pad(date.getUTCDate()),
-    't',
-    pad(date.getUTCHours()),
-    pad(date.getUTCMinutes()),
-    pad(date.getUTCSeconds()),
-    'z'
-  ].join('')
-}
-
-function createTimestampedId(baseValue, fallback, exists, now) {
-  const baseId = autoId(baseValue, fallback)
-  const timestampedBaseId = `${baseId}-${timestampIdPart(now())}`
-  let id = timestampedBaseId
-  let suffix = 2
-  while (exists(id)) {
-    id = `${timestampedBaseId}-${suffix}`
-    suffix += 1
-  }
-  return id
-}
-
-function validateRequestedId(id) {
-  if (typeof id !== 'string' || !id.trim()) {
-    throw new ImportError(400, "'id' must be a non-empty string when provided")
-  }
-  if (!/^[A-Za-z0-9._-]+$/.test(id.trim())) {
-    throw new ImportError(400, "'id' may contain only letters, numbers, '.', '_' and '-' characters")
-  }
-  return id.trim()
-}
-
-class ImportService {
-  constructor(store, options = {}) {
-    this.store = store
-    this.now = options.now || (() => Date.now())
-    this.registry = new FormatRegistry([
-      new JieterImporter(),
-      new ExpeditionImporter()
-    ])
-    this.sourceRegistry = new SourceRegistry([
-      new OrcSource({
-        dataDir: store.dataDir,
-        fetcher: options.fetcher,
-        now: this.now
-      })
-    ])
-  }
-
-  listFormats() {
-    return this.registry.list()
-  }
-
-  listSources() {
-    return this.sourceRegistry.list().map(descriptor => ({ ...descriptor }))
-  }
-
-  importText(formatId, body) {
-    if (!body || typeof body !== 'object') {
-      throw new ImportError(400, 'Expected a JSON object')
-    }
-
-    if (typeof body.content !== 'string' || !body.content.trim()) {
-      throw new ImportError(400, "'content' is required")
-    }
-
-    const importer = this.registry.get(formatId)
-    if (!importer) {
-      throw new ImportError(400, `Unsupported import format: ${formatId}`)
-    }
-
-    let parsed
-    try {
-      parsed = importer.parse(body.content)
-    } catch (error) {
-      throw new ImportError(400, error.message)
-    }
-
-    const resource = applyMetadata(
-      parsed.resource,
-      { ...body, source: body.source || importer.defaultSource },
-      body.name || importer.name
-    )
-
-    const validationError = validateCanonicalPolarResourceBody(resource)
-    if (validationError) {
-      throw new ImportError(400, validationError)
-    }
-
-    const id = createTimestampedId(
-      resource.sailnumber || resource.name || formatId,
-      `${formatId}-polar`,
-      (candidate) => this.store.exists(candidate),
-      this.now
-    )
-
-    this.store.saveCanonical(id, resource)
-    return { id, resource: { ...resource, id } }
-  }
-
-  async searchSource(sourceId, query) {
-    const source = this.sourceRegistry.get(sourceId)
-    if (!source) {
-      throw new ImportError(404, `Unsupported import source: ${sourceId}`)
-    }
-
-    try {
-      return await source.search(query)
-    } catch (error) {
-      if (Number.isInteger(error.status)) {
-        throw new ImportError(error.status, error.message)
-      }
-      throw error
-    }
-  }
-
-  async importSource(sourceId, externalId, body) {
-    const source = this.sourceRegistry.get(sourceId)
-    if (!source) {
-      throw new ImportError(404, `Unsupported import source: ${sourceId}`)
-    }
-
-    if (body != null && typeof body !== 'object') {
-      throw new ImportError(400, 'Expected a JSON object')
-    }
-
-    if (body && Object.keys(body).length > 0) {
-      throw new ImportError(400, 'External source imports do not accept metadata overrides')
-    }
-
-    let parsed
-    try {
-      parsed = await source.importByExternalId(externalId)
-    } catch (error) {
-      if (Number.isInteger(error.status)) {
-        throw new ImportError(error.status, error.message)
-      }
-      throw error
-    }
-
-    const resource = applyMetadata(
-      parsed.resource,
-      { source: parsed.resource.source || source.defaultSource },
-      parsed.fallbackName || source.name
-    )
-
-    const validationError = validateCanonicalPolarResourceBody(resource)
-    if (validationError) {
-      throw new ImportError(400, validationError)
-    }
-
-    const id = (() => {
-      const baseId = autoId(externalId || resource.name || resource.sailnumber, `${sourceId}-polar`)
-      let candidate = baseId
-      let suffix = 2
-      while (this.store.exists(candidate)) {
-        candidate = `${baseId}-${suffix}`
-        suffix += 1
-      }
-      return candidate
-    })()
-
-    this.store.saveCanonical(id, resource)
-    return { id, resource: { ...resource, id } }
-  }
-}
-
-module.exports = { ImportService, ImportError, autoId, timestampIdPart, createTimestampedId }

package/plugin/import/JieterImporter.js

@@ -1,18 +0,0 @@
-'use strict'
-
-const { parseMatrixPolarText } = require('./matrixText')
-
-class JieterImporter {
-  constructor() {
-    this.id = 'jieter'
-    this.name = 'Jieter'
-    this.description = 'Semicolon-delimited Jieter/ORC table with TWS header, TWA rows, and optional beat/run target rows.'
-    this.defaultSource = 'jieter'
-  }
-
-  parse(content) {
-    return parseMatrixPolarText(content, { preferredDelimiters: [';'] })
-  }
-}
-
-module.exports = JieterImporter