mirror of
https://github.com/ksyasuda/SubMiner.git
synced 2026-08-05 19:21:35 -07:00
641 lines
21 KiB
TypeScript
641 lines
21 KiB
TypeScript
import * as fs from 'fs';
|
|
import * as path from 'path';
|
|
import { ensureDir } from '../../shared/fs-utils';
|
|
import type { AnilistCharacterDictionaryProfileScope } from '../../types';
|
|
import type {
|
|
CharacterDictionarySnapshotProgressCallbacks,
|
|
CharacterDictionarySnapshotResult,
|
|
MergedCharacterDictionaryBuildResult,
|
|
} from '../character-dictionary-runtime';
|
|
|
|
type AutoSyncMediaEntry = {
|
|
mediaId: number;
|
|
label: string;
|
|
};
|
|
|
|
type AutoSyncState = {
|
|
activeMediaIds: AutoSyncMediaEntry[];
|
|
mergedRevision: string | null;
|
|
mergedDictionaryTitle: string | null;
|
|
};
|
|
|
|
type AutoSyncDictionaryInfo = {
|
|
title: string;
|
|
revision?: string | number;
|
|
};
|
|
|
|
export interface CharacterDictionaryManagerEntry {
|
|
mediaId: number;
|
|
label: string;
|
|
title: string;
|
|
current: boolean;
|
|
}
|
|
|
|
export interface CharacterDictionaryManagerSnapshot {
|
|
entries: CharacterDictionaryManagerEntry[];
|
|
}
|
|
|
|
export type CharacterDictionaryManagerMutationResult =
|
|
| (CharacterDictionaryManagerSnapshot & { ok: true; rebuildRequired?: boolean })
|
|
| { ok: false; message: string; entries: CharacterDictionaryManagerEntry[] };
|
|
|
|
export interface CharacterDictionaryAutoSyncConfig {
|
|
enabled: boolean;
|
|
maxLoaded: number;
|
|
profileScope: AnilistCharacterDictionaryProfileScope;
|
|
}
|
|
|
|
export interface CharacterDictionaryAutoSyncStatusEvent {
|
|
phase: 'checking' | 'generating' | 'syncing' | 'building' | 'importing' | 'ready' | 'failed';
|
|
mediaId?: number;
|
|
mediaTitle?: string;
|
|
message: string;
|
|
changed?: boolean;
|
|
}
|
|
|
|
export interface CharacterDictionaryAutoSyncRuntimeDeps {
|
|
userDataPath: string;
|
|
getConfig: () => CharacterDictionaryAutoSyncConfig;
|
|
getOrCreateCurrentSnapshot: (
|
|
targetPath?: string,
|
|
progress?: CharacterDictionarySnapshotProgressCallbacks,
|
|
) => Promise<CharacterDictionarySnapshotResult>;
|
|
buildMergedDictionary: (mediaIds: number[]) => Promise<MergedCharacterDictionaryBuildResult>;
|
|
waitForYomitanMutationReady?: () => Promise<void>;
|
|
getYomitanDictionaryInfo: () => Promise<AutoSyncDictionaryInfo[]>;
|
|
importYomitanDictionary: (zipPath: string) => Promise<boolean>;
|
|
deleteYomitanDictionary: (dictionaryTitle: string) => Promise<boolean>;
|
|
upsertYomitanDictionarySettings: (
|
|
dictionaryTitle: string,
|
|
profileScope: AnilistCharacterDictionaryProfileScope,
|
|
) => Promise<boolean>;
|
|
now: () => number;
|
|
schedule?: (fn: () => void, delayMs: number) => ReturnType<typeof setTimeout>;
|
|
clearSchedule?: (timer: ReturnType<typeof setTimeout>) => void;
|
|
operationTimeoutMs?: number;
|
|
logInfo?: (message: string) => void;
|
|
logWarn?: (message: string) => void;
|
|
onSyncStatus?: (event: CharacterDictionaryAutoSyncStatusEvent) => void;
|
|
onSyncComplete?: (result: { mediaId: number; mediaTitle: string; changed: boolean }) => void;
|
|
}
|
|
|
|
function normalizeMediaId(rawMediaId: number): number | null {
|
|
const mediaId = Math.max(1, Math.floor(rawMediaId));
|
|
return Number.isFinite(mediaId) ? mediaId : null;
|
|
}
|
|
|
|
function parseActiveMediaEntry(rawEntry: unknown): AutoSyncMediaEntry | null {
|
|
if (typeof rawEntry === 'number') {
|
|
const mediaId = normalizeMediaId(rawEntry);
|
|
if (mediaId === null) {
|
|
return null;
|
|
}
|
|
return { mediaId, label: String(mediaId) };
|
|
}
|
|
|
|
if (typeof rawEntry !== 'string') {
|
|
return null;
|
|
}
|
|
|
|
const trimmed = rawEntry.trim();
|
|
if (!trimmed) {
|
|
return null;
|
|
}
|
|
|
|
const [rawId, ...rawTitleParts] = trimmed.split(' - ');
|
|
if (!rawId || !/^\d+$/.test(rawId)) {
|
|
return null;
|
|
}
|
|
const mediaId = normalizeMediaId(Number.parseInt(rawId ?? '', 10));
|
|
if (mediaId === null || mediaId <= 0) {
|
|
return null;
|
|
}
|
|
|
|
const rawLabel = rawTitleParts.length > 0 ? rawTitleParts.join(' - ').trim() : '';
|
|
return { mediaId, label: rawLabel ? `${mediaId} - ${rawLabel}` : String(mediaId) };
|
|
}
|
|
|
|
function buildActiveMediaLabel(mediaId: number, mediaTitle: string | null | undefined): string {
|
|
const normalizedId = normalizeMediaId(mediaId);
|
|
const trimmedTitle = typeof mediaTitle === 'string' ? mediaTitle.trim() : '';
|
|
if (normalizedId === null) {
|
|
return trimmedTitle;
|
|
}
|
|
return trimmedTitle.length > 0 ? `${normalizedId} - ${trimmedTitle}` : String(normalizedId);
|
|
}
|
|
|
|
function readAutoSyncState(statePath: string): AutoSyncState {
|
|
try {
|
|
const raw = fs.readFileSync(statePath, 'utf8');
|
|
const parsed = JSON.parse(raw) as Partial<AutoSyncState>;
|
|
const activeMediaIds: AutoSyncMediaEntry[] = [];
|
|
const activeMediaIdSet = new Set<number>();
|
|
if (Array.isArray(parsed.activeMediaIds)) {
|
|
for (const value of parsed.activeMediaIds) {
|
|
const entry = parseActiveMediaEntry(value);
|
|
if (entry && !activeMediaIdSet.has(entry.mediaId)) {
|
|
activeMediaIdSet.add(entry.mediaId);
|
|
activeMediaIds.push(entry);
|
|
}
|
|
}
|
|
}
|
|
return {
|
|
activeMediaIds,
|
|
mergedRevision:
|
|
typeof parsed.mergedRevision === 'string' && parsed.mergedRevision.length > 0
|
|
? parsed.mergedRevision
|
|
: null,
|
|
mergedDictionaryTitle:
|
|
typeof parsed.mergedDictionaryTitle === 'string' && parsed.mergedDictionaryTitle.length > 0
|
|
? parsed.mergedDictionaryTitle
|
|
: null,
|
|
};
|
|
} catch {
|
|
return {
|
|
activeMediaIds: [],
|
|
mergedRevision: null,
|
|
mergedDictionaryTitle: null,
|
|
};
|
|
}
|
|
}
|
|
|
|
function writeAutoSyncState(statePath: string, state: AutoSyncState): void {
|
|
ensureDir(path.dirname(statePath));
|
|
const persistedState = {
|
|
activeMediaIds: state.activeMediaIds.map((entry) => entry.label),
|
|
mergedRevision: state.mergedRevision,
|
|
mergedDictionaryTitle: state.mergedDictionaryTitle,
|
|
};
|
|
fs.writeFileSync(statePath, JSON.stringify(persistedState, null, 2), 'utf8');
|
|
}
|
|
|
|
function getAutoSyncStatePath(userDataPath: string): string {
|
|
return path.join(userDataPath, 'character-dictionaries', 'auto-sync-state.json');
|
|
}
|
|
|
|
function parseActiveMediaTitle(entry: AutoSyncMediaEntry): string {
|
|
const prefix = `${entry.mediaId} - `;
|
|
if (entry.label.startsWith(prefix)) {
|
|
return entry.label.slice(prefix.length).trim();
|
|
}
|
|
return entry.label === String(entry.mediaId) ? '' : entry.label.trim();
|
|
}
|
|
|
|
function resolveCurrentManagerMediaId(
|
|
state: AutoSyncState,
|
|
currentMediaId?: number | null,
|
|
): number | null {
|
|
const normalizedCurrentMediaId =
|
|
typeof currentMediaId === 'number' ? normalizeMediaId(currentMediaId) : null;
|
|
if (normalizedCurrentMediaId !== null) return normalizedCurrentMediaId;
|
|
return state.activeMediaIds[0]?.mediaId ?? null;
|
|
}
|
|
|
|
function toManagerEntries(
|
|
state: AutoSyncState,
|
|
currentMediaId?: number | null,
|
|
): CharacterDictionaryManagerEntry[] {
|
|
const resolvedCurrentMediaId = resolveCurrentManagerMediaId(state, currentMediaId);
|
|
return state.activeMediaIds.map((entry, index) => ({
|
|
mediaId: entry.mediaId,
|
|
label: entry.label,
|
|
title: parseActiveMediaTitle(entry),
|
|
current:
|
|
resolvedCurrentMediaId !== null ? entry.mediaId === resolvedCurrentMediaId : index === 0,
|
|
}));
|
|
}
|
|
|
|
export function getCharacterDictionaryManagerSnapshot(
|
|
userDataPath: string,
|
|
currentMediaId?: number | null,
|
|
): CharacterDictionaryManagerSnapshot {
|
|
return {
|
|
entries: toManagerEntries(
|
|
readAutoSyncState(getAutoSyncStatePath(userDataPath)),
|
|
currentMediaId,
|
|
),
|
|
};
|
|
}
|
|
|
|
export function moveCharacterDictionaryManagedEntry(
|
|
userDataPath: string,
|
|
mediaId: number,
|
|
direction: 1 | -1,
|
|
currentMediaId?: number | null,
|
|
): CharacterDictionaryManagerMutationResult {
|
|
const statePath = getAutoSyncStatePath(userDataPath);
|
|
const state = readAutoSyncState(statePath);
|
|
const managerEntries = toManagerEntries(state, currentMediaId);
|
|
const index = state.activeMediaIds.findIndex((entry) => entry.mediaId === mediaId);
|
|
if (index < 0) {
|
|
return {
|
|
ok: false,
|
|
message: 'Character dictionary entry not found.',
|
|
entries: managerEntries,
|
|
};
|
|
}
|
|
if (managerEntries[index]?.current) {
|
|
return {
|
|
ok: false,
|
|
message: 'The current anime stays anchored while you are watching it.',
|
|
entries: managerEntries,
|
|
};
|
|
}
|
|
const targetIndex = Math.min(state.activeMediaIds.length - 1, Math.max(0, index + direction));
|
|
if (targetIndex === index) {
|
|
return { ok: true, entries: managerEntries };
|
|
}
|
|
const nextActiveMediaIds = [...state.activeMediaIds];
|
|
const [entry] = nextActiveMediaIds.splice(index, 1);
|
|
if (entry) {
|
|
nextActiveMediaIds.splice(targetIndex, 0, entry);
|
|
}
|
|
const nextState = { ...state, activeMediaIds: nextActiveMediaIds, mergedRevision: null };
|
|
writeAutoSyncState(statePath, nextState);
|
|
return { ok: true, entries: toManagerEntries(nextState, currentMediaId), rebuildRequired: true };
|
|
}
|
|
|
|
export function removeCharacterDictionaryManagedEntry(
|
|
userDataPath: string,
|
|
mediaId: number,
|
|
currentMediaId?: number | null,
|
|
): CharacterDictionaryManagerMutationResult {
|
|
const statePath = getAutoSyncStatePath(userDataPath);
|
|
const state = readAutoSyncState(statePath);
|
|
const managerEntries = toManagerEntries(state, currentMediaId);
|
|
const index = state.activeMediaIds.findIndex((entry) => entry.mediaId === mediaId);
|
|
if (index < 0) {
|
|
return {
|
|
ok: false,
|
|
message: 'Character dictionary entry not found.',
|
|
entries: managerEntries,
|
|
};
|
|
}
|
|
if (managerEntries[index]?.current) {
|
|
return {
|
|
ok: false,
|
|
message: 'The current anime stays loaded while you are watching it.',
|
|
entries: managerEntries,
|
|
};
|
|
}
|
|
const nextState = {
|
|
...state,
|
|
activeMediaIds: state.activeMediaIds.filter((entry) => entry.mediaId !== mediaId),
|
|
mergedRevision: null,
|
|
};
|
|
writeAutoSyncState(statePath, nextState);
|
|
return { ok: true, entries: toManagerEntries(nextState, currentMediaId), rebuildRequired: true };
|
|
}
|
|
|
|
export function replaceCharacterDictionaryManagedEntry(
|
|
userDataPath: string,
|
|
mediaId: number,
|
|
replacement: { mediaId: number; mediaTitle: string },
|
|
): CharacterDictionaryManagerMutationResult {
|
|
const statePath = getAutoSyncStatePath(userDataPath);
|
|
const state = readAutoSyncState(statePath);
|
|
const index = state.activeMediaIds.findIndex((entry) => entry.mediaId === mediaId);
|
|
if (index < 0) {
|
|
return {
|
|
ok: false,
|
|
message: 'Character dictionary entry not found.',
|
|
entries: toManagerEntries(state),
|
|
};
|
|
}
|
|
const normalizedReplacementMediaId = normalizeMediaId(replacement.mediaId);
|
|
const mediaTitle = replacement.mediaTitle.trim();
|
|
if (normalizedReplacementMediaId === null || !mediaTitle) {
|
|
return {
|
|
ok: false,
|
|
message: 'Invalid replacement AniList media.',
|
|
entries: toManagerEntries(state),
|
|
};
|
|
}
|
|
const replacementEntry = {
|
|
mediaId: normalizedReplacementMediaId,
|
|
label: buildActiveMediaLabel(normalizedReplacementMediaId, mediaTitle),
|
|
};
|
|
const nextActiveMediaIds = state.activeMediaIds
|
|
.map((entry, entryIndex) => (entryIndex === index ? replacementEntry : entry))
|
|
.filter(
|
|
(entry, entryIndex, entries) =>
|
|
entries.findIndex((candidate) => candidate.mediaId === entry.mediaId) === entryIndex,
|
|
);
|
|
const nextState = {
|
|
...state,
|
|
activeMediaIds: nextActiveMediaIds,
|
|
mergedRevision: null,
|
|
};
|
|
writeAutoSyncState(statePath, nextState);
|
|
return { ok: true, entries: toManagerEntries(nextState), rebuildRequired: true };
|
|
}
|
|
|
|
function arraysEqual(left: number[], right: number[]): boolean {
|
|
if (left.length !== right.length) return false;
|
|
for (let i = 0; i < left.length; i += 1) {
|
|
if (left[i] !== right[i]) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
function sameMembership(left: number[], right: number[]): boolean {
|
|
if (left.length !== right.length) return false;
|
|
const leftSorted = [...left].sort((a, b) => a - b);
|
|
const rightSorted = [...right].sort((a, b) => a - b);
|
|
return arraysEqual(leftSorted, rightSorted);
|
|
}
|
|
|
|
function buildSyncingMessage(mediaTitle: string): string {
|
|
return `Updating character dictionary for ${mediaTitle}...`;
|
|
}
|
|
|
|
function buildCheckingMessage(mediaTitle: string): string {
|
|
return `Checking character dictionary for ${mediaTitle}...`;
|
|
}
|
|
|
|
function buildGeneratingMessage(mediaTitle: string): string {
|
|
return `Generating character dictionary for ${mediaTitle}...`;
|
|
}
|
|
|
|
function buildImportingMessage(mediaTitle: string): string {
|
|
return `Importing character dictionary for ${mediaTitle}...`;
|
|
}
|
|
|
|
function buildBuildingMessage(mediaTitle: string): string {
|
|
return `Building character dictionary for ${mediaTitle}...`;
|
|
}
|
|
|
|
function buildReadyMessage(mediaTitle: string): string {
|
|
return `Character dictionary ready for ${mediaTitle}`;
|
|
}
|
|
|
|
function buildFailedMessage(mediaTitle: string | null, errorMessage: string): string {
|
|
if (mediaTitle) {
|
|
return `Character dictionary sync failed for ${mediaTitle}: ${errorMessage}`;
|
|
}
|
|
return `Character dictionary sync failed: ${errorMessage}`;
|
|
}
|
|
|
|
export function createCharacterDictionaryAutoSyncRuntimeService(
|
|
deps: CharacterDictionaryAutoSyncRuntimeDeps,
|
|
): {
|
|
scheduleSync: () => void;
|
|
runSyncNow: () => Promise<void>;
|
|
getCurrentMediaId: () => number | null;
|
|
} {
|
|
const dictionariesDir = path.join(deps.userDataPath, 'character-dictionaries');
|
|
const statePath = getAutoSyncStatePath(deps.userDataPath);
|
|
const schedule = deps.schedule ?? ((fn, delayMs) => setTimeout(fn, delayMs));
|
|
const clearSchedule = deps.clearSchedule ?? ((timer) => clearTimeout(timer));
|
|
const debounceMs = 800;
|
|
const operationTimeoutMs = Math.max(1, Math.floor(deps.operationTimeoutMs ?? 7_000));
|
|
|
|
let debounceTimer: ReturnType<typeof setTimeout> | null = null;
|
|
let syncInFlight = false;
|
|
let runQueued = false;
|
|
let activeCurrentMediaId: number | null = null;
|
|
|
|
const withOperationTimeout = async <T>(label: string, promise: Promise<T>): Promise<T> => {
|
|
let timer: ReturnType<typeof setTimeout> | null = null;
|
|
try {
|
|
return await Promise.race([
|
|
promise,
|
|
new Promise<never>((_resolve, reject) => {
|
|
timer = setTimeout(() => {
|
|
reject(new Error(`${label} timed out after ${operationTimeoutMs}ms`));
|
|
}, operationTimeoutMs);
|
|
}),
|
|
]);
|
|
} finally {
|
|
if (timer !== null) {
|
|
clearTimeout(timer);
|
|
}
|
|
}
|
|
};
|
|
|
|
const runSyncOnce = async (): Promise<void> => {
|
|
const config = deps.getConfig();
|
|
if (!config.enabled) {
|
|
activeCurrentMediaId = null;
|
|
return;
|
|
}
|
|
|
|
let currentMediaId: number | undefined;
|
|
let currentMediaTitle: string | null = null;
|
|
|
|
try {
|
|
deps.logInfo?.('[dictionary:auto-sync] syncing current anime snapshot');
|
|
const snapshot = await deps.getOrCreateCurrentSnapshot(undefined, {
|
|
onChecking: ({ mediaId, mediaTitle }) => {
|
|
currentMediaId = mediaId;
|
|
currentMediaTitle = mediaTitle;
|
|
activeCurrentMediaId = mediaId;
|
|
deps.onSyncStatus?.({
|
|
phase: 'checking',
|
|
mediaId,
|
|
mediaTitle,
|
|
message: buildCheckingMessage(mediaTitle),
|
|
});
|
|
},
|
|
onGenerating: ({ mediaId, mediaTitle }) => {
|
|
currentMediaId = mediaId;
|
|
currentMediaTitle = mediaTitle;
|
|
activeCurrentMediaId = mediaId;
|
|
deps.onSyncStatus?.({
|
|
phase: 'generating',
|
|
mediaId,
|
|
mediaTitle,
|
|
message: buildGeneratingMessage(mediaTitle),
|
|
});
|
|
},
|
|
});
|
|
currentMediaId = snapshot.mediaId;
|
|
currentMediaTitle = snapshot.mediaTitle;
|
|
activeCurrentMediaId = snapshot.mediaId;
|
|
const state = readAutoSyncState(statePath);
|
|
const staleMediaIds = new Set(
|
|
(snapshot.staleMediaIds ?? [])
|
|
.map((mediaId) => normalizeMediaId(mediaId))
|
|
.filter((mediaId): mediaId is number => mediaId !== null),
|
|
);
|
|
const nextActiveMediaIds = [
|
|
{
|
|
mediaId: snapshot.mediaId,
|
|
label: buildActiveMediaLabel(snapshot.mediaId, snapshot.mediaTitle),
|
|
},
|
|
...state.activeMediaIds.filter(
|
|
(entry) => entry.mediaId !== snapshot.mediaId && !staleMediaIds.has(entry.mediaId),
|
|
),
|
|
].slice(0, Math.max(1, Math.floor(config.maxLoaded)));
|
|
const nextActiveMediaIdValues = nextActiveMediaIds.map((entry) => entry.mediaId);
|
|
deps.logInfo?.(
|
|
`[dictionary:auto-sync] active AniList media set: ${nextActiveMediaIds
|
|
.map((entry) => entry.label)
|
|
.join(', ')}`,
|
|
);
|
|
|
|
const stateMediaIds = state.activeMediaIds.map((entry) => entry.mediaId);
|
|
const retainedOrderChanged = !arraysEqual(nextActiveMediaIdValues, stateMediaIds);
|
|
const retainedMembershipChanged = !sameMembership(nextActiveMediaIdValues, stateMediaIds);
|
|
let merged: MergedCharacterDictionaryBuildResult | null = null;
|
|
if (
|
|
retainedMembershipChanged ||
|
|
!state.mergedRevision ||
|
|
!state.mergedDictionaryTitle ||
|
|
!snapshot.fromCache
|
|
) {
|
|
deps.onSyncStatus?.({
|
|
phase: 'building',
|
|
mediaId: snapshot.mediaId,
|
|
mediaTitle: snapshot.mediaTitle,
|
|
message: buildBuildingMessage(snapshot.mediaTitle),
|
|
});
|
|
deps.logInfo?.('[dictionary:auto-sync] rebuilding merged dictionary for active anime set');
|
|
merged = await deps.buildMergedDictionary(nextActiveMediaIdValues);
|
|
}
|
|
|
|
const dictionaryTitle = merged?.dictionaryTitle ?? state.mergedDictionaryTitle;
|
|
const revision = merged?.revision ?? state.mergedRevision;
|
|
if (!dictionaryTitle || !revision) {
|
|
throw new Error('Merged character dictionary state is incomplete.');
|
|
}
|
|
|
|
writeAutoSyncState(statePath, {
|
|
activeMediaIds: nextActiveMediaIds,
|
|
mergedRevision: merged?.revision ?? revision,
|
|
mergedDictionaryTitle: merged?.dictionaryTitle ?? dictionaryTitle,
|
|
});
|
|
|
|
await deps.waitForYomitanMutationReady?.();
|
|
|
|
const dictionaryInfo = await withOperationTimeout(
|
|
'getYomitanDictionaryInfo',
|
|
deps.getYomitanDictionaryInfo(),
|
|
);
|
|
const existing = dictionaryInfo.find((entry) => entry.title === dictionaryTitle) ?? null;
|
|
const existingRevision =
|
|
existing && (typeof existing.revision === 'string' || typeof existing.revision === 'number')
|
|
? String(existing.revision)
|
|
: null;
|
|
const shouldImport =
|
|
merged !== null ||
|
|
existing === null ||
|
|
existingRevision === null ||
|
|
existingRevision !== revision;
|
|
let changed = merged !== null || retainedOrderChanged;
|
|
|
|
if (shouldImport) {
|
|
deps.onSyncStatus?.({
|
|
phase: 'importing',
|
|
mediaId: snapshot.mediaId,
|
|
mediaTitle: snapshot.mediaTitle,
|
|
message: buildImportingMessage(snapshot.mediaTitle),
|
|
});
|
|
if (existing !== null) {
|
|
await withOperationTimeout(
|
|
`deleteYomitanDictionary(${dictionaryTitle})`,
|
|
deps.deleteYomitanDictionary(dictionaryTitle),
|
|
);
|
|
}
|
|
if (merged === null) {
|
|
const existingMergedZipPath = path.join(dictionariesDir, 'merged.zip');
|
|
if (fs.existsSync(existingMergedZipPath)) {
|
|
merged = {
|
|
zipPath: existingMergedZipPath,
|
|
revision,
|
|
dictionaryTitle,
|
|
entryCount: snapshot.entryCount,
|
|
};
|
|
} else {
|
|
merged = await deps.buildMergedDictionary(nextActiveMediaIdValues);
|
|
}
|
|
}
|
|
deps.logInfo?.(`[dictionary:auto-sync] importing merged dictionary: ${merged.zipPath}`);
|
|
const imported = await withOperationTimeout(
|
|
`importYomitanDictionary(${path.basename(merged.zipPath)})`,
|
|
deps.importYomitanDictionary(merged.zipPath),
|
|
);
|
|
if (!imported) {
|
|
throw new Error(`Failed to import dictionary ZIP: ${merged.zipPath}`);
|
|
}
|
|
changed = true;
|
|
}
|
|
|
|
deps.logInfo?.(`[dictionary:auto-sync] applying Yomitan settings for ${dictionaryTitle}`);
|
|
const settingsUpdated = await withOperationTimeout(
|
|
`upsertYomitanDictionarySettings(${dictionaryTitle})`,
|
|
deps.upsertYomitanDictionarySettings(dictionaryTitle, config.profileScope),
|
|
);
|
|
changed = changed || settingsUpdated === true;
|
|
|
|
deps.logInfo?.(
|
|
`[dictionary:auto-sync] synced AniList ${snapshot.mediaId}: ${dictionaryTitle} (${snapshot.entryCount} entries)`,
|
|
);
|
|
deps.onSyncStatus?.({
|
|
phase: 'ready',
|
|
mediaId: snapshot.mediaId,
|
|
mediaTitle: snapshot.mediaTitle,
|
|
message: buildReadyMessage(snapshot.mediaTitle),
|
|
changed,
|
|
});
|
|
deps.onSyncComplete?.({
|
|
mediaId: snapshot.mediaId,
|
|
mediaTitle: snapshot.mediaTitle,
|
|
changed,
|
|
});
|
|
} catch (error) {
|
|
const errorMessage = (error as Error)?.message ?? String(error);
|
|
deps.onSyncStatus?.({
|
|
phase: 'failed',
|
|
mediaId: currentMediaId,
|
|
mediaTitle: currentMediaTitle ?? undefined,
|
|
message: buildFailedMessage(currentMediaTitle, errorMessage),
|
|
});
|
|
throw error;
|
|
}
|
|
};
|
|
|
|
const enqueueSync = (): void => {
|
|
runQueued = true;
|
|
if (syncInFlight) {
|
|
return;
|
|
}
|
|
|
|
syncInFlight = true;
|
|
void (async () => {
|
|
while (runQueued) {
|
|
runQueued = false;
|
|
try {
|
|
await runSyncOnce();
|
|
} catch (error) {
|
|
deps.logWarn?.(
|
|
`[dictionary:auto-sync] sync failed: ${(error as Error)?.message ?? String(error)}`,
|
|
);
|
|
}
|
|
}
|
|
})().finally(() => {
|
|
syncInFlight = false;
|
|
});
|
|
};
|
|
|
|
return {
|
|
scheduleSync: () => {
|
|
const config = deps.getConfig();
|
|
if (!config.enabled) {
|
|
return;
|
|
}
|
|
if (debounceTimer !== null) {
|
|
clearSchedule(debounceTimer);
|
|
}
|
|
debounceTimer = schedule(() => {
|
|
debounceTimer = null;
|
|
enqueueSync();
|
|
}, debounceMs);
|
|
},
|
|
runSyncNow: async () => {
|
|
await runSyncOnce();
|
|
},
|
|
getCurrentMediaId: () => activeCurrentMediaId,
|
|
};
|
|
}
|