1023 lines
38 KiB
TypeScript
1023 lines
38 KiB
TypeScript
import { defineStore } from 'pinia';
|
||
import { loadInitialDataset } from '../utils/yamlLoader';
|
||
import type { PromptDataset, PromptCategory, PromptGroup, PromptTag, LangCode, ExportBundle, CustomDiff, PromptPreset, ExtendedPreset, PresetFolder, PresetManagement, PresetType } from '../types';
|
||
|
||
const LS_KEY = 'ops.prompt.dataset.v1';
|
||
let saveTimer: number | null = null; // 非响应式计时器，避免递归更新
|
||
let baseline: PromptDataset | null = null; // 基线词库（从 public/sd 加载）
|
||
|
||
function deepClone<T>(obj: T): T {
|
||
return JSON.parse(JSON.stringify(obj));
|
||
}
|
||
|
||
export const usePromptStore = defineStore('promptStore', {
|
||
state: () => ({
|
||
dataset: null as PromptDataset | null,
|
||
selectedLang: 'zh_CN' as LangCode,
|
||
selectedCategoryIndex: 0,
|
||
selectedGroupIndex: 0,
|
||
searchQuery: '',
|
||
// 编辑器相关
|
||
promptText: '',
|
||
presets: [] as PromptPreset[],
|
||
// 扩展预设管理
|
||
extendedPresets: [] as ExtendedPreset[],
|
||
presetFolders: [] as PresetFolder[],
|
||
presetManagement: {
|
||
folders: [],
|
||
presets: [],
|
||
settings: {
|
||
autoBackup: true,
|
||
maxPresets: 1000
|
||
}
|
||
} as PresetManagement,
|
||
}),
|
||
getters: {
|
||
categories: (s) => s.dataset?.categories ?? [],
|
||
currentCategory: (s) => s.dataset?.categories[s.selectedCategoryIndex] ?? null,
|
||
currentGroup(): PromptGroup | null {
|
||
return this.currentCategory?.groups[this.selectedGroupIndex] ?? null;
|
||
},
|
||
languages: (s) => s.dataset?.languages ?? ['en'],
|
||
filteredTags(): PromptTag[] {
|
||
const grp = this.currentGroup;
|
||
if (!grp) return [] as PromptTag[];
|
||
const q = this.searchQuery.trim().toLowerCase();
|
||
const qNorm = q.replace(/_/g, ' ');
|
||
if (!q) return grp.tags;
|
||
return grp.tags.filter((t) => {
|
||
const trans = t.translation?.[this.selectedLang] ?? '';
|
||
const keyLower = t.key.toLowerCase();
|
||
const keyNorm = keyLower.replace(/_/g, ' ');
|
||
const transLower = trans.toLowerCase();
|
||
const transNorm = transLower.replace(/_/g, ' ');
|
||
return (
|
||
keyLower.includes(q) ||
|
||
keyNorm.includes(qNorm) ||
|
||
transLower.includes(q) ||
|
||
transNorm.includes(qNorm)
|
||
);
|
||
});
|
||
},
|
||
tokens(s): string[] {
|
||
return splitTokens(s.promptText);
|
||
},
|
||
},
|
||
actions: {
|
||
async initialize() {
|
||
// 先加载基线词库
|
||
baseline = await loadInitialDataset();
|
||
const raw = localStorage.getItem(LS_KEY);
|
||
if (raw) {
|
||
try {
|
||
const bundle = JSON.parse(raw) as ExportBundle;
|
||
if (bundle.dataset) {
|
||
this.dataset = bundle.dataset;
|
||
} else if (bundle.customDiff) {
|
||
this.dataset = this.applyDiff(deepClone(baseline!), bundle.customDiff);
|
||
} else {
|
||
this.dataset = deepClone(baseline!);
|
||
}
|
||
this.presets = bundle.presets || [];
|
||
// 恢复扩展预设数据
|
||
this.extendedPresets = bundle.extendedPresets || [];
|
||
this.presetFolders = bundle.presetFolders || [];
|
||
if (bundle.presetManagement) {
|
||
this.presetManagement = bundle.presetManagement;
|
||
}
|
||
// 恢复编辑器内容与语言
|
||
if (typeof bundle.promptText === 'string') {
|
||
this.promptText = bundle.promptText;
|
||
}
|
||
if (bundle.selectedLang) {
|
||
this.selectedLang = bundle.selectedLang as LangCode;
|
||
}
|
||
} catch {
|
||
this.dataset = deepClone(baseline!);
|
||
}
|
||
} else {
|
||
this.dataset = deepClone(baseline!);
|
||
this.promptText = '1girl, solo, long hair, blue eyes, smile, looking_at_viewer, upper_body, outdoors, sunset';
|
||
}
|
||
// 若无恢复语言，则默认使用 zh_CN
|
||
if (!this.selectedLang) {
|
||
this.selectedLang = 'zh_CN' as LangCode;
|
||
}
|
||
// 初始化扩展预设管理
|
||
this.initializeExtendedPresets();
|
||
// 自动迁移旧预设到新系统
|
||
this.migrateOldPresets();
|
||
this.autoPersist();
|
||
},
|
||
autoPersist() {
|
||
// 订阅状态变化并延迟保存（不写入 store，避免递归）
|
||
this.$subscribe(() => {
|
||
if (saveTimer) window.clearTimeout(saveTimer);
|
||
saveTimer = window.setTimeout(() => {
|
||
this.save();
|
||
}, 400);
|
||
}, { detached: true });
|
||
},
|
||
save() {
|
||
if (!this.dataset) return;
|
||
const bundle: ExportBundle = {
|
||
version: 1,
|
||
savedAt: new Date().toISOString(),
|
||
dataset: deepClone(this.dataset),
|
||
presets: deepClone(this.presets),
|
||
// 扩展预设数据
|
||
extendedPresets: deepClone(this.extendedPresets),
|
||
presetFolders: deepClone(this.presetFolders),
|
||
presetManagement: deepClone(this.presetManagement),
|
||
promptText: this.promptText,
|
||
selectedLang: this.selectedLang,
|
||
};
|
||
localStorage.setItem(LS_KEY, JSON.stringify(bundle));
|
||
},
|
||
resetToDefault() {
|
||
this.importFromBundle(null);
|
||
},
|
||
async importFromBundle(bundle: ExportBundle | null) {
|
||
if (!bundle) {
|
||
if (!baseline) baseline = await loadInitialDataset();
|
||
this.dataset = deepClone(baseline!);
|
||
// 重置时不清空预设数据，只重置词库
|
||
} else {
|
||
// 词库导入：只处理词库相关数据，不影响预设
|
||
if (bundle.dataset) {
|
||
this.dataset = bundle.dataset;
|
||
} else if (bundle.customDiff) {
|
||
if (!baseline) baseline = await loadInitialDataset();
|
||
this.dataset = this.applyDiff(deepClone(baseline!), bundle.customDiff);
|
||
}
|
||
|
||
// 兼容旧版本：如果导入的是包含预设的旧格式，提示用户使用预设导入功能
|
||
if (bundle.presets || bundle.extendedPresets || bundle.presetFolders) {
|
||
console.warn('检测到预设数据，请使用预设管理页面的导入功能来导入预设数据');
|
||
}
|
||
}
|
||
this.selectedCategoryIndex = 0;
|
||
this.selectedGroupIndex = 0;
|
||
this.save();
|
||
},
|
||
exportToJson(): string {
|
||
// 词库导出：仅包含自定义差异（不包含公共词库和预设数据）
|
||
const diff = this.buildDiff(baseline!, this.dataset!);
|
||
const bundle: ExportBundle = {
|
||
version: 1,
|
||
savedAt: new Date().toISOString(),
|
||
customDiff: diff,
|
||
// 词库导出不包含预设数据
|
||
};
|
||
return JSON.stringify(bundle, null, 2);
|
||
},
|
||
|
||
// 预设导出：仅导出预设相关数据
|
||
exportPresetsToJson(): string {
|
||
const bundle = {
|
||
version: 1,
|
||
type: 'presets',
|
||
savedAt: new Date().toISOString(),
|
||
extendedPresets: deepClone(this.extendedPresets),
|
||
presetFolders: deepClone(this.presetFolders),
|
||
presetManagement: deepClone(this.presetManagement),
|
||
// 保留旧预设以兼容
|
||
presets: deepClone(this.presets),
|
||
};
|
||
return JSON.stringify(bundle, null, 2);
|
||
},
|
||
setLanguage(lang: LangCode) {
|
||
this.selectedLang = lang;
|
||
},
|
||
selectCategory(idx: number) {
|
||
this.selectedCategoryIndex = idx;
|
||
this.selectedGroupIndex = 0;
|
||
},
|
||
selectGroup(idx: number) {
|
||
this.selectedGroupIndex = idx;
|
||
},
|
||
setSearch(q: string) {
|
||
this.searchQuery = q;
|
||
},
|
||
addTag(groupId: string, key = 'new_tag') {
|
||
const grp = this.findGroupById(groupId);
|
||
if (!grp) return;
|
||
// 新增提示词插入到列表顶部，便于用户立即编辑
|
||
grp.tags.unshift({ key, translation: { en: key, [this.selectedLang]: key } });
|
||
},
|
||
removeTag(groupId: string, key: string) {
|
||
const grp = this.findGroupById(groupId);
|
||
if (!grp) return;
|
||
grp.tags = grp.tags.filter((t) => t.key !== key);
|
||
},
|
||
updateTagKey(groupId: string, oldKey: string, newKey: string) {
|
||
const grp = this.findGroupById(groupId);
|
||
if (!grp) return;
|
||
const tag = grp.tags.find((t) => t.key === oldKey);
|
||
if (!tag) return;
|
||
tag.key = newKey;
|
||
if (!tag.translation) tag.translation = {};
|
||
tag.translation.en = newKey;
|
||
},
|
||
setTranslation(groupId: string, key: string, lang: LangCode, val: string) {
|
||
const grp = this.findGroupById(groupId);
|
||
if (!grp) return;
|
||
const tag = grp.tags.find((t) => t.key === key);
|
||
if (!tag) return;
|
||
if (!tag.translation) tag.translation = {};
|
||
tag.translation[lang] = val;
|
||
},
|
||
toggleHidden(groupId: string, key: string) {
|
||
const grp = this.findGroupById(groupId);
|
||
if (!grp) return;
|
||
const tag = grp.tags.find((t) => t.key === key);
|
||
if (!tag) return;
|
||
tag.hidden = !tag.hidden;
|
||
},
|
||
reorderTags(groupId: string, fromIndex: number, toIndex: number) {
|
||
const grp = this.findGroupById(groupId);
|
||
if (!grp) return;
|
||
const list = grp.tags;
|
||
if (fromIndex < 0 || toIndex < 0 || fromIndex >= list.length || toIndex >= list.length) return;
|
||
const [item] = list.splice(fromIndex, 1);
|
||
if (item) list.splice(toIndex, 0, item);
|
||
},
|
||
// —— 编辑器核心：基于左侧文本的 token 操作 ——
|
||
setPromptText(text: string) {
|
||
this.promptText = normalizePrompt(text);
|
||
},
|
||
setPromptTextRaw(text: string) {
|
||
// 原始赋值，不做格式化，保留光标与撤回体验
|
||
this.promptText = text;
|
||
},
|
||
replaceChineseComma() {
|
||
this.promptText = this.promptText.replace(/，/g, ',');
|
||
},
|
||
formatPrompt() {
|
||
this.promptText = normalizePrompt(this.promptText);
|
||
},
|
||
// 切换下划线和空格
|
||
toggleUnderscoreSpace() {
|
||
const tokens = splitTokens(this.promptText);
|
||
const newTokens = tokens.map(token => {
|
||
// 解析包裹层数和核心内容
|
||
const { core, wrappers } = this.parseTokenWrappers(token);
|
||
|
||
// 切换下划线和空格
|
||
let newCore;
|
||
if (core.includes('_')) {
|
||
newCore = core.replace(/_/g, ' ');
|
||
} else if (core.includes(' ')) {
|
||
newCore = core.replace(/ /g, '_');
|
||
} else {
|
||
newCore = core;
|
||
}
|
||
|
||
// 重新包装
|
||
return this.wrapToken(newCore, wrappers);
|
||
});
|
||
this.promptText = newTokens.join(', ');
|
||
},
|
||
// 为单个token添加包裹层
|
||
addWrapperToToken(index: number, wrapperType: string = '{}') {
|
||
const tokens = splitTokens(this.promptText);
|
||
if (index < 0 || index >= tokens.length) return;
|
||
|
||
const token = tokens[index];
|
||
if (!token) return;
|
||
const { core, wrappers } = this.parseTokenWrappers(token);
|
||
const newWrappers = [...wrappers, wrapperType];
|
||
tokens[index] = this.wrapToken(core, newWrappers);
|
||
|
||
this.promptText = tokens.join(', ');
|
||
},
|
||
// 为单个token移除包裹层
|
||
removeWrapperFromToken(index: number) {
|
||
const tokens = splitTokens(this.promptText);
|
||
if (index < 0 || index >= tokens.length) return;
|
||
|
||
const token = tokens[index];
|
||
if (!token) return;
|
||
const { core, wrappers } = this.parseTokenWrappers(token);
|
||
if (wrappers.length > 0) {
|
||
const newWrappers = wrappers.slice(0, -1);
|
||
tokens[index] = this.wrapToken(core, newWrappers);
|
||
this.promptText = tokens.join(', ');
|
||
}
|
||
},
|
||
// 获取token的包裹信息（用于显示）
|
||
getTokenWrapperInfo(token: string): { core: string; wrappers: string[]; wrapperCount: number } {
|
||
const { core, wrappers } = this.parseTokenWrappers(token);
|
||
return { core, wrappers, wrapperCount: wrappers.length };
|
||
},
|
||
// 解析token的包裹层和核心内容
|
||
parseTokenWrappers(token: string): { core: string; wrappers: string[] } {
|
||
const wrapperPairs = [
|
||
['{}', '{', '}'],
|
||
['()', '(', ')'],
|
||
['[]', '[', ']'],
|
||
['<>', '<', '>']
|
||
];
|
||
|
||
let current = token.trim();
|
||
const wrappers: string[] = [];
|
||
|
||
// 从外到内解析包裹层
|
||
while (current.length >= 2) {
|
||
let found = false;
|
||
for (const [type, start, end] of wrapperPairs) {
|
||
if (start && end && current.startsWith(start) && current.endsWith(end)) {
|
||
if (type) wrappers.push(type);
|
||
current = current.slice(start.length, -end.length);
|
||
found = true;
|
||
break;
|
||
}
|
||
}
|
||
if (!found) break;
|
||
}
|
||
|
||
return { core: current, wrappers };
|
||
},
|
||
// 用包裹层包装token
|
||
wrapToken(core: string, wrappers: string[]): string {
|
||
let result = core;
|
||
|
||
// 从内到外添加包裹层
|
||
for (let i = wrappers.length - 1; i >= 0; i--) {
|
||
const wrapper = wrappers[i];
|
||
switch (wrapper) {
|
||
case '{}':
|
||
result = `{${result}}`;
|
||
break;
|
||
case '()':
|
||
result = `(${result})`;
|
||
break;
|
||
case '[]':
|
||
result = `[${result}]`;
|
||
break;
|
||
case '<>':
|
||
result = `<${result}>`;
|
||
break;
|
||
}
|
||
}
|
||
|
||
return result;
|
||
},
|
||
updateToken(index: number, newToken: string) {
|
||
const tokens = splitTokens(this.promptText);
|
||
if (index < 0 || index >= tokens.length) return;
|
||
tokens[index] = normalizeToken(newToken);
|
||
this.promptText = tokens.join(', ');
|
||
},
|
||
reorderTokens(fromIndex: number, toIndex: number) {
|
||
const tokens = splitTokens(this.promptText);
|
||
if (fromIndex < 0 || toIndex < 0 || fromIndex >= tokens.length || toIndex >= tokens.length) return;
|
||
const [item] = tokens.splice(fromIndex, 1);
|
||
tokens.splice(toIndex, 0, item!);
|
||
this.promptText = tokens.join(', ');
|
||
},
|
||
removeToken(index: number) {
|
||
const tokens = splitTokens(this.promptText);
|
||
if (index < 0 || index >= tokens.length) return;
|
||
tokens.splice(index, 1);
|
||
this.promptText = tokens.join(', ');
|
||
},
|
||
addTokenAfter(index: number, token: string) {
|
||
const tokens = splitTokens(this.promptText);
|
||
tokens.splice(index + 1, 0, normalizeToken(token));
|
||
this.promptText = tokens.join(', ');
|
||
},
|
||
getTagByKey(key: string): PromptTag | null {
|
||
const target = normalizeKeyForMatch(key);
|
||
for (const cat of this.dataset?.categories || []) {
|
||
for (const g of cat.groups) {
|
||
for (const t of g.tags) {
|
||
if (t.key === key) return t; // 精确匹配优先
|
||
if (normalizeKeyForMatch(t.key) === target) return t; // 下划线/空格归一化匹配
|
||
}
|
||
}
|
||
}
|
||
return null;
|
||
},
|
||
getTranslation(key: string, lang: LangCode): string | null {
|
||
// 兼容包裹层：如 {aaa}、(aaa) 等
|
||
const { core, wrappers } = this.parseTokenWrappers(key);
|
||
const tag = this.getTagByKey(core);
|
||
if (!tag) return null;
|
||
const translatedCore = tag.translation?.[lang] ?? tag.key;
|
||
// 保持原有包裹层结构，返回被翻译后的核心
|
||
return this.wrapToken(translatedCore, wrappers);
|
||
},
|
||
getSuggestions(prefix: string, limit = 8): string[] {
|
||
const list: string[] = [];
|
||
const seen = new Set<string>();
|
||
const p = prefix.trim().toLowerCase();
|
||
const pNorm = p.replace(/_/g, ' ');
|
||
if (!p) return [];
|
||
for (const cat of this.dataset?.categories || []) {
|
||
for (const g of cat.groups) {
|
||
for (const t of g.tags) {
|
||
const k = t.key;
|
||
if (seen.has(k)) continue;
|
||
const kLower = k.toLowerCase();
|
||
const kNorm = kLower.replace(/_/g, ' ');
|
||
if (kLower.includes(p) || kNorm.includes(pNorm)) {
|
||
list.push(k);
|
||
seen.add(k);
|
||
if (list.length >= limit) return list;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return list;
|
||
},
|
||
addMapping(key: string, lang: LangCode, val: string) {
|
||
// 若 key 已存在则更新翻译；否则在自定义分组增加映射
|
||
const exist = this.getTagByKey(key);
|
||
if (exist) {
|
||
if (!exist.translation) exist.translation = {};
|
||
exist.translation[lang] = val;
|
||
return;
|
||
}
|
||
const grp = this.ensureCustomGroup();
|
||
grp.tags.push({ key, translation: { en: key, [lang]: val } });
|
||
},
|
||
ensureCustomGroup(): PromptGroup {
|
||
const catName = 'Custom';
|
||
let cat = this.dataset?.categories.find((c) => c.name === catName);
|
||
if (!cat) {
|
||
cat = { id: `cat_${Math.random().toString(36).slice(2, 9)}`, name: catName, groups: [] };
|
||
this.dataset?.categories.push(cat);
|
||
}
|
||
let grp = cat.groups.find((g) => g.name === 'User Mapping');
|
||
if (!grp) {
|
||
grp = { id: `grp_${Math.random().toString(36).slice(2, 9)}`, name: 'User Mapping', color: '#6366f1', tags: [] };
|
||
cat.groups.push(grp);
|
||
}
|
||
return grp;
|
||
},
|
||
savePreset(name: string) {
|
||
const now = new Date().toISOString();
|
||
const exist = this.presets.find((p) => p.name === name);
|
||
if (exist) {
|
||
exist.text = this.promptText;
|
||
exist.updatedAt = now;
|
||
} else {
|
||
this.presets.push({ name, text: this.promptText, updatedAt: now });
|
||
}
|
||
this.save();
|
||
},
|
||
loadPreset(name: string) {
|
||
const p = this.presets.find((x) => x.name === name);
|
||
if (!p) return;
|
||
this.promptText = p.text;
|
||
},
|
||
deletePreset(name: string) {
|
||
this.presets = this.presets.filter((p) => p.name !== name);
|
||
this.save();
|
||
},
|
||
renamePreset(oldName: string, newName: string) {
|
||
const target = this.presets.find((p) => p.name === oldName);
|
||
if (!target) return;
|
||
const conflict = this.presets.find((p) => p.name === newName);
|
||
const now = new Date().toISOString();
|
||
if (conflict && conflict !== target) {
|
||
// 合并到冲突项：用新名覆盖旧名文本
|
||
conflict.text = target.text;
|
||
conflict.updatedAt = now;
|
||
this.deletePreset(oldName);
|
||
} else {
|
||
target.name = newName;
|
||
target.updatedAt = now;
|
||
}
|
||
this.save();
|
||
},
|
||
findGroupById(id: string): PromptGroup | null {
|
||
for (const cat of this.dataset?.categories || []) {
|
||
const grp = cat.groups.find((g) => g.id === id);
|
||
if (grp) return grp;
|
||
}
|
||
return null;
|
||
},
|
||
// 工具方法：构建差异与应用差异
|
||
buildDiff(base: PromptDataset, cur: PromptDataset): CustomDiff {
|
||
const categories: CustomDiff['categories'] = [];
|
||
const baseCatMap = new Map(base.categories.map((c) => [c.name, c]));
|
||
const curCatMap = new Map(cur.categories.map((c) => [c.name, c]));
|
||
|
||
for (const [name, curCat] of curCatMap.entries()) {
|
||
const baseCat = baseCatMap.get(name);
|
||
const catDiff: CustomDiff['categories'][number] = { name };
|
||
if (!baseCat) {
|
||
catDiff.addedGroups = curCat.groups.map((g) => deepClone(g));
|
||
} else {
|
||
const baseGrpMap = new Map(baseCat.groups.map((g) => [g.name, g]));
|
||
const curGrpMap = new Map(curCat.groups.map((g) => [g.name, g]));
|
||
const groupsDiff: NonNullable<typeof catDiff.groups> = [];
|
||
|
||
for (const [gname, curGrp] of curGrpMap.entries()) {
|
||
const baseGrp = baseGrpMap.get(gname);
|
||
if (!baseGrp) {
|
||
if (!catDiff.addedGroups) catDiff.addedGroups = [];
|
||
catDiff.addedGroups.push(deepClone(curGrp));
|
||
continue;
|
||
}
|
||
const updated: { name: string; color?: string; added?: PromptTag[]; removed?: string[]; updated?: Array<{ key: string; translation?: Partial<Record<LangCode, string>>; hidden?: boolean }>; order?: string[] } = { name: gname } as any;
|
||
if ((curGrp.color || '') !== (baseGrp.color || '')) updated.color = curGrp.color;
|
||
const baseTagMap = new Map(baseGrp.tags.map((t) => [t.key, t]));
|
||
const curTagMap = new Map(curGrp.tags.map((t) => [t.key, t]));
|
||
|
||
const addList: PromptTag[] = [];
|
||
const updList: Array<{ key: string; translation?: Partial<Record<LangCode, string>>; hidden?: boolean }> = [];
|
||
for (const [key, curTag] of curTagMap.entries()) {
|
||
const baseTag = baseTagMap.get(key);
|
||
if (!baseTag) {
|
||
addList.push(deepClone(curTag));
|
||
} else {
|
||
let changed = false;
|
||
const change: { key: string; translation?: Partial<Record<LangCode, string>>; hidden?: boolean } = { key };
|
||
for (const l of ['en', 'zh_CN', 'es_ES'] as LangCode[]) {
|
||
const a = baseTag.translation?.[l] ?? '';
|
||
const b = curTag.translation?.[l] ?? '';
|
||
if (a !== b) {
|
||
if (!change.translation) change.translation = {};
|
||
change.translation[l] = b;
|
||
changed = true;
|
||
}
|
||
}
|
||
const aHidden = !!baseTag.hidden;
|
||
const bHidden = !!curTag.hidden;
|
||
if (aHidden !== bHidden) { change.hidden = bHidden; changed = true; }
|
||
if (changed) updList.push(change);
|
||
}
|
||
}
|
||
const remList: string[] = [];
|
||
for (const [key] of baseTagMap.entries()) {
|
||
if (!curTagMap.has(key)) remList.push(key);
|
||
}
|
||
const baseOrder = baseGrp.tags.map((t) => t.key);
|
||
const curOrder = curGrp.tags.map((t) => t.key);
|
||
const orderChanged = baseOrder.length !== curOrder.length || baseOrder.some((k, i) => k !== curOrder[i]);
|
||
|
||
if (updated.color || addList.length || remList.length || updList.length || orderChanged) {
|
||
if (updated.color) updated.color = updated.color;
|
||
if (addList.length) updated.added = addList;
|
||
if (remList.length) updated.removed = remList;
|
||
if (updList.length) updated.updated = updList;
|
||
if (orderChanged) updated.order = curOrder;
|
||
groupsDiff.push(updated as any);
|
||
}
|
||
}
|
||
const removedGroups = baseCat.groups.filter((bg) => !curGrpMap.has(bg.name)).map((g) => g.name);
|
||
if (removedGroups.length) catDiff.removedGroups = removedGroups;
|
||
if (groupsDiff.length) catDiff.groups = groupsDiff;
|
||
}
|
||
if (catDiff.addedGroups?.length || catDiff.removedGroups?.length || catDiff.groups?.length) {
|
||
categories.push(catDiff);
|
||
}
|
||
}
|
||
for (const baseCat of base.categories) {
|
||
if (!curCatMap.has(baseCat.name)) {
|
||
categories.push({ name: baseCat.name, removedGroups: baseCat.groups.map((g) => g.name) });
|
||
}
|
||
}
|
||
return { categories };
|
||
},
|
||
applyDiff(target: PromptDataset, diff: CustomDiff): PromptDataset {
|
||
const catMap = new Map(target.categories.map((c) => [c.name, c]));
|
||
for (const c of diff.categories || []) {
|
||
let cat = catMap.get(c.name);
|
||
if (!cat) {
|
||
cat = { id: `cat_${Math.random().toString(36).slice(2, 9)}`, name: c.name, groups: [] };
|
||
target.categories.push(cat);
|
||
catMap.set(c.name, cat);
|
||
}
|
||
const grpMap = new Map(cat.groups.map((g) => [g.name, g]));
|
||
for (const g of c.addedGroups || []) {
|
||
const copy = deepClone(g);
|
||
// 保持现有结构：如果没有 id，生成一个
|
||
(copy as PromptGroup).id = `grp_${Math.random().toString(36).slice(2, 9)}`;
|
||
(copy as PromptGroup).id = `grp_${Math.random().toString(36).slice(2, 9)}`;
|
||
cat.groups.push(copy as PromptGroup);
|
||
grpMap.set(copy.name, copy as PromptGroup);
|
||
}
|
||
for (const gname of c.removedGroups || []) {
|
||
cat.groups = cat.groups.filter((g) => g.name !== gname);
|
||
grpMap.delete(gname);
|
||
}
|
||
for (const gdiff of c.groups || []) {
|
||
let grp = grpMap.get(gdiff.name);
|
||
if (!grp) {
|
||
grp = { id: `grp_${Math.random().toString(36).slice(2, 9)}`, name: gdiff.name, color: gdiff.color, tags: [] };
|
||
cat.groups.push(grp);
|
||
grpMap.set(grp.name, grp);
|
||
}
|
||
if (gdiff.color !== undefined) grp.color = gdiff.color;
|
||
const tagMap = new Map(grp.tags.map((t) => [t.key, t]));
|
||
for (const t of gdiff.added || []) {
|
||
const copy = deepClone(t);
|
||
grp.tags.push(copy);
|
||
tagMap.set(copy.key, copy);
|
||
}
|
||
for (const key of gdiff.removed || []) {
|
||
grp.tags = grp.tags.filter((t) => t.key !== key);
|
||
tagMap.delete(key);
|
||
}
|
||
for (const u of gdiff.updated || []) {
|
||
const tag = tagMap.get(u.key);
|
||
if (!tag) continue;
|
||
if (u.translation) tag.translation = { ...(tag.translation || {}), ...u.translation };
|
||
if (u.hidden !== undefined) tag.hidden = u.hidden;
|
||
}
|
||
if (gdiff.order && gdiff.order.length) {
|
||
const keyToTag = new Map(grp.tags.map((t) => [t.key, t]));
|
||
const reordered: PromptTag[] = [];
|
||
for (const key of gdiff.order) {
|
||
const tag = keyToTag.get(key);
|
||
if (tag) reordered.push(tag);
|
||
}
|
||
// 保留未列出的条目
|
||
for (const t of grp.tags) {
|
||
if (!gdiff.order.includes(t.key)) reordered.push(t);
|
||
}
|
||
grp.tags = reordered;
|
||
}
|
||
}
|
||
}
|
||
return target;
|
||
},
|
||
|
||
// 扩展预设管理方法
|
||
initializeExtendedPresets() {
|
||
// 如果没有扩展预设数据，初始化默认结构
|
||
if (!this.extendedPresets) {
|
||
this.extendedPresets = [];
|
||
}
|
||
if (!this.presetFolders) {
|
||
this.presetFolders = [];
|
||
}
|
||
if (!this.presetManagement) {
|
||
this.presetManagement = {
|
||
folders: [],
|
||
presets: [],
|
||
settings: {
|
||
autoBackup: true,
|
||
maxPresets: 1000
|
||
}
|
||
};
|
||
}
|
||
|
||
// 确保有默认文件夹
|
||
if (this.presetFolders.length === 0) {
|
||
const defaultFolder = this.createPresetFolder({
|
||
name: '默认文件夹',
|
||
description: '系统默认预设文件夹',
|
||
color: '#6366f1'
|
||
});
|
||
|
||
// 设置为默认文件夹
|
||
if (this.presetManagement.settings) {
|
||
this.presetManagement.settings.defaultFolder = defaultFolder.id;
|
||
}
|
||
}
|
||
},
|
||
|
||
createExtendedPreset(data: Omit<ExtendedPreset, 'id' | 'createdAt' | 'updatedAt'>) {
|
||
const now = new Date().toISOString();
|
||
const preset: ExtendedPreset = {
|
||
id: `preset_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`,
|
||
createdAt: now,
|
||
updatedAt: now,
|
||
...data
|
||
};
|
||
|
||
this.extendedPresets.push(preset);
|
||
this.save();
|
||
return preset;
|
||
},
|
||
|
||
updateExtendedPreset(id: string, data: Partial<Omit<ExtendedPreset, 'id' | 'createdAt'>>) {
|
||
const preset = this.extendedPresets.find(p => p.id === id);
|
||
if (!preset) return false;
|
||
|
||
Object.assign(preset, data, { updatedAt: new Date().toISOString() });
|
||
this.save();
|
||
return true;
|
||
},
|
||
|
||
deleteExtendedPreset(id: string) {
|
||
const index = this.extendedPresets.findIndex(p => p.id === id);
|
||
if (index === -1) return false;
|
||
|
||
this.extendedPresets.splice(index, 1);
|
||
this.save();
|
||
return true;
|
||
},
|
||
|
||
createPresetFolder(data: Omit<PresetFolder, 'id' | 'createdAt' | 'updatedAt'>) {
|
||
const now = new Date().toISOString();
|
||
const folder: PresetFolder = {
|
||
id: `folder_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`,
|
||
createdAt: now,
|
||
updatedAt: now,
|
||
...data
|
||
};
|
||
|
||
this.presetFolders.push(folder);
|
||
this.save();
|
||
return folder;
|
||
},
|
||
|
||
updatePresetFolder(id: string, data: Partial<Omit<PresetFolder, 'id' | 'createdAt'>>) {
|
||
const folder = this.presetFolders.find(f => f.id === id);
|
||
if (!folder) return false;
|
||
|
||
Object.assign(folder, data, { updatedAt: new Date().toISOString() });
|
||
this.save();
|
||
return true;
|
||
},
|
||
|
||
deletePresetFolder(id: string) {
|
||
const index = this.presetFolders.findIndex(f => f.id === id);
|
||
if (index === -1) return false;
|
||
|
||
// 将该文件夹下的预设移动到未分类
|
||
this.extendedPresets.forEach(preset => {
|
||
if (preset.folderId === id) {
|
||
preset.folderId = undefined;
|
||
preset.updatedAt = new Date().toISOString();
|
||
}
|
||
});
|
||
|
||
// 删除子文件夹或将其移动到父级
|
||
const folder = this.presetFolders[index];
|
||
if (folder) {
|
||
this.presetFolders.forEach(f => {
|
||
if (f.parentId === id) {
|
||
f.parentId = folder.parentId;
|
||
f.updatedAt = new Date().toISOString();
|
||
}
|
||
});
|
||
}
|
||
|
||
this.presetFolders.splice(index, 1);
|
||
this.save();
|
||
return true;
|
||
},
|
||
|
||
importExtendedPresets(data: { folders?: PresetFolder[]; presets?: ExtendedPreset[] }) {
|
||
if (data.folders) {
|
||
// 合并文件夹，避免ID冲突
|
||
data.folders.forEach(folder => {
|
||
const existingFolder = this.presetFolders.find(f => f.name === folder.name);
|
||
if (existingFolder) {
|
||
// 更新现有文件夹
|
||
Object.assign(existingFolder, folder, {
|
||
id: existingFolder.id,
|
||
updatedAt: new Date().toISOString()
|
||
});
|
||
} else {
|
||
// 创建新文件夹，重新生成ID
|
||
const newFolder = {
|
||
...folder,
|
||
id: `folder_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`,
|
||
createdAt: new Date().toISOString(),
|
||
updatedAt: new Date().toISOString()
|
||
};
|
||
this.presetFolders.push(newFolder);
|
||
}
|
||
});
|
||
}
|
||
|
||
if (data.presets) {
|
||
// 合并预设，避免ID冲突
|
||
data.presets.forEach(preset => {
|
||
const existingPreset = this.extendedPresets.find(p => p.name === preset.name && p.type === preset.type);
|
||
if (existingPreset) {
|
||
// 更新现有预设
|
||
Object.assign(existingPreset, preset, {
|
||
id: existingPreset.id,
|
||
updatedAt: new Date().toISOString()
|
||
});
|
||
} else {
|
||
// 创建新预设，重新生成ID
|
||
const newPreset = {
|
||
...preset,
|
||
id: `preset_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`,
|
||
createdAt: new Date().toISOString(),
|
||
updatedAt: new Date().toISOString()
|
||
};
|
||
this.extendedPresets.push(newPreset);
|
||
}
|
||
});
|
||
}
|
||
|
||
this.save();
|
||
},
|
||
|
||
// 预设导入：专门处理预设导入文件
|
||
importPresetsFromJson(jsonData: string): boolean {
|
||
try {
|
||
const data = JSON.parse(jsonData);
|
||
|
||
// 仅处理预设相关的导入文件
|
||
if (!(data.type === 'presets' || data.extendedPresets || data.presetFolders || data.presets)) {
|
||
return false;
|
||
}
|
||
|
||
// 1) 构建旧ID到新ID的映射，按名称合并已存在的文件夹
|
||
const idMap = new Map<string, string>();
|
||
const existingByName = new Map((this.presetFolders || []).map((f) => [f.name, f]));
|
||
|
||
const foldersToCreate: any[] = [];
|
||
const incomingFolders: any[] = Array.isArray(data.presetFolders) ? data.presetFolders : [];
|
||
|
||
// 先确定每个旧ID对应的新ID（复用同名文件夹，否则生成新ID）
|
||
for (const folder of incomingFolders) {
|
||
const sameName = existingByName.get(folder.name);
|
||
if (sameName) {
|
||
idMap.set(folder.id, sameName.id);
|
||
// 更新同名文件夹的基础信息（不改ID）
|
||
Object.assign(sameName, {
|
||
description: folder.description ?? sameName.description,
|
||
color: folder.color ?? sameName.color,
|
||
updatedAt: new Date().toISOString(),
|
||
});
|
||
} else {
|
||
const newId = `folder_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
|
||
idMap.set(folder.id, newId);
|
||
foldersToCreate.push({ ...folder, id: newId });
|
||
}
|
||
}
|
||
|
||
// 创建不存在的文件夹，修正其父子关系（父ID按映射转换）
|
||
for (const folder of foldersToCreate) {
|
||
const created = {
|
||
id: folder.id,
|
||
name: folder.name,
|
||
description: folder.description ?? undefined,
|
||
color: folder.color ?? '#6366f1',
|
||
parentId: folder.parentId ? idMap.get(folder.parentId) : undefined,
|
||
createdAt: folder.createdAt || new Date().toISOString(),
|
||
updatedAt: new Date().toISOString(),
|
||
} as PresetFolder;
|
||
this.presetFolders.push(created);
|
||
}
|
||
|
||
// 2) 导入扩展预设，修正其 folderId 指向到新ID
|
||
const incomingPresets: any[] = Array.isArray(data.extendedPresets) ? data.extendedPresets : [];
|
||
for (const preset of incomingPresets) {
|
||
// 如果已存在同名同类型，则更新；否则创建新预设
|
||
const existing = (this.extendedPresets || []).find((p) => p.name === preset.name && p.type === preset.type);
|
||
const mappedFolderId = preset.folderId ? idMap.get(preset.folderId) : undefined;
|
||
|
||
if (existing) {
|
||
Object.assign(existing, {
|
||
content: preset.content,
|
||
description: preset.description ?? existing.description,
|
||
tags: Array.isArray(preset.tags) ? preset.tags : existing.tags,
|
||
folderId: mappedFolderId ?? existing.folderId,
|
||
updatedAt: new Date().toISOString(),
|
||
});
|
||
} else {
|
||
this.extendedPresets.push({
|
||
id: `preset_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`,
|
||
name: preset.name,
|
||
type: preset.type,
|
||
content: preset.content,
|
||
description: preset.description ?? undefined,
|
||
tags: Array.isArray(preset.tags) ? preset.tags : undefined,
|
||
folderId: mappedFolderId,
|
||
createdAt: preset.createdAt || new Date().toISOString(),
|
||
updatedAt: new Date().toISOString(),
|
||
} as ExtendedPreset);
|
||
}
|
||
}
|
||
|
||
// 3) 合并预设管理配置（不覆盖现有设置），无需变更 defaultFolder
|
||
if (data.presetManagement) {
|
||
this.presetManagement = {
|
||
...this.presetManagement,
|
||
folders: [...(this.presetManagement?.folders || []), ...(data.presetManagement.folders || [])],
|
||
presets: [...(this.presetManagement?.presets || []), ...(data.presetManagement.presets || [])],
|
||
settings: { ...(this.presetManagement?.settings || {}) },
|
||
};
|
||
}
|
||
|
||
// 4) 兼容旧预设格式（旧格式只含 presets: [{ name, text }...]）
|
||
if (Array.isArray(data.presets)) {
|
||
for (const oldPreset of data.presets) {
|
||
this.extendedPresets.push({
|
||
id: `preset_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`,
|
||
name: oldPreset.name,
|
||
type: 'positive' as PresetType,
|
||
content: oldPreset.text,
|
||
description: '从旧格式导入',
|
||
createdAt: oldPreset.updatedAt || new Date().toISOString(),
|
||
updatedAt: new Date().toISOString(),
|
||
} as ExtendedPreset);
|
||
}
|
||
}
|
||
|
||
this.save();
|
||
return true;
|
||
} catch (error) {
|
||
console.error('预设导入失败:', error);
|
||
return false;
|
||
}
|
||
},
|
||
|
||
// 兼容性：从旧预设迁移到新预设系统
|
||
migrateOldPresets() {
|
||
if (this.presets.length === 0) return; // 没有旧预设需要迁移
|
||
|
||
console.log(`开始迁移 ${this.presets.length} 个旧预设到新系统...`);
|
||
|
||
let migratedCount = 0;
|
||
const defaultFolder = this.presetManagement?.settings?.defaultFolder;
|
||
|
||
this.presets.forEach(oldPreset => {
|
||
const existingExtended = this.extendedPresets.find(p =>
|
||
p.name === oldPreset.name && p.type === 'positive'
|
||
);
|
||
|
||
if (!existingExtended) {
|
||
// 创建新的扩展预设，但不触发保存（避免递归）
|
||
const now = new Date().toISOString();
|
||
const preset: ExtendedPreset = {
|
||
id: `migrated_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`,
|
||
name: oldPreset.name,
|
||
type: 'positive',
|
||
content: oldPreset.text,
|
||
description: '从旧版快速预设自动迁移',
|
||
folderId: defaultFolder,
|
||
createdAt: oldPreset.updatedAt,
|
||
updatedAt: oldPreset.updatedAt
|
||
};
|
||
|
||
this.extendedPresets.push(preset);
|
||
migratedCount++;
|
||
}
|
||
});
|
||
|
||
if (migratedCount > 0) {
|
||
console.log(`成功迁移 ${migratedCount} 个预设到新系统`);
|
||
// 清空旧预设数组，完成迁移
|
||
this.presets = [];
|
||
console.log('旧预设已清空，迁移完成');
|
||
}
|
||
},
|
||
|
||
// 检查并处理版本兼容性
|
||
ensureCompatibility(bundle: ExportBundle) {
|
||
// 如果是旧版本的导出文件，确保新字段存在
|
||
if (!bundle.extendedPresets && bundle.presets && bundle.presets.length > 0) {
|
||
// 自动迁移旧预设到新系统
|
||
bundle.extendedPresets = bundle.presets.map(preset => ({
|
||
id: `migrated_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`,
|
||
name: preset.name,
|
||
type: 'positive' as PresetType,
|
||
content: preset.text,
|
||
description: '从旧版本自动迁移',
|
||
createdAt: preset.updatedAt,
|
||
updatedAt: preset.updatedAt
|
||
}));
|
||
}
|
||
|
||
if (!bundle.presetFolders) {
|
||
bundle.presetFolders = [];
|
||
}
|
||
|
||
if (!bundle.presetManagement) {
|
||
bundle.presetManagement = {
|
||
folders: [],
|
||
presets: [],
|
||
settings: {
|
||
autoBackup: true,
|
||
maxPresets: 1000
|
||
}
|
||
};
|
||
}
|
||
|
||
return bundle;
|
||
},
|
||
},
|
||
});
|
||
// —— 工具方法 ——
|
||
function splitTokens(text: string): string[] {
|
||
return text
|
||
.split(/[，,]/)
|
||
.map((s) => s.trim())
|
||
.filter((s) => s.length > 0);
|
||
}
|
||
function normalizeToken(t: string): string {
|
||
return t.trim();
|
||
}
|
||
function normalizePrompt(text: string): string {
|
||
return splitTokens(text).join(', ');
|
||
}
|
||
|
||
// 归一化用于匹配的 key：统一大小写与下划线/空格
|
||
function normalizeKeyForMatch(s: string): string {
|
||
return s.trim().toLowerCase().replace(/_/g, ' ');
|
||
} |