@sayue_ltr/fleq 1.49.2

package/dist/engine/eew/eew-tracker.js

@@ -0,0 +1,229 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EewTracker = void 0;
+const intensityUtils = __importStar(require("../../utils/intensity"));
+/** 古いイベントを自動削除するまでの時間 (ミリ秒) */
+const CLEANUP_THRESHOLD_MS = 10 * 60 * 1000; // 10分
+/** 深さ文字列から数値(km)を抽出 */
+function parseDepthKm(depth) {
+    const m = depth.match(/(\d+)\s*km/);
+    return m ? parseInt(m[1], 10) : null;
+}
+/** 予測震度リストから最大震度を取得 */
+function getMaxForecastIntensity(areas) {
+    if (areas.length === 0)
+        return null;
+    let maxInt = areas[0].intensity;
+    let maxRank = intensityUtils.intensityToRank(maxInt);
+    for (let i = 1; i < areas.length; i++) {
+        const rank = intensityUtils.intensityToRank(areas[i].intensity);
+        if (rank > maxRank) {
+            maxRank = rank;
+            maxInt = areas[i].intensity;
+        }
+    }
+    return maxInt;
+}
+/** 2つの EEW 情報から差分を計算 */
+function computeDiff(prev, curr) {
+    const diff = {};
+    let hasDiff = false;
+    // マグニチュード変化
+    if (prev.earthquake?.magnitude && curr.earthquake?.magnitude) {
+        const prevMag = parseFloat(prev.earthquake.magnitude);
+        const currMag = parseFloat(curr.earthquake.magnitude);
+        if (!isNaN(prevMag) && !isNaN(currMag) && prevMag !== currMag) {
+            diff.previousMagnitude = prev.earthquake.magnitude;
+            hasDiff = true;
+        }
+    }
+    // 深さ変化
+    if (prev.earthquake?.depth && curr.earthquake?.depth) {
+        const prevD = parseDepthKm(prev.earthquake.depth);
+        const currD = parseDepthKm(curr.earthquake.depth);
+        if (prevD != null && currD != null && prevD !== currD) {
+            diff.previousDepth = prev.earthquake.depth;
+            hasDiff = true;
+        }
+    }
+    // 最大予測震度変化 (配列順に依存せず最大値を正規化して比較)
+    if (prev.forecastIntensity?.areas.length && curr.forecastIntensity?.areas.length) {
+        const prevMax = getMaxForecastIntensity(prev.forecastIntensity.areas);
+        const currMax = getMaxForecastIntensity(curr.forecastIntensity.areas);
+        if (prevMax && currMax && prevMax !== currMax) {
+            diff.previousMaxInt = prevMax;
+            hasDiff = true;
+        }
+    }
+    // 震源地名変化
+    if (prev.earthquake?.hypocenterName && curr.earthquake?.hypocenterName) {
+        if (prev.earthquake.hypocenterName !== curr.earthquake.hypocenterName) {
+            diff.hypocenterChange = true;
+            hasDiff = true;
+        }
+    }
+    return hasDiff ? diff : undefined;
+}
+/**
+ * 複数の EEW イベントを EventID ごとに追跡し、
+ * 重複報の検出・キャンセル状態の管理を行う。
+ */
+class EewTracker {
+    events = new Map();
+    onCleanup;
+    constructor(options) {
+        this.onCleanup = options?.onCleanup;
+    }
+    /** EEW 情報を受け取り、状態を更新して結果を返す */
+    update(info) {
+        // 古いイベントをクリーンアップ
+        this.cleanup();
+        const eventId = info.eventId || "";
+        if (!eventId) {
+            // EventID がない場合は常に新規扱い
+            return {
+                isNew: true,
+                isDuplicate: false,
+                isCancelled: info.infoType === "取消",
+                activeCount: this.getActiveCount(),
+                colorIndex: 0,
+            };
+        }
+        const serialRaw = parseInt(info.serial || "", 10);
+        const serial = Number.isFinite(serialRaw) ? serialRaw : null;
+        const isCancelled = info.infoType === "取消";
+        const existing = this.events.get(eventId);
+        if (existing) {
+            // 既知のイベント — 報数チェック
+            if (!isCancelled && serial != null && serial > 0 && serial <= existing.lastSerial) {
+                // 同じか古い報数 → 重複
+                return {
+                    isNew: false,
+                    isDuplicate: true,
+                    isCancelled: false,
+                    activeCount: this.getActiveCount(),
+                    colorIndex: existing.colorIndex,
+                };
+            }
+            // 差分計算
+            const diff = existing.previousInfo ? computeDiff(existing.previousInfo, info) : undefined;
+            const previousInfo = existing.previousInfo;
+            // 状態更新
+            if (serial != null) {
+                existing.lastSerial = Math.max(existing.lastSerial, serial);
+            }
+            existing.isWarning = existing.isWarning || info.isWarning;
+            existing.isCancelled = isCancelled;
+            existing.lastUpdate = new Date();
+            existing.previousInfo = info;
+            return {
+                isNew: false,
+                isDuplicate: false,
+                isCancelled,
+                activeCount: this.getActiveCount(),
+                diff,
+                previousInfo,
+                colorIndex: existing.colorIndex,
+            };
+        }
+        // 新規イベント
+        const colorIndex = this.nextColorIndex();
+        this.events.set(eventId, {
+            eventId,
+            lastSerial: serial ?? 0,
+            isWarning: info.isWarning,
+            isCancelled,
+            isFinalized: false,
+            lastUpdate: new Date(),
+            previousInfo: info,
+            colorIndex,
+        });
+        return {
+            isNew: true,
+            isDuplicate: false,
+            isCancelled,
+            activeCount: this.getActiveCount(),
+            colorIndex,
+        };
+    }
+    /**
+     * イベントを終了扱いにする (最終報受信時)。
+     * 遅延到着した重複報の検出のためエントリは保持し、
+     * アクティブカウントからは除外する。
+     */
+    finalizeEvent(eventId) {
+        const ev = this.events.get(eventId);
+        if (ev) {
+            ev.isFinalized = true;
+        }
+    }
+    /** 未使用の最小カラーインデックスを返す */
+    nextColorIndex() {
+        const used = new Set();
+        for (const ev of this.events.values()) {
+            if (!ev.isCancelled && !ev.isFinalized)
+                used.add(ev.colorIndex);
+        }
+        let idx = 0;
+        while (used.has(idx))
+            idx++;
+        return idx;
+    }
+    /** 現在アクティブ（キャンセル・最終報済みでない）イベント数を返す */
+    getActiveCount() {
+        let count = 0;
+        for (const ev of this.events.values()) {
+            if (!ev.isCancelled && !ev.isFinalized)
+                count++;
+        }
+        return count;
+    }
+    /** 最終更新から一定時間経過したイベントを削除 */
+    cleanup() {
+        const now = Date.now();
+        const expired = [];
+        for (const [id, ev] of this.events) {
+            if (now - ev.lastUpdate.getTime() > CLEANUP_THRESHOLD_MS) {
+                expired.push(id);
+            }
+        }
+        for (const id of expired) {
+            this.events.delete(id);
+            this.onCleanup?.(id);
+        }
+    }
+}
+exports.EewTracker = EewTracker;

package/dist/engine/messages/message-router.js

@@ -0,0 +1,261 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMessageHandler = createMessageHandler;
+const telegram_parser_1 = require("../../dmdata/telegram-parser");
+const volcano_parser_1 = require("../../dmdata/volcano-parser");
+const formatter_1 = require("../../ui/formatter");
+const eew_formatter_1 = require("../../ui/eew-formatter");
+const earthquake_formatter_1 = require("../../ui/earthquake-formatter");
+const volcano_formatter_1 = require("../../ui/volcano-formatter");
+const volcano_vfvo53_aggregator_1 = require("./volcano-vfvo53-aggregator");
+const eew_tracker_1 = require("../eew/eew-tracker");
+const eew_logger_1 = require("../eew/eew-logger");
+const notifier_1 = require("../notification/notifier");
+const tsunami_state_1 = require("./tsunami-state");
+const volcano_state_1 = require("./volcano-state");
+const volcano_presentation_1 = require("../notification/volcano-presentation");
+const log = __importStar(require("../../logger"));
+/**
+ * classification と head.type から処理ルートを判定する。
+ * ルーティング優先順位:
+ *   1. eew.forecast / eew.warning → EEW
+ *   2. telegram.earthquake + VXSE56/VXSE60/VZSE40 → テキスト系
+ *   3. telegram.earthquake + VXSE62 → 長周期地震動観測
+ *   4. telegram.earthquake + VXSE* → 地震情報
+ *   5. telegram.earthquake + VTSE* → 津波情報
+ *   6. telegram.earthquake + VYSE* → 南海トラフ
+ *   7. telegram.volcano → 火山情報
+ *   8. その他 → raw
+ */
+function classifyMessage(classification, headType) {
+    if (classification === "eew.forecast" || classification === "eew.warning") {
+        return "eew";
+    }
+    if (classification === "telegram.volcano") {
+        return "volcano";
+    }
+    if (classification === "telegram.earthquake") {
+        if (headType === "VXSE56" || headType === "VXSE60" || headType === "VZSE40") {
+            return "seismicText";
+        }
+        if (headType === "VXSE62") {
+            return "lgObservation";
+        }
+        if (headType.startsWith("VXSE")) {
+            return "earthquake";
+        }
+        if (headType.startsWith("VTSE")) {
+            return "tsunami";
+        }
+        if (headType.startsWith("VYSE")) {
+            return "nankaiTrough";
+        }
+    }
+    return "raw";
+}
+// ── ルート別処理 ──
+/** EEW パス: パース → 重複判定 → ログ → 表示 → 通知 */
+function handleEew(msg, eewTracker, eewLogger, notifier) {
+    const eewInfo = (0, telegram_parser_1.parseEewTelegram)(msg);
+    if (!eewInfo) {
+        (0, formatter_1.displayRawHeader)(msg);
+        return;
+    }
+    const result = eewTracker.update(eewInfo);
+    if (result.isDuplicate) {
+        log.debug(`EEW 重複報スキップ: EventID=${eewInfo.eventId} 第${eewInfo.serial}報`);
+        return;
+    }
+    // ログ記録 (非重複報のみ)
+    eewLogger.logReport(eewInfo, result);
+    // 取消報の場合はログを閉じる
+    if (result.isCancelled && eewInfo.eventId) {
+        eewLogger.closeEvent(eewInfo.eventId, "取消");
+    }
+    // 最終報の場合はログを閉じ、トラッカーのイベントを終了扱いにする
+    if (eewInfo.nextAdvisory && eewInfo.eventId && !result.isCancelled) {
+        eewLogger.closeEvent(eewInfo.eventId, "最終報");
+        eewTracker.finalizeEvent(eewInfo.eventId);
+    }
+    (0, eew_formatter_1.displayEewInfo)(eewInfo, {
+        activeCount: result.activeCount,
+        diff: result.diff,
+        colorIndex: result.colorIndex,
+    });
+    notifier.notifyEew(eewInfo, result);
+}
+/** テキスト系 (VXSE56/VXSE60/VZSE40) パス */
+function handleSeismicText(msg, notifier) {
+    const textInfo = (0, telegram_parser_1.parseSeismicTextTelegram)(msg);
+    if (textInfo) {
+        (0, earthquake_formatter_1.displaySeismicTextInfo)(textInfo);
+        notifier.notifySeismicText(textInfo);
+    }
+    else {
+        (0, formatter_1.displayRawHeader)(msg);
+    }
+}
+/** 長周期地震動観測情報 (VXSE62) パス */
+function handleLgObservation(msg, notifier) {
+    const lgInfo = (0, telegram_parser_1.parseLgObservationTelegram)(msg);
+    if (lgInfo) {
+        (0, earthquake_formatter_1.displayLgObservationInfo)(lgInfo);
+        notifier.notifyLgObservation(lgInfo);
+    }
+    else {
+        (0, formatter_1.displayRawHeader)(msg);
+    }
+}
+/** 地震情報 (VXSE51/52/53/61 等) パス */
+function handleEarthquake(msg, notifier) {
+    const eqInfo = (0, telegram_parser_1.parseEarthquakeTelegram)(msg);
+    if (eqInfo) {
+        (0, earthquake_formatter_1.displayEarthquakeInfo)(eqInfo);
+        notifier.notifyEarthquake(eqInfo);
+    }
+    else {
+        (0, formatter_1.displayRawHeader)(msg);
+    }
+}
+/** 津波情報 (VTSE41/51/52) パス */
+function handleTsunami(msg, notifier, tsunamiState) {
+    const tsunamiInfo = (0, telegram_parser_1.parseTsunamiTelegram)(msg);
+    if (tsunamiInfo) {
+        // VTSE41 (津波警報・注意報) の場合のみ状態を更新
+        if (msg.head.type === "VTSE41") {
+            tsunamiState.update(tsunamiInfo);
+        }
+        (0, earthquake_formatter_1.displayTsunamiInfo)(tsunamiInfo);
+        notifier.notifyTsunami(tsunamiInfo);
+    }
+    else {
+        (0, formatter_1.displayRawHeader)(msg);
+    }
+}
+/** 南海トラフ関連 (VYSE50/51/52/60) パス */
+function handleNankaiTrough(msg, notifier) {
+    const nankaiInfo = (0, telegram_parser_1.parseNankaiTroughTelegram)(msg);
+    if (nankaiInfo) {
+        (0, earthquake_formatter_1.displayNankaiTroughInfo)(nankaiInfo);
+        notifier.notifyNankaiTrough(nankaiInfo);
+    }
+    else {
+        (0, formatter_1.displayRawHeader)(msg);
+    }
+}
+/** 火山情報パス (aggregator 経由) */
+function handleVolcano(msg, vfvo53Aggregator) {
+    const volcanoInfo = (0, volcano_parser_1.parseVolcanoTelegram)(msg);
+    if (volcanoInfo) {
+        vfvo53Aggregator.handle(volcanoInfo);
+    }
+    else {
+        (0, formatter_1.displayRawHeader)(msg);
+    }
+}
+/** 受信データのハンドリング */
+function createMessageHandler() {
+    const eewLogger = new eew_logger_1.EewEventLogger();
+    const notifier = new notifier_1.Notifier();
+    const tsunamiState = new tsunami_state_1.TsunamiStateHolder();
+    const volcanoState = new volcano_state_1.VolcanoStateHolder();
+    const eewTracker = new eew_tracker_1.EewTracker({
+        onCleanup: (eventId) => {
+            eewLogger.closeEvent(eventId, "タイムアウト");
+        },
+    });
+    // VFVO53 バッチ集約器
+    const vfvo53Aggregator = new volcano_vfvo53_aggregator_1.VolcanoVfvo53Aggregator(
+    // emitSingle: 従来の単発処理パイプライン (opts?.notify === false なら通知スキップ)
+    (info, opts) => {
+        const presentation = (0, volcano_presentation_1.resolveVolcanoPresentation)(info, volcanoState);
+        (0, volcano_formatter_1.displayVolcanoInfo)(info, presentation);
+        volcanoState.update(info);
+        if (opts?.notify !== false) {
+            notifier.notifyVolcano(info, presentation);
+        }
+    }, 
+    // emitBatch: バッチ専用処理
+    (batch, opts) => {
+        const presentation = (0, volcano_presentation_1.resolveVolcanoBatchPresentation)(batch);
+        (0, volcano_formatter_1.displayVolcanoAshfallBatch)(batch, presentation);
+        if (opts.notify) {
+            notifier.notifyVolcanoBatch(batch, presentation);
+        }
+    });
+    const handler = (msg) => {
+        // XML電文でない場合はヘッダ情報のみ表示
+        if (msg.format !== "xml" || !msg.head.xml) {
+            (0, formatter_1.displayRawHeader)(msg);
+            return;
+        }
+        const route = classifyMessage(msg.classification, msg.head.type);
+        switch (route) {
+            case "eew":
+                handleEew(msg, eewTracker, eewLogger, notifier);
+                break;
+            case "seismicText":
+                handleSeismicText(msg, notifier);
+                break;
+            case "lgObservation":
+                handleLgObservation(msg, notifier);
+                break;
+            case "earthquake":
+                handleEarthquake(msg, notifier);
+                break;
+            case "tsunami":
+                handleTsunami(msg, notifier, tsunamiState);
+                break;
+            case "nankaiTrough":
+                handleNankaiTrough(msg, notifier);
+                break;
+            case "volcano":
+                handleVolcano(msg, vfvo53Aggregator);
+                break;
+            case "raw":
+                (0, formatter_1.displayRawHeader)(msg);
+                break;
+        }
+    };
+    return {
+        handler,
+        eewLogger,
+        notifier,
+        tsunamiState,
+        volcanoState,
+        flushAndDisposeVolcanoBuffer: () => vfvo53Aggregator.flushAndDispose(),
+    };
+}

package/dist/engine/messages/tsunami-state.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TsunamiStateHolder = void 0;
+exports.detectTsunamiAlertLevel = detectTsunamiAlertLevel;
+const theme_1 = require("../../ui/theme");
+const earthquake_formatter_1 = require("../../ui/earthquake-formatter");
+/** レベルの優先度 (大きいほど深刻) */
+const LEVEL_PRIORITY = {
+    "大津波警報": 3,
+    "津波警報": 2,
+    "津波注意報": 1,
+};
+/** レベルに対応するテーマロール */
+const LEVEL_ROLE = {
+    "大津波警報": "tsunamiMajor",
+    "津波警報": "tsunamiWarning",
+    "津波注意報": "tsunamiAdvisory",
+};
+/** 判定対象の kind 一覧 */
+const ALERT_KINDS = new Set(["大津波警報", "津波警報", "津波注意報"]);
+/**
+ * forecast の kind 一覧から最大警報レベルを判定する。
+ * 津波予報 (0.2m 以下) や kind なしの場合は null を返す。
+ */
+function detectTsunamiAlertLevel(kinds) {
+    let maxLevel = null;
+    let maxPriority = 0;
+    for (const kind of kinds) {
+        if (ALERT_KINDS.has(kind)) {
+            const level = kind;
+            const priority = LEVEL_PRIORITY[level];
+            if (priority > maxPriority) {
+                maxPriority = priority;
+                maxLevel = level;
+            }
+        }
+    }
+    return maxLevel;
+}
+/**
+ * 津波情報の状態を保持し、プロンプト表示と detail コマンドを提供する。
+ */
+class TsunamiStateHolder {
+    category = "tsunami";
+    emptyMessage = "現在、継続中の津波情報はありません。";
+    currentLevel = null;
+    lastInfo = null;
+    /** 現在の警報レベルを返す (テスト用) */
+    getLevel() {
+        return this.currentLevel;
+    }
+    /** VTSE41 受信時に状態を更新する */
+    update(info) {
+        // 取消報 → クリア
+        if (info.infoType === "取消") {
+            this.clear();
+            return;
+        }
+        // forecast から警報レベルを検出
+        const kinds = (info.forecast ?? []).map((f) => f.kind);
+        const level = detectTsunamiAlertLevel(kinds);
+        if (level == null) {
+            // 警報レベルなし (津波予報のみ等) → クリア
+            this.clear();
+            return;
+        }
+        this.currentLevel = level;
+        this.lastInfo = info;
+    }
+    /** 状態をクリアする */
+    clear() {
+        this.currentLevel = null;
+        this.lastInfo = null;
+    }
+    // ── PromptStatusProvider ──
+    getPromptStatus() {
+        if (this.currentLevel == null)
+            return null;
+        const role = LEVEL_ROLE[this.currentLevel];
+        const colorFn = (0, theme_1.getRoleChalk)(role);
+        return {
+            text: colorFn(this.currentLevel),
+            priority: 10,
+        };
+    }
+    // ── DetailProvider ──
+    hasDetail() {
+        return this.lastInfo != null;
+    }
+    showDetail() {
+        if (this.lastInfo != null) {
+            (0, earthquake_formatter_1.displayTsunamiInfo)(this.lastInfo);
+        }
+    }
+}
+exports.TsunamiStateHolder = TsunamiStateHolder;