signalk-chiplog 2.0.0 → 2.2.0

package/lib/logbook-pdf.js

@@ -14,6 +14,8 @@ const TABLE_HEAD_HEIGHT = 16;
 const FOOTER_TOP = PAGE.height - PAGE.margin - 6;
 const BODY_BOTTOM = FOOTER_TOP - 12;
 const FONT_SIZE = 8;
+// The landmark line under a position: set back by its size as well as its grey.
+const LANDMARK_FONT_SIZE = 7;
 const LINE_HEIGHT = 10;
 const CELL_PADDING = 3;
 const SKETCH_MAX_HEIGHT = 48;
@@ -35,7 +37,9 @@ const ALARM = [0.72, 0.1, 0.1];
 
 const COLUMNS = [
   { key: 'time', width: 36 },
-  { key: 'position', width: 112 },
+  // Wide enough for the coordinates and, under them, most of a landmark
+  // bearing on one line (SPEC §4.13); the remarks column keeps the rest.
+  { key: 'position', width: 142 },
   { key: 'course', width: 42 },
   { key: 'speed', width: 42 },
   { key: 'wind', width: 80 },
@@ -46,6 +50,45 @@ const COLUMNS = [
 const REMARKS_WIDTH =
   PAGE.width - 2 * PAGE.margin - COLUMNS.reduce((sum, column) => sum + column.width, 0);
 
+// The weather block (SPEC §4.5.3) is its own row spanning the full page
+// width, laid out as the passage page's table: a time column of its own,
+// then the columns the forecast has data for, sharing the rest of the width
+// by weight -- wind needs more room than pressure.
+const WEATHER_TIME_WIDTH = 46;
+const WEATHER_COLUMNS = [
+  { key: 'sky', weight: 2 },
+  { key: 'wind', weight: 3 },
+  { key: 'waves', weight: 2 },
+  { key: 'swell', weight: 2 },
+  { key: 'pressure', weight: 1.3 },
+  { key: 'visibility', weight: 1.6 },
+  { key: 'temperature', weight: 2 },
+  { key: 'current', weight: 2 }
+];
+const WEATHER_TITLE_HEIGHT = 16;
+const WEATHER_ROW_HEIGHT = 2 * LINE_HEIGHT + 4;
+
+// The tide and boat-status blocks (SPEC §4.5.1, §4.5.2): two half-width
+// blocks side by side, between the weather block and the day's table -- what
+// the skipper notes before casting off, next to the forecast bulletin.
+const INFO_GAP = 16;
+const INFO_TITLE_HEIGHT = 16;
+const INFO_WIDTH = (PAGE.width - 2 * PAGE.margin - INFO_GAP) / 2;
+
+function weatherLayout(columns) {
+  const fullWidth = PAGE.width - 2 * PAGE.margin;
+  const included = WEATHER_COLUMNS.filter((column) => columns[column.key]);
+  const totalWeight = included.reduce((sum, column) => sum + column.weight, 0);
+  const layout = [{ key: 'time', x: PAGE.margin, width: WEATHER_TIME_WIDTH }];
+  let x = PAGE.margin + WEATHER_TIME_WIDTH;
+  for (const column of included) {
+    const width = ((fullWidth - WEATHER_TIME_WIDTH) * column.weight) / totalWeight;
+    layout.push({ key: column.key, x, width });
+    x += width;
+  }
+  return layout;
+}
+
 const HOUR_MS = 60 * 60 * 1000;
 
 // The languages of public/js/i18n.mjs, known synchronously for validation.
@@ -57,9 +100,21 @@ let sharedModules = null;
 function loadShared() {
   const load = (file) =>
     import(pathToFileURL(path.join(__dirname, '..', 'public', 'js', file)).href);
-  sharedModules ??= Promise.all([load('i18n.mjs'), load('format.mjs'), load('log-lines.mjs')]).then(
-    ([i18n, format, lines]) => ({ i18n, format, lines })
-  );
+  sharedModules ??= Promise.all([
+    load('i18n.mjs'),
+    load('format.mjs'),
+    load('log-lines.mjs'),
+    load('weather.mjs'),
+    load('tide.mjs'),
+    load('landmarks.mjs')
+  ]).then(([i18n, format, lines, weather, tide, landmarks]) => ({
+    i18n,
+    format,
+    lines,
+    weather,
+    tide,
+    landmarks
+  }));
   return sharedModules;
 }
 
@@ -101,15 +156,126 @@ function propulsionAt(segments, time) {
   return segment ? segment.type : null;
 }
 
+// The forecast fetched at departure, as the skipper notes the bulletin before
+// casting off: a block of its own, above the day's table (SPEC §4.5.3) --
+// not a row mixed into the events and observations it lists.
+function passageWeatherBlock(bundle, context) {
+  const { t, format } = context;
+  const { entry, weather } = bundle;
+  const steps = weather ? context.forecastSteps(weather.points, 3) : [];
+  if (steps.length === 0) {
+    return null;
+  }
+  const rows = steps.map((step, index) => ({
+    time: {
+      main: format.time(step.time),
+      sub:
+        index === 0 || format.dayKey(step.time) !== format.dayKey(steps[index - 1].time)
+          ? format.shortDate(step.time)
+          : null
+    },
+    cells: context.describeStepColumns(step, { t, format })
+  }));
+  return {
+    dayKey: format.dayKey(entry.startTime),
+    title: t('passage.weather', { place: entry.startPlaceName ?? t('place.unknown') }),
+    layout: weatherLayout(context.weatherColumns(steps)),
+    rows,
+    height: WEATHER_TITLE_HEIGHT + TABLE_HEAD_HEIGHT + rows.length * WEATHER_ROW_HEIGHT
+  };
+}
+
+// The tide extremes fetched near departure (SPEC §4.5.2), as a line per high
+// or low -- the PDF has no room for the passage page's curve.
+function tideLines(bundle, context) {
+  const { t, format } = context;
+  const extremes = bundle.tide ? context.tideExtremes(bundle.tide.points) : [];
+  if (extremes.length === 0) {
+    return null;
+  }
+  return extremes.map((extreme, index) => {
+    const label = extreme.type === 'high' ? t('tide.high') : t('tide.low');
+    const when =
+      index === 0 || format.dayKey(extreme.time) !== format.dayKey(extremes[index - 1].time)
+        ? `${format.shortDate(extreme.time)} ${format.time(extreme.time)}`
+        : format.time(extreme.time);
+    return `${label} ${when} — ${format.depth(extreme.height)}`;
+  });
+}
+
+// The tanks and batteries noted as the passage opened (SPEC §4.5.1) -- not
+// the engine hours, already on the departure line.
+function statusLines(bundle, context) {
+  const { t, format } = context;
+  const tanks = bundle.entry.startTanks ?? [];
+  const batteries = bundle.entry.startBatteries ?? [];
+  if (tanks.length + batteries.length === 0) {
+    return null;
+  }
+  const tankLine = (item) =>
+    `${context.tankName(item, t, tanks)}: ${[format.percent(item.level), format.volume(item.volume)]
+      .filter(Boolean)
+      .join(' · ')}`;
+  const batteryLine = (item) =>
+    `${context.batteryName(item, t)}: ${[
+      format.percent(item.stateOfCharge),
+      format.voltage(item.voltage),
+      format.current(item.current)
+    ]
+      .filter(Boolean)
+      .join(' · ')}`;
+  return [...tanks.map(tankLine), ...batteries.map(batteryLine)];
+}
+
+// The tide and boat-status blocks, side by side between the weather block
+// and the day's table -- either may be missing (no forecast yet, no sensor
+// aboard), in which case only the other is drawn.
+function passageInfoRow(bundle, context) {
+  const { t, format } = context;
+  const tide = tideLines(bundle, context);
+  const status = statusLines(bundle, context);
+  if (!tide && !status) {
+    return null;
+  }
+  const blockOf = (title, lines) =>
+    lines && {
+      title,
+      lines,
+      height: INFO_TITLE_HEIGHT + lines.length * LINE_HEIGHT + CELL_PADDING
+    };
+  const left = blockOf(t('passage.tide'), tide);
+  const right = blockOf(t('passage.boatState'), status);
+  return {
+    dayKey: format.dayKey(bundle.entry.startTime),
+    left,
+    right,
+    height: Math.max(left?.height ?? 0, right?.height ?? 0)
+  };
+}
+
 function passageLines(bundle, context) {
   const { t, format, buildRows, describeEvent, engineHours, engineName, manoeuvreLabels } = context;
   const { entry, events, observations, propulsion } = bundle;
   const place = (name) => name ?? t('place.unknown');
-  // Readings taken at departure and arrival belong on those lines.
-  const startReadings = observations.find((observation) => observation.reason === 'entry_start');
-  const endReadings = observations.find((observation) => observation.reason === 'entry_end');
+  // Readings taken at departure and arrival belong on those lines. A passage
+  // that set off again after a stopover has a departure reading for each start.
+  const byTime = (a, b) => a.time.localeCompare(b.time) || a.id - b.id;
+  const [startReadings, ...resumeReadings] = observations
+    .filter((observation) => observation.reason === 'entry_start')
+    .sort(byTime);
+  // The last arrival reading, once the passage has arrived: an earlier one was
+  // taken at a stopover and stays a line of its own.
+  const endReadings = entry.endTime
+    ? observations
+        .filter((observation) => observation.reason === 'entry_end')
+        .sort(byTime)
+        .at(-1)
+    : undefined;
   const otherReadings = observations.filter(
-    (observation) => observation !== startReadings && observation !== endReadings
+    (observation) =>
+      observation !== startReadings &&
+      observation !== endReadings &&
+      !resumeReadings.includes(observation)
   );
   // Engine hour counters, as a paper log notes them at departure and arrival:
   // named when there are several engines, with the hours run at arrival.
@@ -128,6 +294,38 @@ function passageLines(bundle, context) {
       .join(', ');
     return { text: t('pdf.engineHours', { hours: list }), newLine: true };
   };
+  // Who was aboard (SPEC §4.11), on the true departure line only -- a
+  // passage's crew does not change at a mid-passage stopover.
+  const crewText = () => {
+    const list = bundle.crew ?? [];
+    if (list.length === 0) {
+      return null;
+    }
+    const names = list
+      .map((member) => (member.role ? `${member.name} (${member.role})` : member.name))
+      .join(', ');
+    return { text: t('pdf.crew', { crew: names }), newLine: true };
+  };
+  // The counters as they stood at one reading, for a departure after a stopover.
+  const hoursAt = (readings) => {
+    const runtimes = Object.entries(readings.engineRuntimes ?? {});
+    if (runtimes.length === 0) {
+      return null;
+    }
+    const list = runtimes
+      .map(([id, runtime]) => {
+        const name = runtimes.length > 1 ? `${engineName(id, t)} ` : '';
+        return `${name}${format.hours(runtime)}`;
+      })
+      .join(', ');
+    return { text: t('pdf.engineHours', { hours: list }), newLine: true };
+  };
+  // Where a departure after a stopover left from: the stopover before it.
+  const stopoverBefore = (time) =>
+    events
+      .filter((event) => event.type === 'stopover' && event.time <= time)
+      .sort((a, b) => a.time.localeCompare(b.time))
+      .at(-1);
   const lines = [
     {
       time: entry.startTime,
@@ -139,11 +337,32 @@ function passageLines(bundle, context) {
       position: entry.startPosition,
       remarks: [
         { text: t('pdf.departure', { place: place(entry.startPlaceName) }), font: 'bold' },
-        hoursText('start')
+        hoursText('start'),
+        crewText()
       ].filter(Boolean)
     }
   ];
 
+  for (const readings of resumeReadings) {
+    const stopover = stopoverBefore(readings.time);
+    lines.push({
+      time: readings.time,
+      order: 1,
+      entry,
+      kind: 'departure',
+      readings,
+      propulsion: propulsionAt(propulsion, readings.time),
+      position: readings.position ?? stopover?.position ?? null,
+      remarks: [
+        {
+          text: t('pdf.departure', { place: place(stopover?.payload?.placeName) }),
+          font: 'bold'
+        },
+        hoursAt(readings)
+      ].filter(Boolean)
+    });
+  }
+
   for (const row of buildRows(events, otherReadings)) {
     const remarks = [];
     let strokes = null;
@@ -204,7 +423,14 @@ function passageLines(bundle, context) {
       ].filter(Boolean)
     });
   }
-  return lines;
+  // Every line's position is also read against the nearest amer (SPEC §4.13),
+  // printed in grey under the coordinates -- the same wording the passage page
+  // shows, from the same module.
+  const landmarks = bundle.landmarks ?? [];
+  return lines.map((line) => ({
+    ...line,
+    landmark: context.landmarkLine(line.position ?? null, landmarks, { t, format })
+  }));
 }
 
 // Distance and engine/sail time of each calendar day, across all passages.
@@ -307,6 +533,7 @@ function readingCells(line, context) {
   const cells = {
     time: line.time ? format.time(line.time) : '',
     position: format.position(line.position ?? null),
+    positionNote: line.landmark ?? '',
     course: '',
     speed: format.speed(readings?.sog),
     wind: '',
@@ -328,8 +555,16 @@ function readingCells(line, context) {
   return cells;
 }
 
+const POSITION_WIDTH = COLUMNS.find((column) => column.key === 'position').width;
+
 function measure(line, context) {
   const remarkLines = layoutRemarks(line.remarks, REMARKS_WIDTH - 2 * CELL_PADDING);
+  const cells = readingCells(line, context);
+  // The landmark line is narrower than the coordinates it sits under, so it
+  // wraps rather than running into the course column.
+  const positionLines = cells.positionNote
+    ? wrapText(cells.positionNote, 'regular', LANDMARK_FONT_SIZE, POSITION_WIDTH - 2 * CELL_PADDING)
+    : [];
   const sketch = sketchBox(line.strokes);
   const maxLines = Math.floor(
     (BODY_BOTTOM -
@@ -346,24 +581,29 @@ function measure(line, context) {
   }
   const height =
     2 * CELL_PADDING +
-    Math.max(1, shown.length) * LINE_HEIGHT +
+    Math.max(1, shown.length, 1 + positionLines.length) * LINE_HEIGHT +
     (sketch ? sketch.drawnHeight + (shown.length > 0 ? 2 : 0) : 0);
-  return { ...line, cells: readingCells(line, context), remarkLines: shown, sketch, height };
+  return { ...line, cells, remarkLines: shown, positionLines, sketch, height };
 }
 
 // Pages as lists of measured rows; nothing is drawn yet, so the page count is
-// known for the footers.
+// known for the footers. A day's weather and info blocks only take up room on
+// its first page, above the table -- not repeated on a page it continues onto.
 function paginate(days, context) {
   const pages = [];
-  const available = BODY_BOTTOM - HEADER_BOTTOM - TABLE_HEAD_HEIGHT;
+  const baseAvailable = BODY_BOTTOM - HEADER_BOTTOM - TABLE_HEAD_HEIGHT;
   for (const day of days) {
+    const weatherHeight = (day.weatherBlocks ?? []).reduce((sum, block) => sum + block.height, 0);
+    const infoHeight = (day.infoRows ?? []).reduce((sum, row) => sum + row.height, 0);
     let page = { day, continued: false, rows: [], used: 0 };
     pages.push(page);
+    let available = baseAvailable - weatherHeight - infoHeight;
     for (const line of day.lines) {
       const row = measure(line, context);
       if (page.used + row.height > available && page.rows.length > 0) {
         page = { day, continued: true, rows: [], used: 0 };
         pages.push(page);
+        available = baseAvailable;
       }
       page.rows.push(row);
       page.used += row.height;
@@ -403,6 +643,14 @@ function drawRow(page, row, top) {
     if (text) {
       page.text(x + CELL_PADDING, baseline, text, { size: FONT_SIZE });
     }
+    if (column.key === 'position') {
+      row.positionLines.forEach((text, index) => {
+        page.text(x + CELL_PADDING, baseline + (index + 1) * LINE_HEIGHT, text, {
+          size: LANDMARK_FONT_SIZE,
+          color: GREY
+        });
+      });
+    }
     x += column.width;
   }
   row.remarkLines.forEach((words, index) => {
@@ -438,6 +686,68 @@ function drawRow(page, row, top) {
   });
 }
 
+// The weather block: a title naming the departure place, then a table of its
+// own spanning the full width -- the same shape as the passage page's, drawn
+// above the day's table rather than as one of its rows.
+function drawWeatherRow(page, block, top, t) {
+  page.text(PAGE.margin, top + 11, block.title, { font: 'bold', size: 9 });
+  let y = top + WEATHER_TITLE_HEIGHT;
+  page.rect(PAGE.margin, y, PAGE.width - 2 * PAGE.margin, TABLE_HEAD_HEIGHT, {
+    fill: HEAD_FILL,
+    stroke: RULE
+  });
+  for (const column of block.layout) {
+    page.text(column.x + CELL_PADDING, y + 11, t(`weather.${column.key}`), {
+      font: 'bold',
+      size: 7.5
+    });
+  }
+  y += TABLE_HEAD_HEIGHT;
+  for (const dataRow of block.rows) {
+    const baseline = y + CELL_PADDING + FONT_SIZE;
+    for (const column of block.layout) {
+      const value = column.key === 'time' ? dataRow.time : dataRow.cells[column.key];
+      if (value?.main) {
+        page.text(column.x + CELL_PADDING, baseline, value.main, { size: FONT_SIZE });
+      }
+      if (value?.sub) {
+        page.text(column.x + CELL_PADDING, baseline + LINE_HEIGHT, value.sub, {
+          size: FONT_SIZE,
+          color: GREY
+        });
+      }
+    }
+    y += WEATHER_ROW_HEIGHT;
+  }
+  page.line(PAGE.margin, top + block.height, PAGE.width - PAGE.margin, top + block.height, {
+    color: RULE,
+    width: 0.4
+  });
+}
+
+// One of the two info blocks: a title, then a line per tide extreme or per
+// tank/battery -- plain text, unlike the weather block's table.
+function drawInfoBlock(page, block, x, top) {
+  if (!block) {
+    return;
+  }
+  page.text(x, top + 11, block.title, { font: 'bold', size: 9 });
+  const baseline = top + INFO_TITLE_HEIGHT + CELL_PADDING + FONT_SIZE;
+  block.lines.forEach((text, index) => {
+    page.text(x, baseline + index * LINE_HEIGHT, text, { size: FONT_SIZE });
+  });
+}
+
+// The tide and boat-status blocks, side by side (SPEC §4.5.1, §4.5.2).
+function drawInfoRow(page, row, top) {
+  drawInfoBlock(page, row.left, PAGE.margin, top);
+  drawInfoBlock(page, row.right, PAGE.margin + INFO_WIDTH + INFO_GAP, top);
+  page.line(PAGE.margin, top + row.height, PAGE.width - PAGE.margin, top + row.height, {
+    color: RULE,
+    width: 0.4
+  });
+}
+
 function capitalise(text) {
   return text.charAt(0).toUpperCase() + text.slice(1);
 }
@@ -446,7 +756,14 @@ async function renderLogbookPdf(
   bundles,
   { language = 'en', timeZone, vesselName = null, now, version = '' }
 ) {
-  const { i18n, format: formatModule, lines: lineModule } = await loadShared();
+  const {
+    i18n,
+    format: formatModule,
+    lines: lineModule,
+    weather: weatherModule,
+    tide: tideModule,
+    landmarks: landmarkModule
+  } = await loadShared();
   const t = i18n.createTranslator(language);
   const format = formatModule.createFormatter({
     locale: language,
@@ -462,6 +779,13 @@ async function renderLogbookPdf(
     describeEvent: lineModule.describeEvent,
     engineHours: lineModule.engineHours,
     engineName: lineModule.engineName,
+    forecastSteps: weatherModule.forecastSteps,
+    weatherColumns: weatherModule.weatherColumns,
+    describeStepColumns: weatherModule.describeStepColumns,
+    tideExtremes: tideModule.tideExtremes,
+    tankName: lineModule.tankName,
+    batteryName: lineModule.batteryName,
+    landmarkLine: landmarkModule.landmarkLine,
     manoeuvreLabels: {}
   };
 
@@ -497,6 +821,22 @@ async function renderLogbookPdf(
     }
     days.at(-1).lines.push(line);
   }
+
+  // Each passage's weather and info blocks belong on the day it departed,
+  // above that day's table rather than mixed into it.
+  for (const bundle of bundles) {
+    const block = passageWeatherBlock(bundle, context);
+    const day = block && days.find((candidate) => candidate.key === block.dayKey);
+    if (day) {
+      (day.weatherBlocks ??= []).push(block);
+    }
+    const info = passageInfoRow(bundle, context);
+    const infoDay = info && days.find((candidate) => candidate.key === info.dayKey);
+    if (infoDay) {
+      (infoDay.infoRows ??= []).push(info);
+    }
+  }
+
   for (const day of days) {
     const total = totals.get(day.key) ?? { distance: 0, engine: 0, sail: 0 };
     day.lines.push({
@@ -567,8 +907,19 @@ async function renderLogbookPdf(
           size: 13
         }
       );
-      drawTableHead(page, t, HEADER_BOTTOM);
-      let top = HEADER_BOTTOM + TABLE_HEAD_HEIGHT;
+      let top = HEADER_BOTTOM;
+      if (!layout.continued) {
+        for (const block of layout.day.weatherBlocks ?? []) {
+          drawWeatherRow(page, block, top, t);
+          top += block.height;
+        }
+        for (const row of layout.day.infoRows ?? []) {
+          drawInfoRow(page, row, top);
+          top += row.height;
+        }
+      }
+      drawTableHead(page, t, top);
+      top += TABLE_HEAD_HEIGHT;
       for (const row of layout.rows) {
         drawRow(page, row, top);
         top += row.height;

package/lib/observation-recorder.js

@@ -250,13 +250,13 @@ function createObservationRecorder({ db, readSelfPath, readFresh, settings }) {
     sense,
 
     // Runs inside detection's transaction, with what this cycle did to passages.
-    afterDetection(now, { opened, closed }) {
+    afterDetection(now, { opened, reopened, resumedAt, closed }) {
       if (closed && !closed.late) {
         // Dated from the actual end of the passage, not from this tick that
-        // only found out about it up to stopClosureMinutes later -- a merge's
-        // stopover event (SPEC §3.1) needs to sort after this reading, not
-        // before it, and readings taken since the boat has been still say the
-        // same thing regardless.
+        // found out about it once detection saw the stop -- a stopover event
+        // (SPEC §3.1) needs to sort after this reading, not before it, and
+        // readings taken since the boat has been still say the same thing
+        // regardless.
         record(closed.id, 'entry_end', closed.endTime);
       }
       if (opened) {
@@ -264,6 +264,12 @@ function createObservationRecorder({ db, readSelfPath, readFresh, settings }) {
         noteBoatState(opened);
         return;
       }
+      // A passage reopened after a short stop sets off again: its departure
+      // reading is dated from when it did, like the propulsion segment.
+      if (reopened) {
+        record(reopened, 'entry_start', iso(resumedAt));
+        return;
+      }
       const entry = db
         .prepare("SELECT id, start_time FROM log_entries WHERE state = 'active'")
         .get();