@sayue_ltr/fleq 1.50.0 → 1.51.0

package/dist/engine/presentation/processors/process-eew.js

@@ -0,0 +1,90 @@
+"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.processEew = processEew;
+const telegram_parser_1 = require("../../../dmdata/telegram-parser");
+const level_helpers_1 = require("../level-helpers");
+const log = __importStar(require("../../../logger"));
+/**
+ * EEW 電文を処理し結果を返す。
+ * - パース失敗: { kind: "parse-failed" }
+ * - 重複報: { kind: "duplicate" }
+ * - 正常: { kind: "ok", outcome }
+ */
+function processEew(msg, eewTracker, eewLogger) {
+    const eewInfo = (0, telegram_parser_1.parseEewTelegram)(msg);
+    if (!eewInfo)
+        return { kind: "parse-failed" };
+    const result = eewTracker.update(eewInfo);
+    if (result.isDuplicate) {
+        log.debug(`EEW 重複報スキップ: EventID=${eewInfo.eventId} 第${eewInfo.serial}報`);
+        return { kind: "duplicate" };
+    }
+    // ログ記録
+    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);
+    }
+    return {
+        kind: "ok",
+        outcome: {
+            domain: "eew",
+            msg,
+            headType: msg.head.type,
+            statsCategory: "eew",
+            parsed: eewInfo,
+            state: {
+                activeCount: result.activeCount,
+                colorIndex: result.colorIndex,
+                isCancelled: result.isCancelled,
+                diff: result.diff,
+            },
+            eewResult: result,
+            stats: {
+                shouldRecord: true,
+                eventId: eewInfo.eventId,
+            },
+            presentation: {
+                frameLevel: (0, level_helpers_1.eewFrameLevel)(eewInfo),
+                soundLevel: (0, level_helpers_1.eewSoundLevel)(eewInfo),
+                notifyCategory: "eew",
+            },
+        },
+    };
+}

package/dist/engine/presentation/processors/process-lg-observation.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processLgObservation = processLgObservation;
+const telegram_parser_1 = require("../../../dmdata/telegram-parser");
+const level_helpers_1 = require("../level-helpers");
+/**
+ * 長周期地震動観測情報 (VXSE62) を処理し LgObservationOutcome を返す。
+ * パース失敗の場合は null を返す。
+ */
+function processLgObservation(msg) {
+    const lgInfo = (0, telegram_parser_1.parseLgObservationTelegram)(msg);
+    if (!lgInfo)
+        return null;
+    return {
+        domain: "lgObservation",
+        msg,
+        headType: msg.head.type,
+        statsCategory: "earthquake", // routeToCategory("lgObservation") = "earthquake"
+        parsed: lgInfo,
+        stats: {
+            shouldRecord: true,
+            eventId: msg.xmlReport?.head.eventId ?? null,
+        },
+        presentation: {
+            frameLevel: (0, level_helpers_1.lgObservationFrameLevel)(lgInfo),
+            soundLevel: (0, level_helpers_1.lgObservationSoundLevel)(lgInfo),
+            notifyCategory: "lgObservation",
+        },
+    };
+}

package/dist/engine/presentation/processors/process-message.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processMessage = processMessage;
+const telegram_stats_1 = require("../../messages/telegram-stats");
+const process_eew_1 = require("./process-eew");
+const process_earthquake_1 = require("./process-earthquake");
+const process_seismic_text_1 = require("./process-seismic-text");
+const process_lg_observation_1 = require("./process-lg-observation");
+const process_tsunami_1 = require("./process-tsunami");
+const process_nankai_trough_1 = require("./process-nankai-trough");
+const process_raw_1 = require("./process-raw");
+/**
+ * ルートに応じた processXxx を呼び出し ProcessOutcome を返す。
+ * パース失敗の場合は RawOutcome にフォールバックする（元カテゴリを statsCategory に保持）。
+ *
+ * EEW の場合: パース失敗/重複は null を返す（表示も統計記録もしない）。
+ * 火山の場合: VFVO53 aggregator との連携は呼び出し側の責務。
+ */
+function processMessage(msg, route, deps) {
+    const category = (0, telegram_stats_1.routeToCategory)(route);
+    switch (route) {
+        case "eew": {
+            const eewResult = (0, process_eew_1.processEew)(msg, deps.eewTracker, deps.eewLogger);
+            if (eewResult.kind === "ok")
+                return eewResult.outcome;
+            if (eewResult.kind === "duplicate")
+                return null; // 重複 → 表示・統計なし
+            // parse-failed → raw 表示するが統計には含めない（旧 router と同じ動作）
+            const raw = (0, process_raw_1.processRaw)(msg, category);
+            raw.stats.shouldRecord = false;
+            return raw;
+        }
+        case "earthquake": {
+            return (0, process_earthquake_1.processEarthquake)(msg) ?? (0, process_raw_1.processRaw)(msg, category);
+        }
+        case "seismicText": {
+            return (0, process_seismic_text_1.processSeismicText)(msg) ?? (0, process_raw_1.processRaw)(msg, category);
+        }
+        case "lgObservation": {
+            return (0, process_lg_observation_1.processLgObservation)(msg) ?? (0, process_raw_1.processRaw)(msg, category);
+        }
+        case "tsunami": {
+            return (0, process_tsunami_1.processTsunami)(msg, deps.tsunamiState) ?? (0, process_raw_1.processRaw)(msg, category);
+        }
+        case "nankaiTrough": {
+            return (0, process_nankai_trough_1.processNankaiTrough)(msg) ?? (0, process_raw_1.processRaw)(msg, category);
+        }
+        // volcano: VolcanoRouteHandler が処理する (VFVO53 バッチ集約のため線形フローでは処理不可)
+        default: {
+            return (0, process_raw_1.processRaw)(msg, category);
+        }
+    }
+}

package/dist/engine/presentation/processors/process-nankai-trough.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processNankaiTrough = processNankaiTrough;
+const telegram_parser_1 = require("../../../dmdata/telegram-parser");
+const level_helpers_1 = require("../level-helpers");
+/**
+ * 南海トラフ電文 (VYSE50/51/52/60) を処理し NankaiTroughOutcome を返す。
+ * パース失敗の場合は null を返す。
+ */
+function processNankaiTrough(msg) {
+    const nankaiInfo = (0, telegram_parser_1.parseNankaiTroughTelegram)(msg);
+    if (!nankaiInfo)
+        return null;
+    return {
+        domain: "nankaiTrough",
+        msg,
+        headType: msg.head.type,
+        statsCategory: "nankaiTrough",
+        parsed: nankaiInfo,
+        stats: {
+            shouldRecord: true,
+            eventId: msg.xmlReport?.head.eventId ?? null,
+        },
+        presentation: {
+            frameLevel: (0, level_helpers_1.nankaiTroughFrameLevel)(nankaiInfo),
+            soundLevel: (0, level_helpers_1.nankaiTroughSoundLevel)(nankaiInfo),
+            notifyCategory: "nankaiTrough",
+        },
+    };
+}

package/dist/engine/presentation/processors/process-raw.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processRaw = processRaw;
+/**
+ * フォールバック: パース失敗等で認識できない電文の ProcessOutcome。
+ * statsCategory は呼び出し元から渡され、元ルートのカテゴリを保持する。
+ */
+function processRaw(msg, statsCategory = "other") {
+    return {
+        domain: "raw",
+        msg,
+        headType: msg.head.type,
+        statsCategory,
+        parsed: null,
+        stats: {
+            shouldRecord: true,
+        },
+        presentation: {
+            frameLevel: "info",
+        },
+    };
+}

package/dist/engine/presentation/processors/process-seismic-text.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processSeismicText = processSeismicText;
+const telegram_parser_1 = require("../../../dmdata/telegram-parser");
+const level_helpers_1 = require("../level-helpers");
+/**
+ * テキスト系地震電文 (VXSE56/VXSE60/VZSE40) を処理し SeismicTextOutcome を返す。
+ * パース失敗の場合は null を返す。
+ */
+function processSeismicText(msg) {
+    const textInfo = (0, telegram_parser_1.parseSeismicTextTelegram)(msg);
+    if (!textInfo)
+        return null;
+    return {
+        domain: "seismicText",
+        msg,
+        headType: msg.head.type,
+        statsCategory: "earthquake", // routeToCategory("seismicText") = "earthquake"
+        parsed: textInfo,
+        stats: {
+            shouldRecord: true,
+            eventId: msg.xmlReport?.head.eventId ?? null,
+        },
+        presentation: {
+            frameLevel: (0, level_helpers_1.seismicTextFrameLevel)(textInfo),
+            soundLevel: (0, level_helpers_1.seismicTextSoundLevel)(textInfo),
+            notifyCategory: "seismicText",
+        },
+    };
+}

package/dist/engine/presentation/processors/process-tsunami.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processTsunami = processTsunami;
+const telegram_parser_1 = require("../../../dmdata/telegram-parser");
+const level_helpers_1 = require("../level-helpers");
+/**
+ * 津波電文 (VTSE41/51/52) を処理し TsunamiOutcome を返す。
+ * VTSE41 のみ TsunamiStateHolder の状態更新を行い、更新前後のレベルを記録する。
+ * パース失敗の場合は null を返す。
+ */
+function processTsunami(msg, tsunamiState) {
+    const tsunamiInfo = (0, telegram_parser_1.parseTsunamiTelegram)(msg);
+    if (!tsunamiInfo)
+        return null;
+    const levelBefore = tsunamiState.getLevel();
+    // VTSE41 のみ状態更新
+    if (msg.head.type === "VTSE41") {
+        tsunamiState.update(tsunamiInfo);
+    }
+    const levelAfter = tsunamiState.getLevel();
+    return {
+        domain: "tsunami",
+        msg,
+        headType: msg.head.type,
+        statsCategory: "tsunami",
+        parsed: tsunamiInfo,
+        state: {
+            levelBefore,
+            levelAfter,
+            changed: levelBefore !== levelAfter,
+        },
+        stats: {
+            shouldRecord: true,
+            eventId: msg.xmlReport?.head.eventId ?? null,
+        },
+        presentation: {
+            frameLevel: (0, level_helpers_1.tsunamiFrameLevel)(tsunamiInfo),
+            soundLevel: (0, level_helpers_1.tsunamiSoundLevel)(tsunamiInfo),
+            notifyCategory: "tsunami",
+        },
+    };
+}

package/dist/engine/presentation/processors/process-volcano.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildVolcanoOutcome = buildVolcanoOutcome;
+const volcano_presentation_1 = require("../../notification/volcano-presentation");
+/**
+ * パース済み火山情報から VolcanoOutcome を構築する。
+ * VolcanoRouteHandler から使用される。
+ */
+function buildVolcanoOutcome(msg, volcanoInfo, volcanoState) {
+    const presentation = (0, volcano_presentation_1.resolveVolcanoPresentation)(volcanoInfo, volcanoState);
+    const isRenotification = volcanoInfo.kind === "alert"
+        ? volcanoState.isRenotification(volcanoInfo)
+        : false;
+    // Track state before/after for alert types
+    const trackedBefore = volcanoInfo.volcanoCode
+        ? (volcanoState.getEntry(volcanoInfo.volcanoCode)?.alertLevel?.toString() ?? null)
+        : null;
+    return {
+        domain: "volcano",
+        msg,
+        headType: msg.head.type,
+        statsCategory: "volcano",
+        parsed: volcanoInfo,
+        volcanoPresentation: presentation,
+        state: {
+            isRenotification,
+            trackedBefore,
+            // trackedAfter will be set by router after volcanoState.update()
+            trackedAfter: undefined,
+        },
+        stats: {
+            shouldRecord: true,
+            eventId: msg.xmlReport?.head.eventId ?? null,
+        },
+        presentation: {
+            frameLevel: presentation.frameLevel,
+            soundLevel: presentation.soundLevel,
+            notifyCategory: "volcano",
+        },
+    };
+}

package/dist/engine/presentation/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/engine/startup/config-resolver.js

@@ -133,6 +133,8 @@ function resolveConfig(opts) {
         eewLog: fileConfig.eewLog ?? types_1.DEFAULT_CONFIG.eewLog,
         eewLogFields: { ...types_1.DEFAULT_CONFIG.eewLogFields, ...fileConfig.eewLogFields },
         maxObservations: fileConfig.maxObservations ?? types_1.DEFAULT_CONFIG.maxObservations,
+        nightMode: opts.night ?? fileConfig.nightMode ?? types_1.DEFAULT_CONFIG.nightMode,
+        summaryInterval: fileConfig.summaryInterval ?? types_1.DEFAULT_CONFIG.summaryInterval,
         backup: fileConfig.backup ?? types_1.DEFAULT_CONFIG.backup,
         truncation: { ...types_1.DEFAULT_CONFIG.truncation, ...fileConfig.truncation },
     };

package/dist/engine/template/compile-template.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileTemplate = compileTemplate;
+const parser_1 = require("./parser");
+const compiler_1 = require("./compiler");
+/**
+ * テンプレート文字列をコンパイルし、TemplateRenderer を返す。
+ *
+ * 使用例:
+ * ```ts
+ * const render = compileTemplate("{{title}} M{{magnitude|default:\"-\"}}");
+ * const text = render(event);
+ * ```
+ */
+function compileTemplate(template) {
+    const nodes = (0, parser_1.parseTemplate)(template);
+    return (0, compiler_1.compileTemplateNodes)(nodes);
+}

package/dist/engine/template/compiler.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileTemplateNodes = compileTemplateNodes;
+const field_accessor_1 = require("./field-accessor");
+const filters_1 = require("./filters");
+/**
+ * TemplateNode[] を TemplateRenderer にコンパイルする。
+ */
+function compileTemplateNodes(nodes) {
+    return (event) => {
+        return renderNodes(nodes, event);
+    };
+}
+function renderNodes(nodes, event) {
+    let result = "";
+    for (const node of nodes) {
+        switch (node.kind) {
+            case "text":
+                result += node.value;
+                break;
+            case "interpolation":
+                result += renderInterpolation(node.expr, node.filters, event);
+                break;
+            case "if":
+                result += renderIfBlock(node, event);
+                break;
+        }
+    }
+    return result;
+}
+function renderInterpolation(expr, filters, event) {
+    let value = resolveExpr(expr, event);
+    for (const filter of filters) {
+        const args = filter.args.map((a) => resolveExprLiteral(a, event));
+        value = (0, filters_1.applyFilter)(filter.name, value, args);
+    }
+    return stringify(value);
+}
+function renderIfBlock(node, event) {
+    const result = evaluatePredicate(node.test, event);
+    if (result) {
+        return renderNodes(node.body, event);
+    }
+    if (node.elseBody) {
+        return renderNodes(node.elseBody, event);
+    }
+    return "";
+}
+function resolveExpr(expr, event) {
+    if (expr.kind === "literal")
+        return expr.value;
+    return (0, field_accessor_1.getFieldValue)(event, expr.segments);
+}
+function resolveExprLiteral(expr, event) {
+    const val = resolveExpr(expr, event);
+    if (val == null)
+        return null;
+    if (typeof val === "string" || typeof val === "number" || typeof val === "boolean") {
+        return val;
+    }
+    return String(val);
+}
+function evaluatePredicate(pred, event) {
+    if (pred.kind === "truthy") {
+        const val = resolveExpr(pred.expr, event);
+        return isTruthy(val);
+    }
+    const left = resolveExpr(pred.left, event);
+    const right = resolveExpr(pred.right, event);
+    switch (pred.op) {
+        case "eq":
+            return left === right;
+        case "ne":
+            return left !== right;
+        case "gt":
+            return Number(left) > Number(right);
+        case "ge":
+            return Number(left) >= Number(right);
+        case "lt":
+            return Number(left) < Number(right);
+        case "le":
+            return Number(left) <= Number(right);
+    }
+}
+function isTruthy(val) {
+    if (val == null)
+        return false;
+    if (val === false)
+        return false;
+    if (val === "")
+        return false;
+    if (val === 0)
+        return false;
+    return true;
+}
+function stringify(value) {
+    if (value == null)
+        return "";
+    if (Array.isArray(value))
+        return value.join(", ");
+    return String(value);
+}

package/dist/engine/template/field-accessor.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFieldValue = getFieldValue;
+/**
+ * PresentationEvent からドットパス + index access で値を取得する。
+ *
+ * segments 例:
+ * - ["title"]              → event.title
+ * - ["raw", "xxx"]         → event.raw.xxx
+ * - ["areaItems", 0, "name"] → event.areaItems[0].name
+ */
+function getFieldValue(event, segments) {
+    let current = event;
+    for (const seg of segments) {
+        if (current == null)
+            return undefined;
+        if (typeof current === "object") {
+            current = current[seg];
+        }
+        else {
+            return undefined;
+        }
+    }
+    return current;
+}

package/dist/engine/template/filters.js

@@ -0,0 +1,94 @@
+"use strict";
+// ── Template filter functions ──
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyFilter = applyFilter;
+function toString(value) {
+    if (value == null)
+        return "";
+    return String(value);
+}
+function filterDefault(value, args) {
+    if (value == null || value === "") {
+        return args[0] ?? "";
+    }
+    return value;
+}
+function filterTruncate(value, args) {
+    const str = toString(value);
+    const limit = typeof args[0] === "number" ? args[0] : Number(args[0]);
+    if (!Number.isFinite(limit) || str.length <= limit)
+        return str;
+    return str.slice(0, limit);
+}
+function filterPad(value, args) {
+    const str = toString(value);
+    const width = typeof args[0] === "number" ? args[0] : Number(args[0]);
+    if (!Number.isFinite(width))
+        return str;
+    return str.padEnd(width);
+}
+function filterJoin(value, args) {
+    if (!Array.isArray(value))
+        return toString(value);
+    const separator = args[0] != null ? String(args[0]) : ",";
+    return value.join(separator);
+}
+function filterDate(value, args) {
+    const format = args[0] != null ? String(args[0]) : "HH:mm";
+    const date = value instanceof Date ? value : new Date(String(value));
+    if (isNaN(date.getTime()))
+        return toString(value);
+    const HH = String(date.getHours()).padStart(2, "0");
+    const mm = String(date.getMinutes()).padStart(2, "0");
+    const ss = String(date.getSeconds()).padStart(2, "0");
+    const MM = String(date.getMonth() + 1).padStart(2, "0");
+    const DD = String(date.getDate()).padStart(2, "0");
+    switch (format) {
+        case "HH:mm":
+            return `${HH}:${mm}`;
+        case "HH:mm:ss":
+            return `${HH}:${mm}:${ss}`;
+        case "MM/DD HH:mm":
+            return `${MM}/${DD} ${HH}:${mm}`;
+        default:
+            return `${HH}:${mm}`;
+    }
+}
+function filterReplace(value, args) {
+    const str = toString(value);
+    const search = args[0] != null ? String(args[0]) : "";
+    const replacement = args[1] != null ? String(args[1]) : "";
+    return str.split(search).join(replacement);
+}
+function filterUpper(value) {
+    return toString(value).toUpperCase();
+}
+function filterLower(value) {
+    return toString(value).toLowerCase();
+}
+/**
+ * テンプレートフィルタを適用する。
+ * 未知のフィルタ名の場合は値をそのまま返す。
+ */
+function applyFilter(name, value, args) {
+    switch (name) {
+        case "default":
+            return filterDefault(value, args);
+        case "truncate":
+            return filterTruncate(value, args);
+        case "pad":
+            return filterPad(value, args);
+        case "join":
+            return filterJoin(value, args);
+        case "date":
+            return filterDate(value, args);
+        case "replace":
+            return filterReplace(value, args);
+        case "upper":
+            return filterUpper(value);
+        case "lower":
+            return filterLower(value);
+        default:
+            return value;
+    }
+}

package/dist/engine/template/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileTemplate = void 0;
+var compile_template_1 = require("./compile-template");
+Object.defineProperty(exports, "compileTemplate", { enumerable: true, get: function () { return compile_template_1.compileTemplate; } });