rootandClaude Opus 5.5
71b129d85a
- H&R becomes a quick-filter facet (yes/no/unknown, with counts) on search results and the site resources tab; drop the old free/H&R selects, keep size range and sort on the same row (mobile: drawer), single clear button - legacy free/hr URL params migrate into quick filters; stored selections keep the same localStorage key - search timing and query terms move into TechInfo - library episode versions: click the whole row to expand, versions listed as sibling rows, details only under the selected version, raw values in TechInfo - slot comparison gaps get reason codes (matchGapText in contracts reasons.ts): "可换成 2160p", "缺 HDR 版本" Co-Authored-By: Claude Opus 5.5 <[email protected]>
540 lines
21 KiB
TypeScript
540 lines
21 KiB
TypeScript
import { parseReleasePath } from "../release-parser/path.ts";
|
|
import type { Cut, HdrFormat, ParsedRelease, ReleaseSource, Resolution, VideoCodec } from "../release-parser/types.ts";
|
|
import {
|
|
currentPri,
|
|
DEFAULT_SOURCE_TIERS,
|
|
describeViolation,
|
|
evaluateCandidate,
|
|
qualityTier,
|
|
RESOLUTION_RANK,
|
|
} from "../slot/evaluate.ts";
|
|
import type { SlotSpec, Violation } from "../slot/types.ts";
|
|
|
|
// LIBV-1 入库版本:一集(或一部电影)可以挂多个本地文件,每个文件是一个"版本"。
|
|
// 版本规格 = 文件名解析 + ffprobe 结果合并:技术事实(分辨率、编码、HDR、音轨、字幕、时长)以探测为准,
|
|
// 来源(原盘/Remux/压制/WEB-DL)、制作组、剪辑版本只能从文件名得到。
|
|
// 规范化后的规格写回 media_asset.delivery(specVersion 标记口径),读取时口径不符就现算。
|
|
|
|
export const VERSION_SPEC_VERSION = 1;
|
|
|
|
/** ffprobe 结果的结构子集(domain 不依赖 adapters) */
|
|
export interface ProbeLike {
|
|
status?: string;
|
|
container?: string;
|
|
durationSec?: number;
|
|
video?: { codec?: string; profile?: string; width?: number; height?: number; pixFmt?: string; hdr?: string }[];
|
|
audio?: {
|
|
codec?: string;
|
|
profile?: string;
|
|
channels?: number;
|
|
channelLayout?: string;
|
|
language?: string;
|
|
title?: string;
|
|
}[];
|
|
subtitles?: { codec?: string; language?: string; title?: string; forced?: boolean }[];
|
|
}
|
|
|
|
export interface VersionAudio {
|
|
/** TrueHD Atmos / DDP / DTS-HD MA / AAC … */
|
|
codec?: string;
|
|
/** 7.1 / 5.1 / 2.0 */
|
|
channels?: string;
|
|
/** zh / en / ja …;未知不给 */
|
|
language?: string;
|
|
}
|
|
|
|
export interface VersionSpec {
|
|
resolution?: Resolution;
|
|
source?: ReleaseSource;
|
|
/** 蓝光二次压制 */
|
|
isEncode?: boolean;
|
|
videoCodec?: VideoCodec;
|
|
/** 按 DV → HDR10+ → HDR10 → HLG → HDR Vivid 排序;空 = SDR 或未知 */
|
|
hdr: HdrFormat[];
|
|
bitDepth?: number;
|
|
audio: VersionAudio[];
|
|
/** 内嵌 + 外挂字幕语言(zh-Hans / zh-Hant / zh / en …) */
|
|
subtitleLanguages: string[];
|
|
releaseGroup?: string;
|
|
edition?: Cut;
|
|
durationSec?: number;
|
|
/** 规格来自哪里:name = 文件名解析,probe = ffprobe */
|
|
specFrom: ("name" | "probe")[];
|
|
}
|
|
|
|
const HDR_ORDER: HdrFormat[] = ["DV", "HDR10+", "HDR10", "HLG", "HDR Vivid"];
|
|
|
|
export function resolutionFromDims(width?: number, height?: number): Resolution | undefined {
|
|
const w = width ?? 0;
|
|
const h = height ?? 0;
|
|
if (!w && !h) return undefined;
|
|
if (w >= 7000 || h >= 4000) return "4320p";
|
|
if (w >= 3200 || h >= 1800) return "2160p";
|
|
if (w >= 2400 || h >= 1300) return "1440p";
|
|
if (w >= 1800 || h >= 1000) return "1080p";
|
|
if (w >= 1200 || h >= 700) return "720p";
|
|
if (w >= 1000 || h >= 540) return "576p";
|
|
return "480p";
|
|
}
|
|
|
|
const VIDEO_CODEC: Record<string, VideoCodec> = {
|
|
hevc: "H.265",
|
|
h265: "H.265",
|
|
h264: "H.264",
|
|
avc: "H.264",
|
|
av1: "AV1",
|
|
vc1: "VC-1",
|
|
mpeg2video: "MPEG-2",
|
|
};
|
|
|
|
export function videoCodecOf(codec?: string): VideoCodec | undefined {
|
|
return codec ? VIDEO_CODEC[codec.toLowerCase()] : undefined;
|
|
}
|
|
|
|
/** ffprobe 音频编码 → 常用写法;Atmos / DTS:X 从 profile 或轨道标题识别 */
|
|
export function audioCodecOf(codec?: string, profile?: string, title?: string): string | undefined {
|
|
if (!codec) return undefined;
|
|
const c = codec.toLowerCase();
|
|
const hint = `${profile ?? ""} ${title ?? ""}`;
|
|
const atmos = /atmos/i.test(hint) ? " Atmos" : "";
|
|
if (c === "truehd") return `TrueHD${atmos}`;
|
|
if (c === "eac3") return `DDP${atmos}`;
|
|
if (c === "ac3") return "DD";
|
|
if (c === "dts") {
|
|
if (/dts[:-]?x\b/i.test(hint)) return "DTS:X";
|
|
if (/\bma\b|master/i.test(hint)) return "DTS-HD MA";
|
|
if (/hra|high res/i.test(hint)) return "DTS-HD HRA";
|
|
return "DTS";
|
|
}
|
|
if (c === "aac") return "AAC";
|
|
if (c === "flac") return "FLAC";
|
|
if (c === "opus") return "Opus";
|
|
if (c === "mp3") return "MP3";
|
|
if (c.startsWith("pcm_")) return "LPCM";
|
|
return codec.toUpperCase();
|
|
}
|
|
|
|
const CHANNELS: Record<number, string> = { 1: "1.0", 2: "2.0", 3: "2.1", 6: "5.1", 7: "6.1", 8: "7.1" };
|
|
|
|
export function channelsLabel(channels?: number, layout?: string): string | undefined {
|
|
const m = layout?.match(/^(\d\.\d)/);
|
|
if (m) return m[1];
|
|
if (layout === "stereo") return "2.0";
|
|
if (layout === "mono") return "1.0";
|
|
if (channels === undefined) return undefined;
|
|
return CHANNELS[channels] ?? `${channels}ch`;
|
|
}
|
|
|
|
const LANG: Record<string, string> = {
|
|
chi: "zh",
|
|
zho: "zh",
|
|
chs: "zh-Hans",
|
|
cht: "zh-Hant",
|
|
sc: "zh-Hans",
|
|
tc: "zh-Hant",
|
|
eng: "en",
|
|
jpn: "ja",
|
|
jap: "ja",
|
|
kor: "ko",
|
|
fre: "fr",
|
|
fra: "fr",
|
|
ger: "de",
|
|
deu: "de",
|
|
spa: "es",
|
|
ita: "it",
|
|
rus: "ru",
|
|
por: "pt",
|
|
tha: "th",
|
|
cantonese: "yue",
|
|
yue: "yue",
|
|
};
|
|
|
|
/** 轨道语言 → 短码;中文按标题区分简繁;und / 空 → undefined */
|
|
export function languageOf(language?: string, title?: string): string | undefined {
|
|
const l = (language ?? "").toLowerCase();
|
|
const t = title ?? "";
|
|
if (!l || l === "und") {
|
|
if (/简|chs|simplified/i.test(t)) return "zh-Hans";
|
|
if (/繁|cht|traditional/i.test(t)) return "zh-Hant";
|
|
return undefined;
|
|
}
|
|
const code = LANG[l] ?? l;
|
|
if (code === "zh") {
|
|
if (/简|chs|simplified|gb/i.test(t)) return "zh-Hans";
|
|
if (/繁|cht|traditional|big5/i.test(t)) return "zh-Hant";
|
|
}
|
|
return code;
|
|
}
|
|
|
|
/** 外挂字幕文件名里的语言记号:xxx.chs.srt / xxx.zh-Hant.ass / xxx.eng.srt */
|
|
export function sidecarLanguageOf(fileName: string): string | undefined {
|
|
const parts = fileName.toLowerCase().split(".");
|
|
parts.pop();
|
|
for (const p of parts.slice(-2).reverse()) {
|
|
if (p === "zh-hans" || p === "zh-cn") return "zh-Hans";
|
|
if (p === "zh-hant" || p === "zh-tw" || p === "zh-hk") return "zh-Hant";
|
|
if (p === "zh" || p === "chi" || p === "zho") return "zh";
|
|
if (LANG[p]) return LANG[p];
|
|
if (p === "en" || p === "ja" || p === "ko") return p;
|
|
}
|
|
if (/简|chs/i.test(fileName)) return "zh-Hans";
|
|
if (/繁|cht/i.test(fileName)) return "zh-Hant";
|
|
return undefined;
|
|
}
|
|
|
|
const uniq = <T>(xs: readonly T[]) => [...new Set(xs)];
|
|
|
|
export function sortHdr(xs: readonly string[]): HdrFormat[] {
|
|
const set = new Set(xs.filter((x): x is HdrFormat => (HDR_ORDER as string[]).includes(x)));
|
|
if (set.has("HDR10+")) set.delete("HDR10");
|
|
return HDR_ORDER.filter((h) => set.has(h));
|
|
}
|
|
|
|
/** 文件名里的音频记号 "DDP 5.1" + "Atmos" → [{ codec: "DDP Atmos", channels: "5.1" }] */
|
|
function audioFromName(tokens: readonly string[]): VersionAudio[] {
|
|
const out: VersionAudio[] = [];
|
|
for (const t of tokens) {
|
|
if (/^atmos$/i.test(t)) {
|
|
const last = out[out.length - 1];
|
|
if (last?.codec && !/atmos/i.test(last.codec)) last.codec = `${last.codec} Atmos`;
|
|
else if (!last) out.push({ codec: "Atmos" });
|
|
continue;
|
|
}
|
|
const m = t.match(/^(.*?)\s*(\d\.\d)$/);
|
|
out.push(m ? { codec: m[1] || undefined, channels: m[2] } : { codec: t });
|
|
}
|
|
return out.map((a) => Object.fromEntries(Object.entries(a).filter(([, v]) => v !== undefined)) as VersionAudio);
|
|
}
|
|
|
|
export interface VersionSpecInput {
|
|
/** 库内相对路径(含作品/季目录,解析时目录名参与) */
|
|
path: string;
|
|
probe?: ProbeLike | null;
|
|
/** 外挂字幕文件名(同主视频的附属资产) */
|
|
sidecarSubtitles?: readonly string[];
|
|
/** 已解析的结果(省一次解析,测试用) */
|
|
parsed?: ParsedRelease;
|
|
}
|
|
|
|
/** 文件名解析 + 探测 → 版本规格 */
|
|
export function versionSpecOf(input: VersionSpecInput): VersionSpec {
|
|
const r = input.parsed ?? parseReleasePath(input.path, { isFile: true });
|
|
const p = input.probe?.status === "ok" ? input.probe : null;
|
|
const v = p?.video?.[0];
|
|
const from: VersionSpec["specFrom"] = [];
|
|
const nameHas = !!(r.resolution || r.source || r.videoCodec || r.releaseGroup || r.hdr.length || r.audio.length);
|
|
if (nameHas) from.push("name");
|
|
if (p) from.push("probe");
|
|
const audio = p?.audio?.length
|
|
? p.audio.map((a) => {
|
|
const o: VersionAudio = {};
|
|
const codec = audioCodecOf(a.codec, a.profile, a.title);
|
|
const ch = channelsLabel(a.channels, a.channelLayout);
|
|
const lang = languageOf(a.language, a.title);
|
|
if (codec) o.codec = codec;
|
|
if (ch) o.channels = ch;
|
|
if (lang) o.language = lang;
|
|
return o;
|
|
})
|
|
: audioFromName(r.audio);
|
|
const subs = [
|
|
...(p?.subtitles ?? []).map((s) => languageOf(s.language, s.title)),
|
|
...(r.subtitles ?? []),
|
|
...(input.sidecarSubtitles ?? []).map(sidecarLanguageOf),
|
|
].filter((x): x is string => !!x);
|
|
const bitDepth = v?.pixFmt?.match(/p(10|12)(le|be)?$/)?.[1];
|
|
const spec: VersionSpec = {
|
|
hdr: sortHdr([...(v?.hdr ? [v.hdr] : []), ...r.hdr]),
|
|
audio,
|
|
subtitleLanguages: uniq(subs),
|
|
specFrom: from,
|
|
};
|
|
const res = resolutionFromDims(v?.width, v?.height) ?? r.resolution;
|
|
if (res) spec.resolution = res;
|
|
if (r.source) spec.source = r.source;
|
|
if (r.source) spec.isEncode = r.isEncode;
|
|
const vc = videoCodecOf(v?.codec) ?? r.videoCodec;
|
|
if (vc) spec.videoCodec = vc;
|
|
const bd = bitDepth ? Number(bitDepth) : r.bitDepth;
|
|
if (bd) spec.bitDepth = bd;
|
|
if (r.releaseGroup) spec.releaseGroup = r.releaseGroup.name;
|
|
if (r.cut) spec.edition = r.cut;
|
|
if (p?.durationSec) spec.durationSec = Math.round(p.durationSec);
|
|
return spec;
|
|
}
|
|
|
|
/** 写回 media_asset.delivery 的形态(DeliveryTraits 的超集,旧字段保持同名) */
|
|
export function deliveryOfSpec(s: VersionSpec): Record<string, unknown> {
|
|
return {
|
|
specVersion: VERSION_SPEC_VERSION,
|
|
specFrom: s.specFrom,
|
|
...(s.resolution ? { resolution: s.resolution } : {}),
|
|
...(s.source ? { sourceType: s.source, isEncode: !!s.isEncode } : {}),
|
|
...(s.videoCodec ? { videoCodec: s.videoCodec } : {}),
|
|
...(s.bitDepth ? { bitDepth: s.bitDepth } : {}),
|
|
hdr: s.hdr,
|
|
audio: s.audio,
|
|
audioCodecs: uniq(s.audio.map((a) => a.codec).filter((x): x is string => !!x)),
|
|
subtitles: s.subtitleLanguages,
|
|
...(s.releaseGroup ? { releaseGroup: s.releaseGroup } : {}),
|
|
...(s.edition ? { edition: s.edition } : {}),
|
|
...(s.durationSec ? { durationSec: s.durationSec } : {}),
|
|
};
|
|
}
|
|
|
|
/** 已按当前口径写回的 delivery → 规格;口径不符(旧数据)返回 null,由调用方现算 */
|
|
export function specFromDelivery(d: unknown): VersionSpec | null {
|
|
if (!d || typeof d !== "object") return null;
|
|
const o = d as Record<string, unknown>;
|
|
if (o.specVersion !== VERSION_SPEC_VERSION) return null;
|
|
const str = (k: string) => (typeof o[k] === "string" ? (o[k] as string) : undefined);
|
|
const arr = <T>(k: string) => (Array.isArray(o[k]) ? (o[k] as T[]) : []);
|
|
const spec: VersionSpec = {
|
|
hdr: sortHdr(arr<string>("hdr")),
|
|
audio: arr<VersionAudio>("audio"),
|
|
subtitleLanguages: arr<string>("subtitles"),
|
|
specFrom: arr<"name" | "probe">("specFrom"),
|
|
};
|
|
if (str("resolution")) spec.resolution = str("resolution") as Resolution;
|
|
if (str("sourceType")) {
|
|
spec.source = str("sourceType") as ReleaseSource;
|
|
spec.isEncode = o.isEncode === true;
|
|
}
|
|
if (str("videoCodec")) spec.videoCodec = str("videoCodec") as VideoCodec;
|
|
if (typeof o.bitDepth === "number") spec.bitDepth = o.bitDepth;
|
|
if (str("releaseGroup")) spec.releaseGroup = str("releaseGroup");
|
|
if (str("edition")) spec.edition = str("edition") as Cut;
|
|
if (typeof o.durationSec === "number") spec.durationSec = o.durationSec;
|
|
return spec;
|
|
}
|
|
|
|
// ── 汇总 ──
|
|
|
|
export interface SpecGroup {
|
|
resolution: Resolution | null;
|
|
source: ReleaseSource | null;
|
|
hdr: HdrFormat[];
|
|
count: number;
|
|
}
|
|
|
|
export interface VersionSummary {
|
|
versionCount: number;
|
|
sizeBytes: number;
|
|
/** 按 分辨率 + 来源 + HDR 分组,数量多的在前 */
|
|
specs: SpecGroup[];
|
|
}
|
|
|
|
export function summarizeVersions(
|
|
items: readonly { spec: Pick<VersionSpec, "resolution" | "source" | "hdr">; sizeBytes: number | null }[],
|
|
): VersionSummary {
|
|
const groups = new Map<string, SpecGroup>();
|
|
let size = 0;
|
|
for (const it of items) {
|
|
size += it.sizeBytes ?? 0;
|
|
const hdr = it.spec.hdr.filter((h) => h !== "HDR10" || !it.spec.hdr.includes("DV"));
|
|
const key = `${it.spec.resolution ?? ""}|${it.spec.source ?? ""}|${hdr.join("+")}`;
|
|
const g = groups.get(key);
|
|
if (g) g.count++;
|
|
else groups.set(key, { resolution: it.spec.resolution ?? null, source: it.spec.source ?? null, hdr, count: 1 });
|
|
}
|
|
const rank = (g: SpecGroup) => (g.resolution ? RESOLUTION_RANK[g.resolution] : -1);
|
|
return {
|
|
versionCount: items.length,
|
|
sizeBytes: size,
|
|
specs: [...groups.values()].sort((a, b) => b.count - a.count || rank(b) - rank(a)),
|
|
};
|
|
}
|
|
|
|
// ── 与版本目标比对 ──
|
|
|
|
export type UnitMatchState = "satisfied" | "missing" | "upgradeable";
|
|
|
|
export interface UnitMatch {
|
|
slotId: string | null;
|
|
state: UnitMatchState;
|
|
/** 满足目标的最好版本(satisfied / 可升级但已达标时);都不达标时为最接近的版本 */
|
|
assetId: string | null;
|
|
/** 可读原因:不达标的条件、升级余量(原文,界面放进技术信息) */
|
|
reasons: string[];
|
|
/** 差距原因码(`version_resolution:2160p`、`version_hdr` …),界面经 @umt/contracts matchGapText 转成人话 */
|
|
codes: string[];
|
|
}
|
|
|
|
export interface LocalVersion {
|
|
assetId: string;
|
|
path: string;
|
|
spec: VersionSpec;
|
|
sizeBytes: number | null;
|
|
/** 该文件覆盖的内容单元数(合集文件按集折算体积) */
|
|
unitCount?: number;
|
|
}
|
|
|
|
/** 本地文件与站点资源不同:站点范围、做种数、促销、标题关键词不适用;剧集按单集体积比较 */
|
|
export function localSlotSpec(spec: SlotSpec, isEpisode: boolean): SlotSpec {
|
|
const { sites: _s, excludeSites: _xs, minSeeders: _m, freeOnly: _f, include: _i, exclude: _x, ...hard } = spec.hard;
|
|
if (isEpisode) {
|
|
delete hard.maxSizeBytes;
|
|
delete hard.minSizeBytes;
|
|
}
|
|
return { ...spec, hard, unknownPolicy: "accept" };
|
|
}
|
|
|
|
function pseudoRelease(v: LocalVersion): ParsedRelease {
|
|
const s = v.spec;
|
|
return {
|
|
parserVersion: 0,
|
|
raw: v.path,
|
|
isEncode: !!s.isEncode,
|
|
audio: s.audio.map((a) => [a.codec, a.channels].filter(Boolean).join(" ")),
|
|
hdr: s.hdr,
|
|
contentType: "unknown",
|
|
variantTags: [],
|
|
mediaTypeHint: "unknown",
|
|
isSeasonPack: false,
|
|
packHint: "single",
|
|
isFile: true,
|
|
explicitIds: [],
|
|
confidence: "rule_confirmed",
|
|
evidence: [],
|
|
...(s.resolution ? { resolution: s.resolution } : {}),
|
|
...(s.source ? { source: s.source } : {}),
|
|
...(s.videoCodec ? { videoCodec: s.videoCodec } : {}),
|
|
...(s.releaseGroup ? { releaseGroup: { name: s.releaseGroup, source: "known" as const } } : {}),
|
|
...(s.edition ? { cut: s.edition } : {}),
|
|
// 只有探测过才知道内嵌字幕;只凭文件名时视为未知(不据此判不达标)
|
|
...(s.specFrom.includes("probe") || s.subtitleLanguages.length ? { subtitles: s.subtitleLanguages } : {}),
|
|
...(v.sizeBytes !== null ? { sizeBytes: v.sizeBytes } : {}),
|
|
};
|
|
}
|
|
|
|
/** 目标允许的最高来源等级(未限制来源时为等级表最高) */
|
|
function ceilingOf(spec: SlotSpec): { source: number; resolution: number } {
|
|
const tiers = { ...DEFAULT_SOURCE_TIERS, ...spec.upgrade?.sourceTiers };
|
|
const allowed = (spec.hard.sources?.length ? spec.hard.sources : (Object.keys(tiers) as ReleaseSource[])).filter(
|
|
(s) => !spec.hard.excludeSources?.includes(s),
|
|
);
|
|
const res = spec.hard.resolutions?.length ? spec.hard.resolutions : (Object.keys(RESOLUTION_RANK) as Resolution[]);
|
|
return {
|
|
source: Math.max(-1, ...allowed.map((s) => tiers[s])),
|
|
resolution: Math.max(-1, ...res.map((r) => RESOLUTION_RANK[r])),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* 一集(或一部电影)的全部版本与一个版本目标比对:
|
|
* missing = 没有版本;satisfied = 有版本达标且没有升级余量;
|
|
* upgradeable = 有版本但都不达标,或达标版本在目标的升级策略下还能换更好的。
|
|
*/
|
|
export function matchVersions(
|
|
target: SlotSpec,
|
|
versions: readonly LocalVersion[],
|
|
opts: { isEpisode: boolean },
|
|
): UnitMatch {
|
|
const slotId = target.id ?? null;
|
|
if (versions.length === 0) return { slotId, state: "missing", assetId: null, reasons: [], codes: [] };
|
|
const spec = localSlotSpec(target, opts.isEpisode);
|
|
const evals = versions.map((v) => {
|
|
const r = pseudoRelease(v);
|
|
const ev = evaluateCandidate(spec, r, null, v.unitCount ? { unitCount: v.unitCount } : {});
|
|
return { v, r, ev, tier: qualityTier(r, spec) };
|
|
});
|
|
const better = (a: (typeof evals)[number], b: (typeof evals)[number]) =>
|
|
(b.ev.decision === "accept" ? (b.ev.pri ?? 0) : 0) - (a.ev.decision === "accept" ? (a.ev.pri ?? 0) : 0) ||
|
|
b.tier.source - a.tier.source ||
|
|
b.tier.resolution - a.tier.resolution;
|
|
const ok = evals.filter((e) => e.ev.decision === "accept").sort(better);
|
|
const best = ok[0];
|
|
if (!best) {
|
|
const near = [...evals].sort(better)[0]!;
|
|
const rejected = near.ev.decision === "reject" ? near.ev.violations : null;
|
|
const reasons = rejected ? uniq(rejected.map(describeViolation)) : ["规格未知"];
|
|
const codes = rejected ? uniq(rejected.map((v) => gapCode(v, target))) : ["version_spec_unknown"];
|
|
return { slotId, state: "upgradeable", assetId: near.v.assetId, reasons, codes };
|
|
}
|
|
const up = target.upgrade;
|
|
if (!up?.enabled) return { slotId, state: "satisfied", assetId: best.v.assetId, reasons: [], codes: [] };
|
|
const tiered = !!target.soft?.tiers?.length || !!target.rules?.groups.length;
|
|
const basis = up.basis ?? (tiered ? "priority" : "tier");
|
|
if (basis === "priority") {
|
|
const pri = best.ev.decision === "accept" ? (best.ev.pri ?? currentPri(spec, best.r)) : 0;
|
|
const goal = up.targetPri ?? 100;
|
|
return pri < goal
|
|
? {
|
|
slotId,
|
|
state: "upgradeable",
|
|
assetId: best.v.assetId,
|
|
reasons: [`优先级 ${pri}，目标 ${goal}`],
|
|
codes: ["version_priority"],
|
|
}
|
|
: { slotId, state: "satisfied", assetId: best.v.assetId, reasons: [], codes: [] };
|
|
}
|
|
const ceil = ceilingOf(target);
|
|
const belowCeiling = up.ceilingTier === undefined || best.tier.source < up.ceilingTier;
|
|
const bySource = belowCeiling && best.tier.source + (up.minTierSteps ?? 1) <= ceil.source;
|
|
const byRes = !!up.allowResolutionUpgrade && best.tier.resolution < ceil.resolution;
|
|
if (bySource || byRes)
|
|
return {
|
|
slotId,
|
|
state: "upgradeable",
|
|
assetId: best.v.assetId,
|
|
reasons: [bySource ? "来源还能升级" : "分辨率还能升级"],
|
|
codes: [bySource ? "version_source_upgrade" : withParam("version_resolution_upgrade", topResolution(target))],
|
|
};
|
|
return { slotId, state: "satisfied", assetId: best.v.assetId, reasons: [], codes: [] };
|
|
}
|
|
|
|
const withParam = (code: string, p: string | null | undefined) => (p ? `${code}:${p}` : code);
|
|
|
|
/** 目标允许的最高分辨率名 */
|
|
function topResolution(spec: SlotSpec, allowed?: readonly string[]): string | null {
|
|
const list = (allowed ?? spec.hard.resolutions ?? Object.keys(RESOLUTION_RANK)) as Resolution[];
|
|
const known = list.filter((r) => RESOLUTION_RANK[r] !== undefined);
|
|
return known.sort((a, b) => RESOLUTION_RANK[b] - RESOLUTION_RANK[a])[0] ?? null;
|
|
}
|
|
|
|
/** 目标允许的最好来源 */
|
|
function topSource(spec: SlotSpec, allowed: readonly string[]): string | null {
|
|
const tiers: Record<string, number> = { ...DEFAULT_SOURCE_TIERS, ...spec.upgrade?.sourceTiers };
|
|
return [...allowed].sort((a, b) => (tiers[b] ?? -1) - (tiers[a] ?? -1))[0] ?? null;
|
|
}
|
|
|
|
const strList = (v: unknown): string[] => (Array.isArray(v) ? v.filter((x): x is string => typeof x === "string") : []);
|
|
|
|
/**
|
|
* 本地版本与收录版本的差距 → 原因码(POLISH-1)。码表与文案在 @umt/contracts reasons.ts(matchGapText),
|
|
* 冒号后是参数(目标分辨率、来源、编码、字幕语言)。
|
|
*/
|
|
export function gapCode(v: Violation, spec: SlotSpec): string {
|
|
const expected = strList(v.expected);
|
|
switch (`${v.field}.${v.code}`) {
|
|
case "resolution.not_allowed":
|
|
return withParam("version_resolution", topResolution(spec, expected));
|
|
case "source.not_allowed":
|
|
return withParam("version_source", topSource(spec, expected));
|
|
case "source.excluded":
|
|
return "version_source";
|
|
case "source.not_encode":
|
|
return "version_encode";
|
|
case "hdr.missing_required":
|
|
return expected.length && expected.every((h) => h === "DV") ? "version_hdr:DV" : "version_hdr";
|
|
case "hdr.not_sdr":
|
|
return "version_sdr";
|
|
case "hdr.excluded":
|
|
return "version_hdr_excluded";
|
|
case "codec.not_allowed":
|
|
return withParam("version_codec", expected[0]);
|
|
case "codec.excluded":
|
|
return "version_codec";
|
|
case "subtitles.missing_language":
|
|
return withParam("version_subtitles", expected.join("/"));
|
|
case "cut.not_allowed":
|
|
return "version_edition";
|
|
case "group.excluded":
|
|
return "version_group";
|
|
case "contentType.not_allowed":
|
|
return "version_content_type";
|
|
default:
|
|
return v.field === "size" ? "version_size" : "version_rules";
|
|
}
|
|
}
|