koishi-plugin-rocom 1.0.19 → 1.0.24

package/lib/merchant-catalog.d.ts

@@ -0,0 +1,47 @@
+export declare const MERCHANT_ALL_ALIASES: Set<string>;
+export interface MerchantCatalogItem {
+    index: number;
+    name: string;
+    goods_id: number;
+    item_id: number;
+    item_num: number;
+}
+export declare function isAllAlias(token?: string): boolean;
+/**
+ * 把后端商品池归一成带序号的目录。
+ *
+ * 序号只取后端返回的顺序（index = 位置 + 1），解析订阅时立刻换成商品名落盘，
+ * 所以后端调整目录顺序不会影响已有订阅。
+ */
+export declare function buildMerchantCatalog(randomGoods: unknown): MerchantCatalogItem[];
+/**
+ * 解析用户输入：序号 / 商品名 / 全部。
+ *
+ * - 纯数字按序号查目录，命中后换成规范名
+ * - 目录里没有的文字按原样保留（后端随时会加新商品），同时记进 unrecognizedNames 供提示
+ * - 目录为空（离线）时不报未识别，避免误伤
+ */
+export declare function resolveMerchantSelection(input: unknown, catalog: MerchantCatalogItem[]): {
+    all: boolean;
+    names: string[];
+    unknownIndexes: string[];
+    unrecognizedNames: string[];
+};
+/** 把订阅的商品名回显成「序号.名称」，方便用户对照商品列表。 */
+export declare function describeMerchantItems(names: unknown, catalog: MerchantCatalogItem[]): string;
+export declare class MerchantCatalogService {
+    private filePath;
+    private fetchRandomGoods;
+    private memory;
+    constructor(filePath: string, fetchRandomGoods: () => Promise<any>);
+    /** 同步读磁盘缓存，供命令在离线时兜底。 */
+    loadCachedCatalog(): MerchantCatalogItem[];
+    writeCache(items: MerchantCatalogItem[]): boolean;
+    /**
+     * 取商品目录：内存缓存 → 后端全量商品池 → 磁盘缓存。
+     * 全链路失败时返回上一次的目录（可能为空），由调用方决定怎么提示。
+     */
+    getCatalog(options?: {
+        refresh?: boolean;
+    }): Promise<MerchantCatalogItem[]>;
+}

package/lib/merchant-catalog.js

@@ -0,0 +1,193 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MerchantCatalogService = exports.MERCHANT_ALL_ALIASES = void 0;
+exports.isAllAlias = isAllAlias;
+exports.buildMerchantCatalog = buildMerchantCatalog;
+exports.resolveMerchantSelection = resolveMerchantSelection;
+exports.describeMerchantItems = describeMerchantItems;
+const koishi_1 = require("koishi");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const logger = new koishi_1.Logger('rocom-merchant');
+// 把后端商品池（merchant/info?random_goods=all）归一成带序号的目录，
+// 供「商人商品」列表展示与「订阅远行商人 1 3 5」按序号订阅使用。
+// 商品池变化很慢，内存缓存 6 小时，避免订阅轮询反复拉全量。
+const CATALOG_TTL_MS = 6 * 60 * 60 * 1000;
+// 「全物品订阅」的写法。
+exports.MERCHANT_ALL_ALIASES = new Set(['全部', '全物品', '全部物品', '所有', '所有物品', 'all', '*']);
+function trimText(value) {
+    return String(value ?? '').trim();
+}
+function toWholeNumber(value) {
+    const num = Number(value);
+    return Number.isFinite(num) && num > 0 ? Math.floor(num) : 0;
+}
+function isAllAlias(token = '') {
+    return exports.MERCHANT_ALL_ALIASES.has(trimText(token).toLowerCase());
+}
+/**
+ * 把后端商品池归一成带序号的目录。
+ *
+ * 序号只取后端返回的顺序（index = 位置 + 1），解析订阅时立刻换成商品名落盘，
+ * 所以后端调整目录顺序不会影响已有订阅。
+ */
+function buildMerchantCatalog(randomGoods) {
+    const items = [];
+    const seen = new Set();
+    for (const raw of Array.isArray(randomGoods) ? randomGoods : []) {
+        const name = trimText(raw?.goods_name);
+        if (!name || seen.has(name))
+            continue;
+        seen.add(name);
+        items.push({
+            index: items.length + 1,
+            name,
+            goods_id: toWholeNumber(raw?.id),
+            item_id: toWholeNumber(raw?.item_id),
+            item_num: toWholeNumber(raw?.item_num) || 1,
+        });
+    }
+    return items;
+}
+/**
+ * 解析用户输入：序号 / 商品名 / 全部。
+ *
+ * - 纯数字按序号查目录，命中后换成规范名
+ * - 目录里没有的文字按原样保留（后端随时会加新商品），同时记进 unrecognizedNames 供提示
+ * - 目录为空（离线）时不报未识别，避免误伤
+ */
+function resolveMerchantSelection(input, catalog) {
+    const list = Array.isArray(input) ? input : [input];
+    const items = Array.isArray(catalog) ? catalog : [];
+    const names = [];
+    const seen = new Set();
+    const unknownIndexes = [];
+    const unrecognizedNames = [];
+    let all = false;
+    const pushName = (value) => {
+        const text = trimText(value);
+        if (!text || seen.has(text))
+            return;
+        seen.add(text);
+        names.push(text);
+    };
+    for (const raw of list) {
+        const token = trimText(raw);
+        if (!token)
+            continue;
+        if (isAllAlias(token)) {
+            all = true;
+            continue;
+        }
+        if (/^\d+$/.test(token)) {
+            const hit = items.find(item => item.index === Number(token));
+            if (hit)
+                pushName(hit.name);
+            else
+                unknownIndexes.push(token);
+            continue;
+        }
+        const hit = items.find(item => trimText(item.name) === token);
+        if (hit) {
+            pushName(hit.name);
+            continue;
+        }
+        pushName(token);
+        if (items.length > 0)
+            unrecognizedNames.push(token);
+    }
+    return { all, names, unknownIndexes, unrecognizedNames };
+}
+/** 把订阅的商品名回显成「序号.名称」，方便用户对照商品列表。 */
+function describeMerchantItems(names, catalog) {
+    const indexByName = new Map();
+    for (const item of Array.isArray(catalog) ? catalog : []) {
+        const name = trimText(item?.name);
+        if (name)
+            indexByName.set(name, item.index);
+    }
+    return (Array.isArray(names) ? names : [])
+        .map((raw) => {
+        const name = trimText(raw);
+        if (!name)
+            return '';
+        const index = indexByName.get(name) || 0;
+        return index > 0 ? `${index}.${name}` : name;
+    })
+        .filter(Boolean)
+        .join('、');
+}
+class MerchantCatalogService {
+    filePath;
+    fetchRandomGoods;
+    memory = null;
+    constructor(filePath, fetchRandomGoods) {
+        this.filePath = filePath;
+        this.fetchRandomGoods = fetchRandomGoods;
+    }
+    /** 同步读磁盘缓存，供命令在离线时兜底。 */
+    loadCachedCatalog() {
+        try {
+            const raw = JSON.parse(node_fs_1.default.readFileSync(this.filePath, 'utf8'));
+            const items = Array.isArray(raw?.items) ? raw.items : [];
+            return items.filter((item) => trimText(item?.name));
+        }
+        catch {
+            return [];
+        }
+    }
+    writeCache(items) {
+        try {
+            const dir = node_path_1.default.dirname(this.filePath);
+            if (!node_fs_1.default.existsSync(dir))
+                node_fs_1.default.mkdirSync(dir, { recursive: true });
+            const payload = {
+                updated_at: new Date().toISOString(),
+                source: 'merchant/info?random_goods=all',
+                items,
+            };
+            const tempPath = `${this.filePath}.tmp`;
+            node_fs_1.default.writeFileSync(tempPath, JSON.stringify(payload, null, 2), 'utf8');
+            node_fs_1.default.renameSync(tempPath, this.filePath);
+            return true;
+        }
+        catch (error) {
+            logger.warn(`写入远行商人商品目录失败: ${error}`);
+            return false;
+        }
+    }
+    /**
+     * 取商品目录：内存缓存 → 后端全量商品池 → 磁盘缓存。
+     * 全链路失败时返回上一次的目录（可能为空），由调用方决定怎么提示。
+     */
+    async getCatalog(options = {}) {
+        const now = Date.now();
+        const cached = this.memory;
+        if (!options.refresh && cached && cached.items.length > 0 && now - cached.at < CATALOG_TTL_MS) {
+            return JSON.parse(JSON.stringify(cached.items));
+        }
+        try {
+            const payload = await this.fetchRandomGoods();
+            const items = buildMerchantCatalog(payload?.random_goods);
+            if (items.length > 0) {
+                this.memory = { at: now, items };
+                this.writeCache(items);
+                return JSON.parse(JSON.stringify(items));
+            }
+            logger.warn('远行商人商品目录为空，沿用本地缓存');
+        }
+        catch (error) {
+            logger.warn(`拉取远行商人商品目录失败: ${error}`);
+        }
+        const disk = this.loadCachedCatalog();
+        if (disk.length > 0) {
+            this.memory = { at: now, items: disk };
+            return JSON.parse(JSON.stringify(disk));
+        }
+        return cached?.items ? JSON.parse(JSON.stringify(cached.items)) : [];
+    }
+}
+exports.MerchantCatalogService = MerchantCatalogService;

package/lib/merchant-price-log.d.ts

@@ -0,0 +1,63 @@
+export declare function merchantPriceDateKey(date?: Date): string;
+export interface MerchantPriceSnapshot {
+    price: number;
+    origin_price: number;
+    buy_limit_num: number;
+    at: string;
+}
+export interface MerchantPriceEntry {
+    goods_id: number;
+    name: string;
+    item_id: number;
+    item_num: number;
+    buy_limit_num: number;
+    by_round: Record<string, MerchantPriceSnapshot>;
+    price: number;
+    origin_price: number;
+    round: number;
+}
+export interface MerchantPriceLogItem {
+    goods_id: number;
+    name: string;
+    goods_name?: string;
+    item_id?: unknown;
+    item_num?: unknown;
+    buy_limit_num?: unknown;
+    limit_buy_num?: unknown;
+    price?: unknown;
+    origin_price?: unknown;
+}
+export interface MerchantPriceLookup {
+    goods_id: number;
+    name: string;
+    price: number;
+    origin_price: number;
+    buy_limit_num: number;
+    item_id: number;
+    item_num: number;
+    round: number;
+}
+interface PriceLogState {
+    date: string;
+    updated_at: string;
+    items: Record<string, MerchantPriceEntry>;
+}
+export declare class MerchantPriceLog {
+    private filePath;
+    private state;
+    constructor(filePath: string);
+    /** 读盘；日期不是今天就当作已清空（游戏内自然日滚动）。 */
+    load(now?: Date): PriceLogState;
+    save(now?: Date): void;
+    /** 记录一批实时商品（价格 <= 0 的跳过，避免把无效值写进去）。 */
+    record(goods: MerchantPriceLogItem[], options?: {
+        now?: Date;
+        round?: number;
+    }): boolean;
+    /** 按 goods_id（优先同名轮次）查当天记录，查不到再退回商品名。 */
+    lookup(goodsId: unknown, name?: string, round?: number, now?: Date): MerchantPriceLookup | null;
+    /** 调试 / 测试用：当前记录快照。 */
+    snapshot(): any;
+    clear(now?: Date): void;
+}
+export {};

package/lib/merchant-price-log.js

@@ -0,0 +1,187 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MerchantPriceLog = void 0;
+exports.merchantPriceDateKey = merchantPriceDateKey;
+const koishi_1 = require("koishi");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const logger = new koishi_1.Logger('rocom-merchant');
+// 实时接口只返回当前轮次的商品价格，轮次一过就拿不到了；
+// 旧接口 random_goods[].price 恒为 0。把每轮观察到的实时价格按 goods_id + 轮次
+// 记下来，供当天后续轮次补价。按游戏内自然日（Asia/Shanghai）分桶，跨天自动清空。
+const chinaDateFormatter = new Intl.DateTimeFormat('en-CA', {
+    timeZone: 'Asia/Shanghai',
+    year: 'numeric',
+    month: '2-digit',
+    day: '2-digit',
+});
+function merchantPriceDateKey(date = new Date()) {
+    return chinaDateFormatter.format(date);
+}
+function toPositiveNumber(value) {
+    const num = Number(value);
+    return Number.isFinite(num) && num > 0 ? num : 0;
+}
+function toWholeNumber(value) {
+    const num = Number(value);
+    return Number.isFinite(num) && num > 0 ? Math.floor(num) : 0;
+}
+function trimText(value) {
+    return String(value ?? '').trim();
+}
+class MerchantPriceLog {
+    filePath;
+    state = null;
+    constructor(filePath) {
+        this.filePath = filePath;
+    }
+    /** 读盘；日期不是今天就当作已清空（游戏内自然日滚动）。 */
+    load(now = new Date()) {
+        const today = merchantPriceDateKey(now);
+        if (this.state && this.state.date === today)
+            return this.state;
+        let raw = null;
+        try {
+            if (node_fs_1.default.existsSync(this.filePath)) {
+                raw = JSON.parse(node_fs_1.default.readFileSync(this.filePath, 'utf8'));
+            }
+        }
+        catch (error) {
+            logger.warn(`读取远行商人价格记录失败: ${error}`);
+        }
+        if (!raw || typeof raw !== 'object' || raw.date !== today) {
+            this.state = { date: today, updated_at: '', items: {} };
+            if (raw && raw.date !== today)
+                this.save(now);
+            return this.state;
+        }
+        this.state = {
+            date: today,
+            updated_at: trimText(raw.updated_at),
+            items: raw.items && typeof raw.items === 'object' ? raw.items : {},
+        };
+        return this.state;
+    }
+    save(now = new Date()) {
+        try {
+            const dir = node_path_1.default.dirname(this.filePath);
+            if (!node_fs_1.default.existsSync(dir))
+                node_fs_1.default.mkdirSync(dir, { recursive: true });
+            const payload = {
+                date: this.state?.date || merchantPriceDateKey(now),
+                updated_at: new Date().toISOString(),
+                items: this.state?.items || {},
+            };
+            this.state = payload;
+            const tempPath = `${this.filePath}.tmp`;
+            node_fs_1.default.writeFileSync(tempPath, JSON.stringify(payload, null, 2), 'utf8');
+            node_fs_1.default.renameSync(tempPath, this.filePath);
+        }
+        catch (error) {
+            logger.warn(`写入远行商人价格记录失败: ${error}`);
+        }
+    }
+    /** 记录一批实时商品（价格 <= 0 的跳过，避免把无效值写进去）。 */
+    record(goods, options = {}) {
+        const now = options.now instanceof Date ? options.now : new Date();
+        const state = this.load(now);
+        const round = toWholeNumber(options.round);
+        let changed = false;
+        for (const item of Array.isArray(goods) ? goods : []) {
+            const goodsId = toWholeNumber(item?.goods_id);
+            const price = toPositiveNumber(item?.price);
+            if (!goodsId || price <= 0)
+                continue;
+            const key = String(goodsId);
+            const entry = state.items[key] || {
+                goods_id: goodsId,
+                name: trimText(item?.goods_name),
+                item_id: toWholeNumber(item?.item_id),
+                item_num: toWholeNumber(item?.item_num) || 1,
+                buy_limit_num: toWholeNumber(item?.buy_limit_num ?? item?.limit_buy_num),
+                by_round: {},
+                price: 0,
+                origin_price: 0,
+                round: 0,
+            };
+            if (!entry.name && item?.goods_name)
+                entry.name = trimText(item.goods_name);
+            if (!entry.item_id && item?.item_id)
+                entry.item_id = toWholeNumber(item.item_id);
+            if (!entry.item_num && item?.item_num)
+                entry.item_num = toWholeNumber(item.item_num) || 1;
+            const limitNum = toWholeNumber(item?.buy_limit_num ?? item?.limit_buy_num);
+            if (!entry.buy_limit_num && limitNum)
+                entry.buy_limit_num = limitNum;
+            const snapshot = {
+                price,
+                origin_price: toPositiveNumber(item?.origin_price) || price,
+                buy_limit_num: limitNum || entry.buy_limit_num || 0,
+                at: now.toISOString(),
+            };
+            entry.by_round[String(round)] = snapshot;
+            // 顶层存最近一次观察到的价格，供没有轮次命中的商品兜底。
+            entry.price = snapshot.price;
+            entry.origin_price = snapshot.origin_price;
+            entry.round = round || entry.round;
+            state.items[key] = entry;
+            changed = true;
+        }
+        if (changed)
+            this.save(now);
+        return changed;
+    }
+    /** 按 goods_id（优先同名轮次）查当天记录，查不到再退回商品名。 */
+    lookup(goodsId, name = '', round = 0, now = new Date()) {
+        const items = this.load(now).items || {};
+        const fromEntry = (entry) => {
+            if (!entry)
+                return null;
+            const byRound = entry.by_round || {};
+            const matched = byRound[String(toWholeNumber(round))];
+            const source = matched || { price: entry.price, origin_price: entry.origin_price, buy_limit_num: entry.buy_limit_num, at: '' };
+            const price = toPositiveNumber(source?.price);
+            if (price <= 0)
+                return null;
+            return {
+                goods_id: toWholeNumber(entry.goods_id),
+                name: trimText(entry.name),
+                price,
+                origin_price: toPositiveNumber(source?.origin_price) || price,
+                buy_limit_num: toWholeNumber(source?.buy_limit_num) || toWholeNumber(entry.buy_limit_num),
+                item_id: toWholeNumber(entry.item_id),
+                item_num: toWholeNumber(entry.item_num) || 1,
+                round: toWholeNumber(round) || toWholeNumber(entry.round),
+            };
+        };
+        const normalizedId = toWholeNumber(goodsId);
+        if (normalizedId > 0) {
+            const direct = fromEntry(items[String(normalizedId)]);
+            if (direct)
+                return direct;
+        }
+        const normalizedName = trimText(name);
+        if (!normalizedName)
+            return null;
+        for (const entry of Object.values(items)) {
+            if (trimText(entry?.name) === normalizedName) {
+                const found = fromEntry(entry);
+                if (found)
+                    return found;
+            }
+        }
+        return null;
+    }
+    /** 调试 / 测试用：当前记录快照。 */
+    snapshot() {
+        return JSON.parse(JSON.stringify(this.load()));
+    }
+    clear(now = new Date()) {
+        this.state = { date: merchantPriceDateKey(now), updated_at: '', items: {} };
+        this.save(now);
+    }
+}
+exports.MerchantPriceLog = MerchantPriceLog;

package/lib/merchant-service.d.ts

@@ -10,6 +10,9 @@ export interface MerchantItem {
     active: boolean;
     category: string;
     source: 'live' | 'legacy';
+    allDay: boolean;
+    itemId?: string;
+    itemKind?: string;
 }
 export interface NormalizedMerchant {
     source: 'live' | 'legacy';
@@ -18,7 +21,18 @@ export interface NormalizedMerchant {
 export declare const numberOrNull: (v: unknown) => number | null;
 export declare function livePrice(value: any): number | null;
 export declare function merchantTimestampMs(value: any): number | null;
-export declare function normalizeLiveMerchant(payload: any, nowMs?: number): MerchantItem[];
-export declare function normalizeLegacyMerchant(payload: any, nowMs?: number): MerchantItem[];
+export interface MerchantNormalizeOptions {
+    secondsOfDay?: (ms: number) => number;
+    assetBaseUrl?: string;
+    fallbackIcon?: string;
+}
+export declare function isAllDayMerchantProduct(refreshAt: number | null, startsAt: number | null, endsAt: number | null, roundValue: unknown, secondsOfDay?: (ms: number) => number): boolean;
+export declare function wikiItemAssetUrl(baseUrl: string | undefined, itemId: unknown, itemKind: unknown): string;
+export declare function collectAllDayProductNames(items: Array<{
+    name?: string;
+    allDay?: boolean;
+}>): Set<string>;
+export declare function normalizeLiveMerchant(payload: any, nowMs?: number, options?: MerchantNormalizeOptions): MerchantItem[];
+export declare function normalizeLegacyMerchant(payload: any, nowMs?: number, options?: MerchantNormalizeOptions): MerchantItem[];
 export declare function isLiveMerchantPayload(payload: any): boolean;
-export declare function normalizeMerchant(payload: any, nowMs?: number): NormalizedMerchant;
+export declare function normalizeMerchant(payload: any, nowMs?: number, options?: MerchantNormalizeOptions): NormalizedMerchant;