feat: v0.3.8–v0.3.14 工作区汇总（依赖升级、整理来源、手动入库、原地入库等）
生产 v0.3.8～v0.3.13 均由 8013196 加工作区修改构建部署，此前未提交；本提交补齐源码，
并含未部署的 v0.3.14 原地入库。中间各版本源码状态未保存，无法逐版拆分，详见
docs/plan/17-full-upgrade.md 与 docs/plan/18-organize-release.md。
- v0.3.8 全面升级：Deno workspace 依赖、Router 8 / Vite 8、camofox 1.18.0 / Node 24、
PostgreSQL 18.6、备份客户端 18.6、演示 qB 5.2.4
- v0.3.9 媒体整理：分类规则、整理来源与目录快照（0059）、文件管理整理入口
- v0.3.10 手动下载与入库：独立手动下载、详情页资源下载、TMDB / Local 元数据兜底
（metadata.resolve_organize）、正常多版本 / 一次性洗版（0060）
- v0.3.11 搜索详情与桌面黑边修复
- v0.3.12 列表分页、搜索历史、首页概况
- v0.3.13 统一整理弹窗与队列
- v0.3.14 原地入库（0061，未部署）
同批审计修复：
- 刮削入队：确认原记录存在后才删重放产生的新记录；写回 run 关联失败时保持 queued，
由处理器补关联（对齐 MP 先登记、只在入队失败时记失败）
- 识别升级链只在结果更确定时采用，不再用 no_match 顶替原有歧义候选
- bluray_dir 资产以原盘目录本身为刮削根（MP 同做法）
- metadata.resolve_organize 登记到入库排障 Skill 与能力地图
- db/src/types.ts 按迁移重新生成；contracts 整理动作枚举顺序与数据库对齐
- 测试：原地入库用例改为直接查记录表；domain 测试模板补 version
- 前端：通知铃铛弹层与用户菜单统一样式；站点卡片共用卡头、底栏贴底、分页间距
依赖升级证据只提交摘要文件，registry-snapshot.json 移至 .local/（SHA-256 记于文档）。
Co-Authored-By: Claude Opus 5.5 <[email protected]>
This commit is contained in:
rootandClaude Opus 5.5 committed
1 parent
8013196e3f
commit
ceb66f8c77
265 files changed
+17751
-2483
No files matched your search
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "@umt/domain",
|
||||
"version": "0.3.7",
|
||||
"version": "0.3.14",
|
||||
"exports": { ".": "./src/index.ts" },
|
||||
"tasks": {
|
||||
"test": "deno run -A npm:vitest run",
|
||||
|
||||
@@ -0,0 +1,96 @@
|
||||
import { describe, expect, it } from "vitest";
|
||||
import { classifyTmdb, DEFAULT_CLASSIFICATION_YAML, parseClassificationYaml } from "./classification.ts";
|
||||
|
||||
const config = parseClassificationYaml(DEFAULT_CLASSIFICATION_YAML);
|
||||
|
||||
describe("ordered TMDB classification", () => {
|
||||
it("defaults honor genre priority and normalize raw movie and TV facts", () => {
|
||||
expect(classifyTmdb(config, "movie", { genres: [{ id: 16 }], original_language: "zh" })).toEqual({
|
||||
category: "动画电影",
|
||||
matchedFields: ["genre_ids"],
|
||||
fallback: false,
|
||||
});
|
||||
expect(classifyTmdb(config, "movie", { genres: [{ id: 10402 }] }).category).toBe("演唱会");
|
||||
for (const language of ["zh", "cn", "bo", "za"])
|
||||
expect(classifyTmdb(config, "movie", { original_language: language }).category).toBe("华语电影");
|
||||
for (const country of ["JP", "VN", "IR", "SA"]) {
|
||||
expect(classifyTmdb(config, "movie", { production_countries: [{ iso_3166_1: country }] }).category).toBe(
|
||||
"亚洲电影",
|
||||
);
|
||||
expect(classifyTmdb(config, "tv", { origin_country: [country] }).category).toBe("亚洲剧集");
|
||||
}
|
||||
expect(classifyTmdb(config, "tv", { genres: [{ id: 16 }, { id: 10762 }], origin_country: ["CN"] }).category).toBe(
|
||||
"儿童剧集",
|
||||
);
|
||||
expect(classifyTmdb(config, "tv", { genre_ids: [10764], origin_country: ["CN"] }).category).toBe("综艺");
|
||||
expect(classifyTmdb(config, "tv", { origin_country: ["TW"] }).category).toBe("华语剧集");
|
||||
expect(classifyTmdb(config, "movie", { original_language: "en" })).toEqual({
|
||||
category: "欧美电影",
|
||||
matchedFields: [],
|
||||
fallback: true,
|
||||
});
|
||||
});
|
||||
|
||||
it("AND fields, OR scalar/list values, exclusions and year ranges", () => {
|
||||
const c = parseClassificationYaml(`movie:
|
||||
合作:
|
||||
original_language: [en, fr]
|
||||
production_countries: 'JP,!US'
|
||||
release_year: '2000-2010,2020'
|
||||
adult: false
|
||||
其它: null
|
||||
tv:
|
||||
年份:
|
||||
release_year: '!2000-2010'
|
||||
`);
|
||||
const raw = {
|
||||
original_language: "en",
|
||||
production_countries: [{ iso_3166_1: "JP" }],
|
||||
release_date: "2010-02-03",
|
||||
adult: false,
|
||||
};
|
||||
expect(classifyTmdb(c, "movie", raw).matchedFields).toEqual([
|
||||
"original_language",
|
||||
"production_countries",
|
||||
"release_year",
|
||||
"adult",
|
||||
]);
|
||||
expect(classifyTmdb(c, "movie", { ...raw, adult: true }).category).toBe("其它");
|
||||
expect(
|
||||
classifyTmdb(c, "movie", { ...raw, production_countries: [{ iso_3166_1: "JP" }, { iso_3166_1: "US" }] }).category,
|
||||
).toBe("其它");
|
||||
expect(classifyTmdb(c, "movie", { ...raw, release_date: "2020-01-01" }).category).toBe("合作");
|
||||
expect(classifyTmdb(c, "tv", { first_air_date: "2011-01-01" }).category).toBe("年份");
|
||||
expect(classifyTmdb(c, "tv", { title: "Missing date" }).category).toBeNull();
|
||||
});
|
||||
|
||||
it("supports arbitrary first-level scalar/list fields and numeric category ordering", () => {
|
||||
const c = parseClassificationYaml(`movie:
|
||||
'20':
|
||||
custom: [true, 3]
|
||||
'1':
|
||||
custom: true
|
||||
tv: {}`);
|
||||
expect(c.movie.map((r) => r.category)).toEqual(["20", "1"]);
|
||||
expect(classifyTmdb(c, "movie", { custom: [true, 4] }).category).toBe("20");
|
||||
});
|
||||
|
||||
it("no fallback without actual raw data, missing exclusions do not match", () => {
|
||||
expect(classifyTmdb(config, "movie", null).category).toBeNull();
|
||||
expect(classifyTmdb(config, "movie", {}).category).toBeNull();
|
||||
const c = parseClassificationYaml("movie:\n 未排除:\n original_language: '!zh'\ntv: {}\n");
|
||||
expect(classifyTmdb(c, "movie", { title: "Unknown" }).category).toBeNull();
|
||||
expect(classifyTmdb(c, "movie", { original_language: "" }).category).toBeNull();
|
||||
});
|
||||
|
||||
it.each([
|
||||
"movie: {}\nmovie: {}\ntv: {}",
|
||||
"movie:\n 重复: null\n 重复: null\ntv: {}",
|
||||
"movie:\n 分类:\n genre_ids: 16\n genre_ids: 99\ntv: {}",
|
||||
"movie:\n ../逃逸: null\ntv: {}",
|
||||
"movie:\n 无条件: null\n 动画:\n genre_ids: 16\ntv: {}",
|
||||
"movie:\n 条件:\n release_year: '2020-2000'\ntv: {}",
|
||||
"movie:\n 条件:\n nested: {invalid: value}\ntv: {}",
|
||||
"movies: {}\ntv: {}",
|
||||
])("rejects invalid config: %s", (yaml) => expect(() => parseClassificationYaml(yaml)).toThrow());
|
||||
});
|
||||
@@ -0,0 +1,132 @@
|
||||
import { parseDocument } from "yaml";
|
||||
|
||||
/** Ordered TMDB rules; first matching category wins. */
|
||||
export interface ClassificationRule {
|
||||
category: string;
|
||||
conditions: { field: string; values: string[] }[];
|
||||
}
|
||||
export interface ClassificationConfig {
|
||||
movie: ClassificationRule[];
|
||||
tv: ClassificationRule[];
|
||||
}
|
||||
export interface ClassificationResult {
|
||||
category: string | null;
|
||||
matchedFields: string[];
|
||||
fallback: boolean;
|
||||
}
|
||||
|
||||
export { DEFAULT_CLASSIFICATION_YAML } from "@umt/contracts";
|
||||
|
||||
const scalar = (v: unknown): v is string | number | boolean =>
|
||||
typeof v === "string" || typeof v === "boolean" || (typeof v === "number" && Number.isFinite(v));
|
||||
|
||||
export function parseClassificationYaml(yaml: string): ClassificationConfig {
|
||||
const doc = parseDocument(yaml, { uniqueKeys: true, schema: "core" });
|
||||
if (doc.errors.length) throw new Error(doc.errors.map((e) => e.message).join("; "));
|
||||
const raw: unknown = doc.toJS({ mapAsMap: true, maxAliasCount: 0 });
|
||||
if (!(raw instanceof Map) || [...raw.keys()].some((k) => k !== "movie" && k !== "tv"))
|
||||
throw new Error("分类配置的一级名称只能是 movie、tv");
|
||||
const config: ClassificationConfig = { movie: [], tv: [] };
|
||||
for (const type of ["movie", "tv"] as const) {
|
||||
const categories: unknown = raw.get(type);
|
||||
if (!(categories instanceof Map)) throw new Error(`${type} 必须是分类名称映射`);
|
||||
for (const [category, fields] of categories) {
|
||||
if (
|
||||
typeof category !== "string" ||
|
||||
!category.trim() ||
|
||||
category.trim() !== category ||
|
||||
/[\\/<>:"|?*]/.test(category) ||
|
||||
Array.from(category).some((ch) => ch.charCodeAt(0) < 32 || ch.charCodeAt(0) === 127) ||
|
||||
category === "." ||
|
||||
category === ".." ||
|
||||
/[. ]$/.test(category) ||
|
||||
/^(CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])(?:\.|$)/i.test(category)
|
||||
)
|
||||
throw new Error(`${type} 分类名称必须是安全的单层目录名`);
|
||||
if (fields !== null && !(fields instanceof Map)) throw new Error(`${type}.${category} 必须是条件映射或 null`);
|
||||
const conditions: ClassificationRule["conditions"] = [];
|
||||
for (const [field, input] of fields ?? []) {
|
||||
if (typeof field !== "string" || !field.trim()) throw new Error(`${category} 的条件字段必须是非空字符串`);
|
||||
const list: unknown[] = Array.isArray(input) ? input : [input];
|
||||
if (!list.length || !list.every(scalar)) throw new Error(`${category}.${field} 条件必须是标量或标量列表`);
|
||||
const values = list.flatMap((v) =>
|
||||
String(v)
|
||||
.split(",")
|
||||
.map((s) => s.trim()),
|
||||
);
|
||||
if (values.some((v) => !v || v === "!")) throw new Error(`${category}.${field} 条件值不能为空`);
|
||||
if (field === "release_year") {
|
||||
for (const value of values) {
|
||||
const year = value.replace(/^!/, "");
|
||||
if (!/^\d{4}(?:-\d{4})?$/.test(year) || (year.includes("-") && year.slice(0, 4) > year.slice(5)))
|
||||
throw new Error(`${category}.release_year 请使用 YYYY 或 YYYY-YYYY`);
|
||||
}
|
||||
}
|
||||
conditions.push({ field, values });
|
||||
}
|
||||
config[type].push({ category, conditions });
|
||||
}
|
||||
if (config[type].some((r, i) => !r.conditions.length && i !== config[type].length - 1))
|
||||
throw new Error(`${type} 无条件兜底分类必须放在最后`);
|
||||
}
|
||||
return config;
|
||||
}
|
||||
|
||||
function actualValues(raw: Record<string, unknown>, type: "movie" | "tv", field: string): string[] {
|
||||
let input = field === "release_year" ? raw[type === "movie" ? "release_date" : "first_air_date"] : raw[field];
|
||||
if (field === "genre_ids" && input === undefined) input = raw.genres;
|
||||
const list = Array.isArray(input) ? input : [input];
|
||||
return list.flatMap((item) => {
|
||||
let value = item;
|
||||
if (value && typeof value === "object") {
|
||||
const o = value as Record<string, unknown>;
|
||||
value =
|
||||
field === "production_countries"
|
||||
? o.iso_3166_1
|
||||
: field === "genre_ids" || field === "genres"
|
||||
? o.id
|
||||
: undefined;
|
||||
}
|
||||
if (!scalar(value) || String(value).trim() === "") return [];
|
||||
if (field === "release_year") {
|
||||
const year = String(value)
|
||||
.match(/^\d{4}(?:-|$)/)?.[0]
|
||||
.slice(0, 4);
|
||||
return year ? [year] : [];
|
||||
}
|
||||
return [String(value)];
|
||||
});
|
||||
}
|
||||
|
||||
function matches(actual: string[], values: string[], field: string): boolean {
|
||||
if (!actual.length) return false;
|
||||
const hit = (value: string) =>
|
||||
actual.some((a) => {
|
||||
if (field === "release_year" && value.includes("-")) {
|
||||
const [start, end] = value.split("-");
|
||||
return a >= start! && a <= end!;
|
||||
}
|
||||
return a === value;
|
||||
});
|
||||
const excluded = values.filter((v) => v.startsWith("!")).map((v) => v.slice(1));
|
||||
const included = values.filter((v) => !v.startsWith("!"));
|
||||
return !excluded.some(hit) && (!included.length || included.some(hit));
|
||||
}
|
||||
|
||||
export function classifyTmdb(
|
||||
config: ClassificationConfig,
|
||||
type: "movie" | "tv",
|
||||
raw: Record<string, unknown> | null | undefined,
|
||||
): ClassificationResult {
|
||||
const none: ClassificationResult = { category: null, matchedFields: [], fallback: false };
|
||||
if (!raw || !Object.keys(raw).length) return none;
|
||||
for (const rule of config[type]) {
|
||||
if (rule.conditions.every(({ field, values }) => matches(actualValues(raw, type, field), values, field)))
|
||||
return {
|
||||
category: rule.category,
|
||||
matchedFields: rule.conditions.map((c) => c.field),
|
||||
fallback: !rule.conditions.length,
|
||||
};
|
||||
}
|
||||
return none;
|
||||
}
|
||||
@@ -2,6 +2,7 @@
|
||||
export const PACKAGE_NAME = "@umt/domain";
|
||||
|
||||
export * from "./acquisition/index.ts";
|
||||
export * from "./classification.ts";
|
||||
export * from "./download-state/index.ts";
|
||||
export * from "./identity/index.ts";
|
||||
export * from "./library/versions.ts";
|
||||
|
||||
@@ -15,5 +15,6 @@ export {
|
||||
planOrganize,
|
||||
type SourceFile,
|
||||
} from "./plan.ts";
|
||||
export * from "./replacement.ts";
|
||||
export { type DefaultSubtitleLang, sidecarLanguageSuffix, sidecarStem } from "./sidecars.ts";
|
||||
export { findOtherVersions } from "./versions.ts";
|
||||
@@ -13,7 +13,7 @@ import {
|
||||
splitExt,
|
||||
} from "./sidecars.ts";
|
||||
|
||||
export type OrganizeOperation = "copy" | "move" | "rename";
|
||||
export type OrganizeOperation = "copy" | "move" | "rename" | "in_place";
|
||||
export type OrganizeFileKind = "video" | "subtitle" | "audio" | "nfo" | "other";
|
||||
export type ExistingPolicy = "skip" | "replace_with_verify" | "conflict";
|
||||
|
||||
@@ -52,6 +52,8 @@ export interface OrganizeInput {
|
||||
/** 主视频最小体积,默认 50 MiB;低于此值视为样例/垃圾 */
|
||||
minVideoBytes?: number;
|
||||
grants?: { replace?: boolean };
|
||||
/** Explicit one-time replacement grants, restricted to the selected old library paths. */
|
||||
replacePaths?: readonly string[];
|
||||
parse?: ParseOptions;
|
||||
/** 随行字幕里此语言加 .default 标记(对照 MP DEFAULT_SUB);不设不加 */
|
||||
defaultSubtitleLang?: DefaultSubtitleLang;
|
||||
@@ -198,6 +200,7 @@ export function planOrganize(input: OrganizeInput): OrganizePlan {
|
||||
const existing = new Map((input.existingTargets ?? []).map((e) => [e.path, e]));
|
||||
const targetDevice = input.target.device;
|
||||
const isRename = input.operation === "rename";
|
||||
const inPlace = input.operation === "in_place";
|
||||
|
||||
const videos: { f: SourceFile; parsed: ParsedRelease; dst: string }[] = [];
|
||||
const sidecars: SourceFile[] = [];
|
||||
@@ -232,6 +235,15 @@ export function planOrganize(input: OrganizeInput): OrganizePlan {
|
||||
excluded.push({ src: f.path, kind, reason: "extra_content" });
|
||||
continue;
|
||||
}
|
||||
if (inPlace) {
|
||||
if (input.mediaType === "tv" && !parsed.episodes && !parsed.airDate) {
|
||||
excluded.push({ src: f.path, kind, reason: "no_episode" });
|
||||
continue;
|
||||
}
|
||||
if (input.mediaType === "tv" && parsed.season === undefined) parsed.season = 1;
|
||||
videos.push({ f, parsed, dst: f.path });
|
||||
continue;
|
||||
}
|
||||
const [, ext] = splitExt(basename(f.path));
|
||||
let dir: string | undefined;
|
||||
let named: ReturnType<typeof renderMediaFileName>;
|
||||
@@ -276,7 +288,7 @@ export function planOrganize(input: OrganizeInput): OrganizePlan {
|
||||
kind: "video",
|
||||
role: "main",
|
||||
action: "transfer",
|
||||
...(sameDevice(v.f.device, targetDevice) !== undefined
|
||||
...(!inPlace && sameDevice(v.f.device, targetDevice) !== undefined
|
||||
? { crossDevice: sameDevice(v.f.device, targetDevice) }
|
||||
: {}),
|
||||
...(v.parsed.season !== undefined ? { season: v.parsed.season } : {}),
|
||||
@@ -310,7 +322,7 @@ export function planOrganize(input: OrganizeInput): OrganizePlan {
|
||||
const [mainStem] = splitExt(main.dst);
|
||||
const [, ext] = splitExt(basename(s.path));
|
||||
const suffix = sidecarLanguageSuffix(tags, input.defaultSubtitleLang);
|
||||
let dst = `${mainStem}${suffix}.${ext.toLowerCase()}`;
|
||||
let dst = inPlace ? s.path : `${mainStem}${suffix}.${ext.toLowerCase()}`;
|
||||
for (let n = 1; usedSidecarDst.has(dst); n++) dst = `${mainStem}${suffix}.${n}.${ext.toLowerCase()}`;
|
||||
usedSidecarDst.add(dst);
|
||||
planned.push({
|
||||
@@ -321,7 +333,9 @@ export function planOrganize(input: OrganizeInput): OrganizePlan {
|
||||
role: "sidecar",
|
||||
mainSrc: main.f.path,
|
||||
action: "transfer",
|
||||
...(sameDevice(s.device, targetDevice) !== undefined ? { crossDevice: sameDevice(s.device, targetDevice) } : {}),
|
||||
...(!inPlace && sameDevice(s.device, targetDevice) !== undefined
|
||||
? { crossDevice: sameDevice(s.device, targetDevice) }
|
||||
: {}),
|
||||
});
|
||||
}
|
||||
|
||||
@@ -337,7 +351,7 @@ export function planOrganize(input: OrganizeInput): OrganizePlan {
|
||||
// 目标已存在
|
||||
const replaced: string[] = [];
|
||||
for (const p of planned) {
|
||||
if (p.action !== "transfer") continue;
|
||||
if (inPlace || p.action !== "transfer") continue;
|
||||
const e = existing.get(p.dst);
|
||||
if (!e) continue;
|
||||
if (e.size === p.size && e.sha256 !== undefined && e.sha256 === input.files.find((f) => f.path === p.src)?.sha256) {
|
||||
@@ -349,7 +363,7 @@ export function planOrganize(input: OrganizeInput): OrganizePlan {
|
||||
p.action = "skip";
|
||||
p.skipReason = "target_exists";
|
||||
conflicts.push({ kind: "target_exists", blocking: false, src: p.src, dst: p.dst, detail: "skipped" });
|
||||
} else if (onExisting === "replace_with_verify") {
|
||||
} else if (onExisting === "replace_with_verify" && (!input.replacePaths || input.replacePaths.includes(p.dst))) {
|
||||
p.action = "replace";
|
||||
replaced.push(p.dst);
|
||||
if (!input.grants?.replace)
|
||||
@@ -397,10 +411,11 @@ export function planOrganize(input: OrganizeInput): OrganizePlan {
|
||||
bytes,
|
||||
});
|
||||
}
|
||||
preconditions.push({
|
||||
kind: "target_absent",
|
||||
paths: active.filter((p) => p.action === "transfer").map((p) => p.dst),
|
||||
});
|
||||
if (!inPlace)
|
||||
preconditions.push({
|
||||
kind: "target_absent",
|
||||
paths: active.filter((p) => p.action === "transfer").map((p) => p.dst),
|
||||
});
|
||||
preconditions.push({ kind: "source_unchanged", files: active.map((p) => ({ path: p.src, size: p.size })) });
|
||||
const verify = active.filter((p) => !isRename && needsCopy(p)).map((p) => p.dst);
|
||||
if (verify.length > 0) preconditions.push({ kind: "verify_after_copy", paths: verify });
|
||||
|
||||
@@ -0,0 +1,19 @@
|
||||
import { describe, expect, it } from "vitest";
|
||||
import { replacementCovers, replacementScope } from "./replacement.ts";
|
||||
|
||||
describe("one-time replacement coverage", () => {
|
||||
it("movies require the same Part", () => {
|
||||
const old = replacementScope("Movie.2020.720p.Part1.mkv", "movie");
|
||||
expect(replacementCovers(old, [replacementScope("Movie.2020.1080p.Part2.mkv", "movie")])).toBe(false);
|
||||
expect(replacementCovers(old, [replacementScope("Movie.2020.1080p.Part1.mkv", "movie")])).toBe(true);
|
||||
});
|
||||
it("replaces only episodes fully covered by successful files, preserving indivisible merged ranges", () => {
|
||||
const success = [1, 2, 3, 5, 6].map((n) => replacementScope(`Show.S01E${String(n).padStart(2, "0")}.mkv`, "tv"));
|
||||
expect(replacementCovers(replacementScope("Show.S01E01.mkv", "tv"), success)).toBe(true);
|
||||
expect(replacementCovers(replacementScope("Show.S01E04.mkv", "tv"), success)).toBe(false);
|
||||
expect(replacementCovers(replacementScope("Show.S01E07.mkv", "tv"), success)).toBe(false);
|
||||
expect(replacementCovers(replacementScope("Show.S01E01-E10.mkv", "tv"), success)).toBe(false);
|
||||
expect(replacementCovers(replacementScope("Show.S02E01.mkv", "tv"), success)).toBe(false);
|
||||
expect(replacementCovers(replacementScope("Show.Special.mkv", "tv"), success)).toBe(false);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,35 @@
|
||||
import { parseReleasePath } from "../release-parser/path.ts";
|
||||
|
||||
/** Physical files are indivisible: every covered unit must have a successful replacement. */
|
||||
export interface ReplacementScope {
|
||||
mediaType: "movie" | "tv";
|
||||
part: string;
|
||||
season?: number;
|
||||
episodes?: number[];
|
||||
}
|
||||
export function replacementScope(
|
||||
path: string,
|
||||
mediaType: "movie" | "tv",
|
||||
units?: { season?: number; episodes?: number[] },
|
||||
): ReplacementScope {
|
||||
const parsed = parseReleasePath(path);
|
||||
const episodes =
|
||||
units?.episodes ??
|
||||
(parsed.episodes
|
||||
? Array.from({ length: parsed.episodes.end - parsed.episodes.start + 1 }, (_, i) => parsed.episodes!.start + i)
|
||||
: undefined);
|
||||
const season = units?.season ?? parsed.season;
|
||||
return {
|
||||
mediaType,
|
||||
part: (parsed.part ?? "").toLowerCase(),
|
||||
...(season !== undefined ? { season } : {}),
|
||||
...(episodes ? { episodes } : {}),
|
||||
};
|
||||
}
|
||||
export function replacementCovers(old: ReplacementScope, successful: readonly ReplacementScope[]): boolean {
|
||||
const compatible = successful.filter((s) => s.mediaType === old.mediaType && s.part === old.part);
|
||||
if (old.mediaType === "movie") return compatible.length > 0;
|
||||
if (old.season === undefined || !old.episodes?.length) return false;
|
||||
const episodes = new Set(compatible.filter((s) => s.season === old.season).flatMap((s) => s.episodes ?? []));
|
||||
return old.episodes.every((e) => episodes.has(e));
|
||||
}
|
||||
@@ -332,3 +332,36 @@ describe("W4-E4:字幕 .default 与 latest 旧版本判定口径(对照 MP)", ()
|
||||
]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("原地入库计划", () => {
|
||||
it("保留视频与配对字幕路径，不依赖命名模板和目标，不要求搬运空间或目标不存在", () => {
|
||||
const input = tvInput({
|
||||
operation: "in_place",
|
||||
target: { device: 2 },
|
||||
templates: { version: 2, movie: "{{invalid}}", tv: "{{invalid}}", variety: "{{invalid}}" },
|
||||
});
|
||||
const p = planOrganize(input);
|
||||
expect(p.files).toHaveLength(4);
|
||||
expect(p.files.every((f) => f.src === f.dst && f.action === "transfer")).toBe(true);
|
||||
expect(p.requiresApproval).toBe(false);
|
||||
expect(p.crossDevice).toBe(false);
|
||||
expect(p.preconditions.map((p) => p.kind)).toEqual(["source_unchanged"]);
|
||||
expect(p.files[0]?.season).toBe(1);
|
||||
expect(p.files[0]?.episodes).toEqual({ start: 1, end: 1 });
|
||||
});
|
||||
it("不将当前文件视作目标冲突，仍排除样例与无法定位的剧集", () => {
|
||||
const input = tvInput({
|
||||
operation: "in_place",
|
||||
files: [
|
||||
{ path: `${ROOT}/Unknown.mkv`, size: GiB },
|
||||
{ path: `${ROOT}/Known.S02E03.mkv`, size: GiB },
|
||||
{ path: `${ROOT}/sample.mkv`, size: GiB },
|
||||
],
|
||||
});
|
||||
const p = planOrganize({ ...input, existingTargets: input.files.map((f) => ({ path: f.path, size: f.size })) });
|
||||
expect(p.files).toHaveLength(1);
|
||||
expect(p.files[0]?.dst).toBe(`${ROOT}/Known.S02E03.mkv`);
|
||||
expect(p.excluded.map((f) => f.reason)).toEqual(["no_episode", "sample"]);
|
||||
expect(p.requiresApproval).toBe(false);
|
||||
});
|
||||
});
|
||||
Reference in new issue
Block a user