koishi-plugin-disaster-warning 0.1.1 → 0.1.3

package/README.md

@@ -1,61 +1,69 @@
-# koishi-plugin-disaster-warning
-
-[![npm](https://img.shields.io/npm/v/koishi-plugin-disaster-warning?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-disaster-warning)
-
-Koishi 灾害预警插件，支持多数据源（地震、海啸、气象预警）实时推送。
-本插件移植自 [astrbot_plugin_disaster_warning](https://github.com/DBJD-CR/astrbot_plugin_disaster_warning)，感谢原作者的开源贡献。
-
-## ✨ 功能特性
-
-### 🌍 多数据源支持
-插件支持多个可自由选择启用的细粒度数据源，覆盖全球主要地震监测机构：
-- **中国地震网地震预警 (FAN Studio / Wolfx)** - 实时地震预警信息。
-- **台湾中央气象署强震即时警报 (FAN Studio / Wolfx)** - 台湾地区地震预警。
-- **日本气象厅紧急地震速报 (P2P / Wolfx / FAN Studio)** - 日本紧急地震速报。
-- **中国地震台网地震测定 (FAN Studio / Wolfx)** - 正式地震测定信息。
-- **日本气象厅地震情报 (P2P / Wolfx)** - 详细地震情报。
-- **USGS地震测定 (FAN Studio)** - 美国地质调查局地震信息。
-- **Global Quake服务器** - 全球地震测站实时计算推送，精度有限。
-- **中国气象局气象预警 (FAN Studio)** - 气象灾害预警。
-- **自然资源部海啸预警中心 (FAN Studio)** - 海啸预警信息。
-- **日本气象厅海啸预报 (P2P)** - 日本海啸预报信息。
-
-### 🎯 智能推送控制
-- **阈值过滤** - 根据震级、烈度、震度设置推送阈值。
-- **频率控制** - 智能推送逻辑，避免短时间内刷屏。
-- **首报推送保证** - 确保预警信息首次下达时总是推送。
-- **最终报保证** - 确保最终报总是推送。
-
-### 🔁 事件去重功能
-插件具备基础的事件去重功能，防止同一地震被同一个数据源重复推送。
-
-## 🚀 安装与使用
-
-### 安装
-
-```bash
-npm install koishi-plugin-disaster-warning
-```
-
-或者在 Koishi 插件市场搜索 `disaster-warning` 安装。
-
-### 配置
-
-安装完成后，在 Koishi 控制台的「插件配置」页面进行配置：
-
-1. **启用插件**：确保 `enabled` 为 `true`。
-2. **目标群组**：在 `target_groups` 中添加需要推送预警消息的群号。
-3. **数据源配置**：在 `data_sources` 中按需启用或禁用各个数据源。
-4. **过滤器配置**：在 `earthquake_filters` 中设置震级和烈度阈值，避免过多打扰。
-
-## 📋 使用命令
-
-插件提供以下指令：
-
-- `disaster` - 查看插件帮助信息
-- `disaster.test` - 发送一条测试预警消息，用于验证配置是否生效
-- `disaster.history` - 查看最近的地震记录 (数据来源：CENC)
-
-## 📄 许可证
-
-本项目采用 [AGPL-3.0](./LICENSE) 许可证。
+# koishi-plugin-disaster-warning
+
+[![npm](https://img.shields.io/npm/v/koishi-plugin-disaster-warning?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-disaster-warning)
+
+Koishi 灾害预警插件，支持多数据源（地震、海啸、气象预警）实时推送。
+本插件移植自 [astrbot_plugin_disaster_warning](https://github.com/DBJD-CR/astrbot_plugin_disaster_warning)，感谢原作者的开源贡献。
+
+## ✨ 功能特性
+
+### 🌍 多数据源支持
+插件支持多个可自由选择启用的细粒度数据源，覆盖全球主要地震监测机构：
+- **中国地震网地震预警 (FAN Studio / Wolfx)** - 实时地震预警信息。
+- **台湾中央气象署强震即时警报 (FAN Studio / Wolfx)** - 台湾地区地震预警。
+- **日本气象厅紧急地震速报 (P2P / Wolfx / FAN Studio)** - 日本紧急地震速报。
+- **中国地震台网地震测定 (FAN Studio / Wolfx)** - 正式地震测定信息。
+- **日本气象厅地震情报 (P2P / Wolfx)** - 详细地震情报。
+- **USGS地震测定 (FAN Studio)** - 美国地质调查局地震信息。
+- **Global Quake服务器** - 全球地震测站实时计算推送，精度有限。
+- **中国气象局气象预警 (FAN Studio)** - 气象灾害预警。
+- **自然资源部海啸预警中心 (FAN Studio)** - 海啸预警信息。
+- **日本气象厅海啸预报 (P2P)** - 日本海啸预报信息。
+
+### 🎯 智能推送控制
+- **阈值过滤** - 根据震级、烈度、震度设置推送阈值。
+- **频率控制** - 智能推送逻辑，避免短时间内刷屏。
+- **首报推送保证** - 确保预警信息首次下达时总是推送。
+- **震中地区过滤** - 地震类事件会按震中地名与经纬度过滤，关闭全球地区后，CENC 等数据源发布的海外地震不会再误推送。
+- **最终报保证** - 确保最终报总是推送。
+
+### 🔁 事件去重功能
+插件具备基础的事件去重功能，防止同一地震被同一个数据源重复推送。
+
+## 🚀 安装与使用
+
+### 安装
+
+```bash
+npm install koishi-plugin-disaster-warning
+```
+
+或者在 Koishi 插件市场搜索 `disaster-warning` 安装。
+
+### 配置
+
+安装完成后，在 Koishi 控制台的「插件配置」页面进行配置：
+
+1. **启用插件**：确保 `enabled` 为 `true`。
+2. **目标群组**：在 `target_groups` 中添加需要推送预警消息的群号。
+3. **灾害类型**：在 `data_types` 中选择是否接收地震预警、地震信息、海啸预警、气象预警。
+4. **接收地区**：在 `regions` 中选择中国大陆、台湾、日本或全球。数据源连接会依据此项自动开启，地震类事件还会按震中位置再次过滤。
+5. **过滤器配置**：在 `filter` 中设置震级、烈度、震度阈值，避免过多打扰。
+
+### 地区过滤说明
+
+`regions` 同时控制数据源连接与地震震中地区过滤。例如仅开启中国大陆和台湾、关闭日本与全球时，插件仍可连接 CENC/CWA 等相关数据源，但智利、印尼等不在已开启地区内的地震会被丢弃，不会因为由 CENC 发布就被推送。
+
+当前震中识别优先使用地名关键词，其次使用经纬度范围；无法识别且带有非空地名的地震默认视为全球事件。
+
+## 📋 使用命令
+
+插件提供以下指令：
+
+- `disaster` - 查看插件帮助信息
+- `disaster.test` - 发送一条测试预警消息，用于验证配置是否生效
+- `disaster.history` - 查看最近的地震记录 (数据来源：CENC)
+
+## 📄 许可证
+
+本项目采用 [AGPL-3.0](./LICENSE) 许可证。

package/lib/index.js

@@ -15,8 +15,8 @@ exports.Config = koishi_1.Schema.object({
         .default([])
         .description('推送目标群号列表，直接填写群号即可，例如 123456789'),
     data_types: koishi_1.Schema.object({
-        earthquake_warning: koishi_1.Schema.boolean().default(true).description('地震预警（实时速报，震前预警）'),
-        earthquake_info: koishi_1.Schema.boolean().default(true).description('地震信息（震后测定报告）'),
+        earthquake_warning: koishi_1.Schema.boolean().default(true).description('地震预警（实时速报，震前预警，会持续推送刷屏）'),
+        earthquake_info: koishi_1.Schema.boolean().default(true).description('地震信息（震后测定报告，同一事件只推一次）'),
         tsunami_warning: koishi_1.Schema.boolean().default(true).description('海啸预警'),
         weather_alarm: koishi_1.Schema.boolean().default(false).description('气象预警（中国）'),
     }).description('接收的灾害类型'),
@@ -25,7 +25,7 @@ exports.Config = koishi_1.Schema.object({
         taiwan: koishi_1.Schema.boolean().default(true).description('台湾（CWA预警与地震报告）'),
         japan: koishi_1.Schema.boolean().default(true).description('日本（JMA EEW / P2P地震情报 / 海啸）'),
         global: koishi_1.Schema.boolean().default(false).description('全球（USGS 地震信息 / GlobalQuake 实时预警）'),
-    }).description('接收的地区（数据源连接将依据此项自动开启）'),
+    }).description('接收的地区（数据源连接将依据此项自动开启，地震类事件会按震中位置过滤）'),
     filter: koishi_1.Schema.object({
         min_magnitude_absolute: koishi_1.Schema.number().default(3.0).description('绝对过滤震级：低于此震级直接丢弃（不推送）'),
         min_magnitude_for_push: koishi_1.Schema.number().default(4.0).description('推送震级门槛：震级达到此值则推送'),

package/lib/models.d.ts

@@ -106,14 +106,21 @@ export interface DisasterEvent {
 }
 /**
  * 跨数据源事件去重器
- * 用 place+magnitude+分钟桶 作为指纹，窗口期内同一事件只推一次
+ * 地震预警按报次去重，允许后续修正继续推送；震后测定按内容去重，同一事件只推一次。
  */
 export declare class EventDeduplicator {
     private seen;
-    private windowMs;
-    constructor(windowMs?: number);
+    private warningWindowMs;
+    private earthquakeInfoWindowMs;
+    constructor(warningWindowMs?: number, earthquakeInfoWindowMs?: number);
     /** 返回 true 表示已见过（应丢弃），false 表示首次（应推送） */
     isDuplicate(event: DisasterEvent): boolean;
     private fingerprint;
+    private ttlFor;
+    private earthquakeInfoFingerprint;
+    private fallbackEarthquakeId;
+    private normalizeLocation;
+    private normalizeTime;
+    private normalizeNumber;
     private evict;
 }

package/lib/models.js

@@ -55,13 +55,14 @@ function getDataSourceFromId(id) {
 }
 /**
  * 跨数据源事件去重器
- * 用 place+magnitude+分钟桶 作为指纹，窗口期内同一事件只推一次
+ * 地震预警按报次去重，允许后续修正继续推送；震后测定按内容去重，同一事件只推一次。
  */
 class EventDeduplicator {
-    constructor(windowMs = 8 * 60 * 1000) {
-        // fingerprint -> first-seen timestamp (ms)
+    constructor(warningWindowMs = 8 * 60 * 1000, earthquakeInfoWindowMs = 7 * 24 * 60 * 60 * 1000) {
+        // fingerprint -> expire timestamp (ms)
         this.seen = new Map();
-        this.windowMs = windowMs;
+        this.warningWindowMs = warningWindowMs;
+        this.earthquakeInfoWindowMs = earthquakeInfoWindowMs;
     }
     /** 返回 true 表示已见过（应丢弃），false 表示首次（应推送） */
     isDuplicate(event) {
@@ -69,26 +70,65 @@ class EventDeduplicator {
         const fp = this.fingerprint(event);
         if (this.seen.has(fp))
             return true;
-        this.seen.set(fp, Date.now());
+        this.seen.set(fp, Date.now() + this.ttlFor(event));
         return false;
     }
     fingerprint(event) {
         const data = event.data;
-        if (event.disaster_type === DisasterType.EARTHQUAKE || event.disaster_type === DisasterType.EARTHQUAKE_WARNING) {
-            // 优先用 event_id，相同机构的多数据源共享同一 event_id
-            if (data.event_id)
-                return `eq:${data.event_id}`;
-            // 降级：地点 + 震级 + 分钟桶
-            const bucket = data.shock_time ? data.shock_time.slice(0, 16) : 'unknown';
-            return `eq:${data.place_name}|${data.magnitude?.toFixed(1)}|${bucket}`;
+        if (event.disaster_type === DisasterType.EARTHQUAKE_WARNING) {
+            const eventId = data.event_id || this.fallbackEarthquakeId(data);
+            const revision = data.revision ?? data.report_num ?? data.serial ?? data.updates ?? 'unknown';
+            const status = data.is_cancel ? 'cancel' : data.is_final ? 'final' : 'update';
+            return `eqw:${eventId}|${revision}|${status}`;
+        }
+        if (event.disaster_type === DisasterType.EARTHQUAKE) {
+            return `eq:${this.earthquakeInfoFingerprint(data)}`;
         }
         // 海啸/气象用 id 即可
         return `${event.disaster_type}:${event.id}`;
     }
+    ttlFor(event) {
+        return event.disaster_type === DisasterType.EARTHQUAKE
+            ? this.earthquakeInfoWindowMs
+            : this.warningWindowMs;
+    }
+    earthquakeInfoFingerprint(data) {
+        const originTime = this.normalizeTime(data.shock_time);
+        const location = this.normalizeLocation(data);
+        const magnitude = this.normalizeNumber(data.magnitude, 1);
+        const depth = this.normalizeNumber(data.depth, 1);
+        const intensity = this.normalizeNumber(data.intensity, 1);
+        const scale = this.normalizeNumber(data.scale, 1);
+        return `${location}|${originTime}|M${magnitude}|D${depth}|I${intensity}|S${scale}`;
+    }
+    fallbackEarthquakeId(data) {
+        const originTime = this.normalizeTime(data.shock_time);
+        const location = this.normalizeLocation(data);
+        return `${location}|${data.magnitude?.toFixed(1)}|${originTime}`;
+    }
+    normalizeLocation(data) {
+        const place = data.place_name?.replace(/\s+/g, '').trim();
+        if (place)
+            return place;
+        const lat = Number.isFinite(data.latitude) ? data.latitude.toFixed(2) : 'unknown';
+        const lon = Number.isFinite(data.longitude) ? data.longitude.toFixed(2) : 'unknown';
+        return `${lat},${lon}`;
+    }
+    normalizeTime(time) {
+        if (!time)
+            return 'unknown';
+        const date = new Date(time);
+        if (isNaN(date.getTime()))
+            return time.slice(0, 19);
+        return date.toISOString().slice(0, 19);
+    }
+    normalizeNumber(value, digits) {
+        return Number.isFinite(value) ? value.toFixed(digits) : 'unknown';
+    }
     evict() {
-        const cutoff = Date.now() - this.windowMs;
-        for (const [fp, ts] of this.seen) {
-            if (ts < cutoff)
+        const now = Date.now();
+        for (const [fp, expiresAt] of this.seen) {
+            if (expiresAt < now)
                 this.seen.delete(fp);
         }
     }

package/lib/pusher.js

@@ -60,9 +60,9 @@ class MessagePushManager {
     }
     formatEarthquake(data) {
         const type = data.disaster_type === models_1.DisasterType.EARTHQUAKE_WARNING ? '🚨 地震预警' : '📋 地震信息';
-        const finalStr = data.is_final ? '【最终报】' : `【第${data.updates}报】`;
+        const finalStr = data.is_final ? ' 【最终报】' : '';
         const cancelStr = data.is_cancel ? '【已取消】' : '';
-        let msg = `${cancelStr}${type} ${finalStr}\n`;
+        let msg = `${cancelStr}${type}${finalStr}\n`;
         msg += `📍 震源：${data.place_name}\n`;
         msg += `🕐 时间：${this.formatTime(data.shock_time)}\n`;
         msg += `📊 震级：M${data.magnitude?.toFixed(1) || '未知'}\n`;

package/lib/service.d.ts

@@ -19,6 +19,20 @@ export declare class DisasterWarningService {
     private startWolfxHttpPoller;
     private handleEvent;
     private shouldPushEvent;
+    private shouldPushEarthquakeByLocation;
+    private detectEarthquakeRegion;
+    private detectRegionByPlace;
+    private includesAny;
+    private validLatitude;
+    private validLongitude;
+    private isTaiwanCoordinate;
+    private isJapanCoordinate;
+    private isMainlandChinaCoordinate;
+    private pointInPolygon;
+    private fallbackRegionForMissingCoordinates;
+    private shouldAllowUnknownEarthquakeRegion;
+    private fallbackRegionBySource;
+    private isRegionEnabled;
     getStatus(): Record<string, {
         connected: boolean;
         retryCount: number;

package/lib/service.js

@@ -210,8 +210,192 @@ class DisasterWarningService {
             return false;
         if (globalSources.includes(src) && !regions.global)
             return false;
+        if ((isEarthquakeWarning || isEarthquakeInfo) && !this.shouldPushEarthquakeByLocation(event)) {
+            const data = event.data;
+            logger.debug(`[region] Skipping earthquake outside enabled regions: ${data.place_name || event.id}`);
+            return false;
+        }
         return true;
     }
+    shouldPushEarthquakeByLocation(event) {
+        const region = this.detectEarthquakeRegion(event.data, event.source);
+        switch (region) {
+            case 'china':
+                return this.config.regions.china;
+            case 'taiwan':
+                return this.config.regions.taiwan;
+            case 'japan':
+                return this.config.regions.japan;
+            case 'global':
+                return this.config.regions.global;
+            case 'unknown':
+                return this.shouldAllowUnknownEarthquakeRegion(event.source);
+        }
+    }
+    detectEarthquakeRegion(data, source) {
+        const place = data.place_name?.replace(/\s+/g, '').toLowerCase() || '';
+        const placeRegion = this.detectRegionByPlace(place);
+        if (placeRegion)
+            return placeRegion;
+        const lat = this.validLatitude(data.latitude);
+        const lon = this.validLongitude(data.longitude);
+        if (lat === undefined || lon === undefined)
+            return this.fallbackRegionForMissingCoordinates(data, source, place);
+        // Many upstream cancellation packets use 0,0 when coordinates are unavailable.
+        if (lat === 0 && lon === 0)
+            return this.fallbackRegionForMissingCoordinates(data, source, place);
+        if (this.isTaiwanCoordinate(lat, lon))
+            return 'taiwan';
+        if (this.isJapanCoordinate(lat, lon))
+            return 'japan';
+        if (this.isMainlandChinaCoordinate(lat, lon))
+            return 'china';
+        return 'global';
+    }
+    detectRegionByPlace(place) {
+        if (!place)
+            return null;
+        if (this.includesAny(place, [
+            '台湾', '臺灣', '台灣', 'taiwan', '花莲', '花蓮', '宜兰', '宜蘭', '台东', '臺東', '台東',
+            '台北', '臺北', '新北', '桃园', '桃園', '台中', '臺中', '台南', '臺南', '高雄', '嘉义', '嘉義',
+            '屏东', '屏東', '南投', '澎湖'
+        ]))
+            return 'taiwan';
+        if (this.includesAny(place, [
+            '日本', 'japan', '北海道', '本州', '四国', '四國', '九州', '沖縄', '冲绳', '琉球', '小笠原',
+            '伊豆', '鳥島', '鸟岛', '青森', '岩手', '宮城', '宫城', '秋田', '山形', '福島', '福岛',
+            '茨城', '栃木', '群馬', '群马', '埼玉', '千葉', '千叶', '東京', '东京', '神奈川', '新潟',
+            '富山', '石川', '福井', '山梨', '長野', '长野', '岐阜', '静岡', '静冈', '愛知', '爱知',
+            '三重', '滋賀', '滋贺', '京都', '大阪', '兵庫', '兵库', '奈良', '和歌山', '鳥取', '鸟取',
+            '島根', '岛根', '岡山', '冈山', '広島', '广岛', '山口', '徳島', '德岛', '香川', '愛媛',
+            '爱媛', '高知', '福岡', '福冈', '佐賀', '佐贺', '長崎', '长崎', '熊本', '大分', '宮崎',
+            '宫崎', '鹿児島', '鹿儿岛'
+        ]))
+            return 'japan';
+        if (this.includesAny(place, [
+            '中国', 'china', '北京', '天津', '河北', '山西', '内蒙古', '辽宁', '遼寧', '吉林', '黑龙江',
+            '黑龍江', '上海', '江苏', '江蘇', '浙江', '安徽', '福建', '江西', '山东', '山東', '河南',
+            '湖北', '湖南', '广东', '廣東', '广西', '廣西', '海南', '重庆', '重慶', '四川', '贵州',
+            '貴州', '云南', '雲南', '西藏', '陕西', '陝西', '甘肃', '甘肅', '青海', '宁夏', '寧夏',
+            '新疆', '香港', '澳门', '澳門'
+        ]))
+            return 'china';
+        return null;
+    }
+    includesAny(text, keywords) {
+        return keywords.some((keyword) => text.includes(keyword.toLowerCase()));
+    }
+    validLatitude(value) {
+        return Number.isFinite(value) && value >= -90 && value <= 90 ? value : undefined;
+    }
+    validLongitude(value) {
+        return Number.isFinite(value) && value >= -180 && value <= 180 ? value : undefined;
+    }
+    isTaiwanCoordinate(lat, lon) {
+        return lat >= 21.5 && lat <= 26.5 && lon >= 119 && lon <= 123.8;
+    }
+    isJapanCoordinate(lat, lon) {
+        const mainIslands = lat >= 30 && lat <= 46.5 && lon >= 129 && lon <= 146.5;
+        const ryukyu = lat >= 24 && lat < 30 && lon >= 122 && lon <= 131.5;
+        const izuOgasawara = lat >= 20 && lat <= 34 && lon >= 139 && lon <= 154.5;
+        return mainIslands || ryukyu || izuOgasawara;
+    }
+    isMainlandChinaCoordinate(lat, lon) {
+        if (lat >= 18 && lat <= 20.5 && lon >= 108 && lon <= 111.5)
+            return true;
+        // Rough mainland China outline. Place-name detection runs first, this is only a coordinate fallback.
+        return this.pointInPolygon(lon, lat, [
+            [73.5, 39.5],
+            [74.9, 37.2],
+            [75.5, 35.4],
+            [78.4, 32.5],
+            [78.7, 30.2],
+            [80.5, 30.0],
+            [81.8, 28.5],
+            [85.2, 28.3],
+            [88.9, 27.3],
+            [91.0, 27.8],
+            [93.3, 28.7],
+            [95.5, 28.2],
+            [97.3, 23.8],
+            [98.9, 24.1],
+            [100.1, 21.4],
+            [101.8, 21.2],
+            [103.8, 22.5],
+            [106.8, 20.0],
+            [108.7, 18.2],
+            [111.3, 18.0],
+            [113.7, 21.8],
+            [116.7, 22.7],
+            [118.5, 24.5],
+            [121.8, 29.0],
+            [122.2, 31.8],
+            [121.5, 35.0],
+            [124.0, 39.8],
+            [126.8, 41.9],
+            [130.0, 42.3],
+            [134.7, 48.2],
+            [131.0, 47.7],
+            [128.0, 49.6],
+            [123.3, 53.5],
+            [119.5, 50.0],
+            [117.0, 49.6],
+            [111.0, 49.2],
+            [105.0, 45.0],
+            [97.0, 42.8],
+            [91.0, 45.2],
+            [87.0, 49.0],
+            [82.0, 47.2],
+            [79.0, 43.0],
+        ]);
+    }
+    pointInPolygon(lon, lat, polygon) {
+        let inside = false;
+        for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+            const xi = polygon[i][0];
+            const yi = polygon[i][1];
+            const xj = polygon[j][0];
+            const yj = polygon[j][1];
+            const intersects = ((yi > lat) !== (yj > lat)) &&
+                (lon < (xj - xi) * (lat - yi) / (yj - yi) + xi);
+            if (intersects)
+                inside = !inside;
+        }
+        return inside;
+    }
+    fallbackRegionForMissingCoordinates(data, source, place) {
+        if (place && !data.is_cancel)
+            return 'global';
+        return this.fallbackRegionBySource(source);
+    }
+    shouldAllowUnknownEarthquakeRegion(source) {
+        const fallback = this.fallbackRegionBySource(source);
+        if (fallback === 'unknown')
+            return this.config.regions.global;
+        return this.isRegionEnabled(fallback);
+    }
+    fallbackRegionBySource(source) {
+        if ([models_1.DataSource.FAN_STUDIO_CEA, models_1.DataSource.FAN_STUDIO_CENC, models_1.DataSource.WOLFX_CENC_EEW, models_1.DataSource.WOLFX_CENC_EQ].includes(source))
+            return 'china';
+        if ([models_1.DataSource.FAN_STUDIO_CWA, models_1.DataSource.WOLFX_CWA_EEW].includes(source))
+            return 'taiwan';
+        if ([models_1.DataSource.FAN_STUDIO_JMA, models_1.DataSource.P2P_EEW, models_1.DataSource.P2P_EARTHQUAKE, models_1.DataSource.WOLFX_JMA_EEW, models_1.DataSource.WOLFX_JMA_EQ].includes(source))
+            return 'japan';
+        if ([models_1.DataSource.FAN_STUDIO_USGS, models_1.DataSource.GLOBAL_QUAKE].includes(source))
+            return 'global';
+        return 'unknown';
+    }
+    isRegionEnabled(region) {
+        if (region === 'china')
+            return this.config.regions.china;
+        if (region === 'taiwan')
+            return this.config.regions.taiwan;
+        if (region === 'japan')
+            return this.config.regions.japan;
+        if (region === 'global')
+            return this.config.regions.global;
+        return false;
+    }
     // ---- 状态查询（供 commands 使用）------------------------------------
     getStatus() {
         const result = {};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "koishi-plugin-disaster-warning",
-    "version": "0.1.1",
+    "version": "0.1.3",
     "description": "Koishi 灾害预警插件，支持多数据源（地震、海啸、气象预警）",
     "contributors": [
         "lumia.wang <fenglian19980510@gmail.com>"
@@ -38,8 +38,7 @@
         "@types/node": "^20.0.0",
         "@types/ws": "^8.5.10",
         "koishi": "^4.18.0",
-        "typescript": "^5.0.0",
-        "ws": "^8.18.0"
+        "typescript": "^5.0.0"
     },
     "koishi": {
         "description": {
@@ -54,5 +53,8 @@
                 "database"
             ]
         }
+    },
+    "dependencies": {
+        "ws": "^8.18.0"
     }
 }