${html}
`
// 这里在函数内执行js是为了在同一页面未刷新下可多次执行该js不执行，也就是对变量/函数等进行隔离
+``
let my_search_box = $(registry.view.viewDocument);
// 视图还没有初始化
if(my_search_box == null) return;
let matchResult = registry.view.element.matchResult;
let textView = registry.view.element.textView
textView.html(html);
/*使用code代码块样式*/
document.querySelectorAll('#text_show pre code').forEach((el) => {
// 这里没有错，发警告不用理
hljs.highlightElement(el);
});
matchResult.css({
"display": "none"
})
textView.css({
"display":"block"
})
waitViewRenderingComplete(() => {
const currentKey = registry.searchData.searchHistory.currentKeyword();
if(currentKey.trim().length > 3) scrollToText(currentKey,0,"#ms-page-body");
});
}
},
// 搜索框logo控制
logo: {
// logo src值
originalLogoImgSrc: null,
// logo按钮是否按下状态
isLogoButtonPressedRef: ref(false),
getLogoImg: function () {
let viewDocument = registry.view.viewDocument;
if(viewDocument == null ) return null;
let currentLogoImg = registry.view.element.logoButton.find("img");
if(this.originalLogoImgSrc == null) this.originalLogoImgSrc = currentLogoImg.attr("src");
return currentLogoImg;
},
change: function (imgResource) {
let logoImg = this.getLogoImg();
if(imgResource == null || logoImg == null ) return;
logoImg.attr("src",imgResource)
},
reset: function() {
let logoImg = this.getLogoImg();
if (logoImg == null ) return;
logoImg.attr("src",this.originalLogoImgSrc)
}
},
modeEnum: {
UN_INIT: -2, // 未初始化
HIDE: -1, // 隐藏
WAIT_SEARCH: 0, // 待搜索模式
SHOW_RESULT: 1, // 结果显示模式
SHOW_ITEM_DETAIL: 2 // 查看项详情 (简述内容查看/脚本页)
},
seeNowMode() {
if(this.viewDocument == null) return this.modeEnum.UN_INIT;
if(this.element.textView.css('display')!== "none") return this.modeEnum.SHOW_ITEM_DETAIL;
if(this.element.matchResult.css('display') !== "none") return this.modeEnum.SHOW_RESULT;
return this.viewDocument.style.display !== "none" ? this.modeEnum.WAIT_SEARCH : this.modeEnum.HIDE;
}
},
other: {
UPDATE_CDNS_CACHE_KEY: "UPDATE_CDNS_CACHE_KEY"
},
searchData: {
// 处理的历史
processHistory: [],
// 用于数据显示后，数据又更新了
version: 0,
// 全局搜索数据
data: [],
// 数据更新后有效时长
effectiveDuration: 1000*60*60*12,
// 数据设置到全局中的时间
dataMountTime: null,
clearData() {
this.data = [];
this.dataMountTime = null;
},
setData(data) {
if(data == null || data.length == 0) return;
this.data = data;
this.dataMountTime = Date.now();
},
getData() {
let dataPackage = cache.get(registry.searchData.SEARCH_DATA_KEY);
if(dataPackage == null || dataPackage.data == null) return this.data;
// 缓存信息不为空，深入判断是否使用缓存的数据
let updateDataTime = dataPackage.expire - this.effectiveDuration;
// 如果数据在挂载后面已经更新了，重新加载数据到全局中
// 全局data (即this.data)与dataMountTime是同时设置的，两者理论上是必须同时有值的
if(this.data == null || updateDataTime > this.dataMountTime) {
console.logout("== 数据未加载或已检查到在其它页面已重新更新数据 ==")
this.setData(dataPackage.data);
}
return this.data;
},
// 根据keys(由idFun决定)从data中匹配items
matchItemsByKeys: function (keys = []) {
let that = this;
if(keys.length == 0) return [];
// 有keys转items
let items = keys.map(key=>{
for(let item of that.data) {
if(that.idFun(item) == key) return item;
}
return null;
})
// 对数组keys去空，注意此时keys已经是items了
return items.filter(item => item != null);
},
specialKeyword: { // 特殊的keyword
new: " 相对定位，以便按钮放在右上角
const pre = codeBlock.parentElement;
pre.style.position = "relative";
// 添加按钮到 容器
pre.appendChild(copyButton);
});
}
// 【数据初始化】
// 获取存在的订阅信息
function getSubscribe() {
// 查看是否有订阅信息
let subscribeKey = registry.searchData.subscribeKey;
let subscribeInfo = cache.get(subscribeKey);
if(subscribeInfo == null ) {
// 初始化订阅信息（初次）
subscribeInfo = `
function(pageText) {
let type = "sketch"; // url sketch
let lines = pageText.split("\\n");
let search_data_lines = []; // 扫描的搜索数据 {},{}
let current_build_search_item = {};
let appendTarget = "resource"; // resource 或 vassal
let current_build_search_item_resource = ""; // 主要内容
let current_build_search_item_vassal = ""; // 附加内容
let current_build_search_item_links = []; // 快捷链接列表
let point = 0; // 指的是上面的 current_build_search_item
let default_desc = "--无描述--"
function extractLinkInfo(str) {
const regex = /\\[(.*?)\\]\\((https?:\\/\\/[^\\s]+)\\s*(?:\\s+"([^"]+)?")?\\s*\\)/;
const match = str.match(regex);
if (match) {
return {
text: match[1], // 链接文本
url: match[2], // URL
title: match[3] || '' // 标题，如果没有则为空字符串
};
} else {
return null; // 如果没有匹配到内容，返回 null
}
}
function isOnlyLinkLine(str) {
// 按行拆分，并检查每一行
return !str.split('\\n').some(line => line.trim() !== '' && !line.trim().startsWith('> '));
}
function getTitleLineData(titleLine) {
try {
const regex = /^#\\s*([^（(]+)(?:[（(](.*)[）)])?\\s*$/;
let matchData = regex.exec(titleLine)
return {
title: matchData[1],
desc: ((matchData[2]==null || matchData[2] == "")?default_desc:matchData[2])
}
}catch(e) {
debugger
}
}
// 是否为空字符串，忽略空格/换行
function isBlank(str) {
const trimmedStr = str.replace(/\\s+/g, '').replace(/[\\n\\r]+/g, '');
return trimmedStr === '';
}
for (let i = 0; i < lines.length; i++) {
let line = lines[i];
if(line.indexOf("# ") == 0) {
// 当前新的开始工作
point++;
// 创建新的搜索项目容器
current_build_search_item = {...getTitleLineData(line)}
// 重置resource
current_build_search_item_resource = "";
continue;
}
// 如果是刚开始，没有标题的内容行，跳过
if(point == 0) continue;
// 判断是否开始为附加内容
if(/^\s*-{3,}\s*$/gm.test(line)) {
appendTarget = "vassal"
// 分割行不添加
continue
}
// 向当前搜索项目容器追加当前行
if(appendTarget == "resource") {
current_build_search_item_resource += (line+"\\n");
}else {
// 判断当前行是否为特殊行-快捷link行
if(isOnlyLinkLine(current_build_search_item_vassal) && (line.trim().length > 0 && isOnlyLinkLine(line)) ) {
current_build_search_item_links.push(extractLinkInfo(line))
}else {
current_build_search_item_vassal += (line+"\\n");
}
}
// 如果是最后一行，打包
let nextLine = lines[i+1];
if(i === lines.length-1 || ( nextLine != null && nextLine.indexOf("# ") == 0 )) {
// 加入resource，最后一项
current_build_search_item.resource = current_build_search_item_resource;
if(! isBlank(current_build_search_item_vassal)) {
current_build_search_item.vassal = current_build_search_item_vassal;
}
if(current_build_search_item_links.length > 0) {
current_build_search_item.links = current_build_search_item_links;
}
// 打包装箱
search_data_lines.push(current_build_search_item);
// 重置资源
appendTarget = "resource"
current_build_search_item_resource = "";
current_build_search_item_vassal = "";
current_build_search_item_links = [];
}
}
// 添加种类
for(let line of search_data_lines) {
line.type = type;
}
return search_data_lines;
}
function(pageText) {
let type = "url"; // url sketch
let lines = pageText.split("\\n");
let search_data_lines = []
for (let line of lines) {
let search_data_line = (function(line) {
const baseReg = /([^:：\\n(（）)]+)[(（]([^()（）]*)[)）]\\s*[:：]\\s*(.+)/gm;
const ifNotDescMatchReg = /([^:：]+)\\s*[:：]\\s*(.*)/gm;
let title = "";
let desc = "";
let resource = "";
let captureResult = null;
if( !(/[()（）]/.test(line))) {
// 兼容没有描述
captureResult = ifNotDescMatchReg.exec(line);
if(captureResult == null ) return;
title = captureResult[1];
desc = "-暂无描述信息-";
resource = captureResult[2];
}else {
// 正常语法
captureResult = baseReg.exec(line);
if(captureResult == null ) return;
title = captureResult[1];
desc = captureResult[2];
resource = captureResult[3];
}
return {
title: title,
desc: desc,
resource: resource
};
})(line);
if (search_data_line == null || search_data_line.title == null) continue;
search_data_lines.push(search_data_line)
}
for(let line of search_data_lines) {
line.type = type;
}
return search_data_lines;
}
` + getSubscribe();
return new Promise(async (resolve,reject)=>{
// 这里请求tishub datasources
// [ {name: "官方订阅",body: " 改为真正的换行符 \n
function contentRecovery(item) {
item.title = callBeforeParse.recovery(item.title);
item.desc = callBeforeParse.recovery(item.desc);
item.resource = callBeforeParse.recovery(item.resource);
if(item.vassal != null ) item.vassal = callBeforeParse.recovery(item.vassal);
}
// 如果tisMetaInfo中有"default-tag"属性表示标签有这个属性，属性处理器在此
function defaultTagHandle(item,tisMetaInfo = {}) {
const defaultTag = tisMetaInfo['default-tag'];
if(!defaultTag) return;
// 假设defaultTag是 h'游戏' 那下面processedDefaultTag是 [h'游戏']
const processedDefaultTag = `[${defaultTag}]`
// defaultTagContent就是 游戏
const defaultTagContent = parseTag(processedDefaultTag)[0][3];
// 这里看item.title是否已经有 '游戏'] 或 [游戏] 如果都没有才加，也就是子数据项如果手动加就，default-tag就不会生效
if( !parseTag(item.title).some(captureMeta => captureMeta[3] === defaultTagContent) ) {
item.title = processedDefaultTag + item.title;
}
}
// baseUrl + relativePath（文件 ./文件 ../文件）= relativePath的绝对路径
function resolveUrl(baseUrl, relativePath) {
// 创建一个链接对象，方便解析路径
const base = new URL(baseUrl);
// 处理相对路径
const resolvedUrl = new URL(relativePath, base);
return resolvedUrl.href;
}
function dataSourceHandle(resourcePageUrl,tisMetaInfo = {}, parentResourcePageUrl) { //resourcePageUrl 可以是url也可以是已经url解析出来的资源
const tisTabFetchFunName = tisMetaInfo && tisMetaInfo.fetchFun;
if(! registry.searchData.isDataInitialized) {
registry.searchData.isDataInitialized = true;
registry.searchData.processHistory = []; // 清空处理历史
registry.searchData.clearData(); // 清理旧数据
}
let processHistory = registry.searchData.processHistory; // 处理过哪些链接需要记住，避免重复
if(processHistory.includes(resourcePageUrl)) return; // 判断
processHistory.push(resourcePageUrl); // 记录
// 如果不根，且不是resourcePageUrl不是httpUrl,需要将resourcePageUrl（相对路径）根据parentResourcePageUrl(绝对路径)转为http url
if( ! tisMetaInfo.root && !isHttpUrl(resourcePageUrl) ) {
// if(parentResourcePageUrl == null) throw new Error(`订阅异常，相对路径: ${resourcePageUrl},没有父绝对路径!`);
resourcePageUrl = resolveUrl(parentResourcePageUrl,resourcePageUrl);
}
urlToText(resourcePageUrl).then(text => {
if(tisTabFetchFunName == null) {
// --> 是配置 <--
let data = []
// 解析配置
let config = getConfigFromDataSource(text);
console.logout("解析的配置：",config)
// 解析FetchFun：将FetchFun放到全局解析器中
globalFetchFun.push(...config.fetchFuns);
// 解析订阅：将tis放到处理队列中
waitQueue.push(...config.tis);
let tis = null;
while((tis = waitQueue.pop()) != undefined) {
// tis第一个是url,第二是fetchFun
dataSourceHandle(tis.tabValue,tis, resourcePageUrl);
}
}else {
// --> 是内容 <--
// 解析内容
if(tisTabFetchFunName === "") return;
let fetchFunStr = getFetchFunGetByName(tisTabFetchFunName);
let searchDataItems = [];
try {
searchDataItems =(new Function('text', "return ( " + fetchFunStr + " )(`"+callBeforeParse.escape(text)+"`)"))();
}catch(e) {
throw new Error("我的搜索 run log: 由于页面站点限制，导致数据解析失败！",e)
}
// 处理并push到全局数据容器中
for(let item of searchDataItems) {
// 转义-恢复
contentRecovery(item);
// "default-tag"标签属性处理器
defaultTagHandle(item,tisMetaInfo)
}
// 加入到push到全局的搜索数据队列中，等待加入到全局数据容器中
triggerRefreshNewData(searchDataItems)
}
})
}
// 根据fetchFun名返回字符串函数
function getFetchFunGetByName(fetchFunName) {
for(let fetchFunData of globalFetchFun) {
if(fetchFunData.name == fetchFunName) {
return fetchFunData.fetchFun;
}
}
}
// 检查是否已经执行初始化
function checkIsInitializedAndSetInitialized(secondTime) {
let key = "DATA_INIT";
let value = cache.cookieGet(key);
if(value != null && value != "") return true;
cache.cookieSet(key,key,1000*secondTime);
return false;
}
// 【数据初始化主函数】
// 调用下面函数自动初始化数据，刚进来直接检查更新(如果数据已过期就更新数据)
function dataInitFun() {
// 从缓存中获取数据，判断是否还有效
// cache.remove(SEARCH_DATA_KEY)
let dataPackage = cache.get(registry.searchData.SEARCH_DATA_KEY);
if(dataPackage != null && dataPackage.data != null) {
// 缓存信息不为空，深入判断是否使用缓存的数据
let dataExpireTime = dataPackage.expire;
let currentTime = new Date().getTime();
// 判断是否有效，有效的话放到全局容器中
let isNotExpire = (dataExpireTime != null && dataExpireTime > currentTime && dataPackage.data != null && dataPackage.data.length > 0);
// 如果网站比较特殊,忽略数据过期时间
if( window.location.host.includes("github.com") ) isNotExpire = true;
if(isNotExpire) {
// 当视图已经初始化时-从缓存中将挂载数据挂载 (条件是视图已经初始化)
console.logout(`视图${registry.view.initialized?'已加载':'未加载'}:数据有效期还有${parseInt((dataExpireTime - currentTime)/1000/60)} 分钟！`,dataPackage.data);
if( registry.view.initialized ) registry.searchData.setData(dataPackage.data);
// 如果数据状态未过期（有效）不会去请求数据
return;
}
}
// 在去网络请求获取数据前-检查是否已经执行初始化-防止多页面同时加载导致的数据重复加载
if(! askIsExpiredByTopic("SEARCH_DATA_INIT",6*1000)) return;
// 清理掉当前缓存数据
cache.remove(registry.searchData.SEARCH_DATA_KEY);
registry.searchData.clearData();
// 重置数据初始化状态
registry.searchData.isDataInitialized = false;
// 持续执行
registry.searchData.searchPlaceholder("UPDATE","🔁 数据准备更新中...",5000)
// 内部将使用递归，解析出信息
getDataSources().then(dataSources=>{dataSourceHandle(dataSources,{ root: true})})
}
// 检查数据有效性，且只有数据无效时挂载到数据
dataInitFun();
// 当视图第一次显示时，再执行
registry.view.viewFirstShowEventListener.push(dataInitFun);
// 解析标签函数-core函数
function parseTag(title) {
return captureRegEx(/\[\s*(([^'\]\s]*)\s*')?\s*([^'\]]*)\s*'?\s*]/gm,title);
}
// 解析出传入的所有项标签数据
function parseTags(data = [],selecterFun = (_item)=>_item,tagsMap = {}) {
let isArray = Array.isArray(data);
let items = isArray?data:[data];
// 解析 item.name中包含的标签
items.forEach(function(item) {
let captureGroups = parseTag(selecterFun(item));
captureGroups.forEach(function(group) {
let params = group[2]??"";
let label = group[3];
// 判断是否已经存在
if(label != null && tagsMap[label] == null ) {
let currentHandleTagObj = tagsMap[label] = {
name: label,
status: 1, // 正常
//visible: params.includes("h"), // 参数中包含h字符表示可见
count: 1
//params: params
//items: [item]
}
// 如果传入的不是一个数组，那设置下面参数才有意义
if(! isArray) {
currentHandleTagObj.params = params;
}
}else {
if(tagsMap[label] != null) {
tagsMap[label].count++;
//tagsMap[label].items.push(item);
}
}
})
});
// 这里不能是不是数组（上面的isArray）都返回tag数组,因为一项也可能有多个标签
return Object.values(tagsMap);
}
let tagsMap = {}
const parseSearchItem = function (searchData){
console.log("==1：解析出数据标签==")
// 将现有的所有标签提取出来
// 解析
let dataItemTags = parseTags(searchData,(_item=>_item.title),tagsMap);
// 缓存
if(dataItemTags.length > 0) {
cache.set(registry.searchData.DATA_ITEM_TAGS_CACHE_KEY,dataItemTags)
}
return searchData;
}
// ################# 执行顺序从大到小 1000 -> 500
registry.searchData.USDRC.add({weight:600 ,fun:parseSearchItem});
// 解析script项的text
function scriptTextParser(text) {
if (text == null) return null;
let scriptLines = text.split("\n");
if (scriptLines != null && scriptLines.length != 0) {
// 可以解析
let result = {};
let key = null;
let value = null;
for (let i = 0; i < scriptLines.length; i++) {
let line = scriptLines[i];
// 判断是否为新的变量开始
let captureArr = captureRegEx(/^--\s*([^-\s]*)\s*--\s*$/gm, line);
let isStartNewVar = captureArr != null && captureArr[0] != null && captureArr[0].length >= 2;
let isLastLine = (i + 1 == scriptLines.length);
if(isStartNewVar) {
// 保存前面的
if (key != null) result[key] = value.trim();
// 开始新的
key = captureArr[0][1];
value = ""; // 重置value
}else {
value += ("\n" + line);
}
if ( isLastLine) {
// 保存前面的
if (key != null) result[key] = value.trim();
return result;
}
}
return result;
}
return null;
}
// 将形如“aa bb” 转为 {aa:"bb"} ,并且如果是布尔类型或数值字符串转为对应的类型
function extractVariables(varsString) {
const lines = varsString.split('\n');
const result = {};
for (const line of lines) {
const parts = line.trim().split(/\s+/);
if (parts.length === 2) {
const key = parts[0].trim();
const value = parts[1].trim();
// 检查是否为 true/false 字符串
if (value === 'true' || value === 'false') {
result[key] = value === 'true'; // 转换为布尔值
} else if (!isNaN(value)) { // 检查是否为数值字符串
result[key] = parseFloat(value); // 转换为数值类型
} else {
result[key] = value; // 保持原始字符串
}
}
}
return result;
}
const parseScriptItem = function (searchData){
console.log("==1：简述项解析出脚本项==")
for(let item of searchData) {
if((item == null || item.title == null) || item.type != "sketch" ) continue;
if( /\[\s*(.*')?\s*(脚本|script)\s*'?\s*\]/.test( item.title ) ) {
// 是脚本项
item.type = "script";
// 将resource解析为对象
item.resourceObj = scriptTextParser(item.resource);
item.resource = "--脚本项resource已解析到resourceObj--"
// 解析脚本中的env(环境变量)
if(item.resourceObj.env != null) {
item.resourceObj.env = extractVariables(item.resourceObj.env);
// 将提取的icon变量放到数据项根上，这样显示时，可读取作为icon
let customIcon = item.resourceObj.env._icon;
if( customIcon != null) item.icon = customIcon;
let vassal = item.resourceObj.vassal;
if(vassal != null) item.vassal = vassal;
}
}
}
return searchData;
}
// ################# 执行顺序从大到小 1000 -> 500
registry.searchData.USDRC.add({weight:599 ,fun:parseScriptItem});
// 监听缓存被清理，当被清理时，置空之前收集的标签数据
registry.searchData.dataCacheRemoveEventListener.push(()=>{tagsMap = {}})
const refreshTags = function (searchData){
// 在添加前，进行额外处理添加，如给有”{keyword}“的url搜索项添加”可搜索“标签
for(let searchItem of searchData) {
let resource = searchItem.resource;
let isHttpUrl =/^[^\n]*\.[^\n]*$/.test(`${resource}`.trim());
let isSearchable = /\[\[[^\[\]]+keyword[^\[\]]+\]\]/.test(resource);
// 判断是否为可搜索
if( resource == null || !isHttpUrl || !isSearchable ) continue;
if(! searchItem.title.includes(registry.searchData.searchProTag)) searchItem.title = registry.searchData.searchProTag+searchItem.title;
}
return searchData;
}
// ################# 执行顺序从大到小 1000 -> 500
registry.searchData.USDRC.add({weight:500 ,fun:refreshTags});
// 清理标签（参数中有h的）
function clearHideTag(data,get = (item)=>item.title,set = (item,cleaned)=>{item.title=cleaned}) {
let isArray = Array.isArray(data);
let items = isArray?data:[data];
for(let item of items) {
let target = get(item);
const regex = /\[\s*[^:\]]*h[^:\]]*\s*'\s*[^'\]]*\s*'\s*]/gm;
let cleanedTarget = target.replace(regex, '');
set(item,cleanedTarget);
}
return isArray?items:items[0];
}
// 给title清理掉“h”标签
function clearHideTagForTitle(rawTitle) {
const regex = /\[\s*[^:\]]*h[^:\]]*\s*'\s*[^'\]]*\s*'\s*]/gm;
return rawTitle.replace(regex, '');
}
// 解析出标题中的所有标签-返回string数组
function extractTagsAndCleanContent(inputString = "") {
// 使用正则表达式匹配所有方括号包围的内容
const regex = /\[.*?\]/g;
const tags = inputString.match(regex) || [];
// 清理掉标签的内容
const cleanedContent = inputString.replace(regex, '').trim();
return {
tags: tags,
cleaned: cleanedContent
};
}
const filterSearchData = function (searchData) {
const filterDataByUserUnfollowList = (itemsData,userUnfollowList = []) => {
var userUnfollowMap = userUnfollowList.reduce(function(result, item) {
result[item] = '';
return result;
}, {});
// 开始过滤
return itemsData.filter(item=>{
let tags = parseTags(item.title);
for(let tag of tags){
if(userUnfollowMap[tag.name] != null){
// 被过滤
return false;
}
}
return true;
})
}
console.log("==去除用户不关注的数据项==")
// 用户维护的取消关注标签列表
let userUnfollowList = cache.get(registry.searchData.USER_UNFOLLOW_LIST_CACHE_KEY)?? registry.searchData.USER_DEFAULT_UNFOLLOW;
// 利用用户维护的取消关注标签列表 过滤 搜索数据
let filteredSearchData = filterDataByUserUnfollowList(searchData,userUnfollowList);
// 去标签（参数h）,清理每个item中title属性的tag , 下面注释掉是因为清理后置了仅在显示时不显示
// let clearedSearchData = clearHideTag(filteredSearchData);
return filteredSearchData;
}
// ############### 执行顺序从大到小 1000 -> 500
registry.searchData.USDRC.add({weight:400 ,fun:filterSearchData});
let isHasLaftData = true;
const compareBlocks = function (searchData = []) {
let oldSearchData = cache.get(registry.searchData.OLD_SEARCH_DATA_KEY)??[];
if(isHasLaftData) isHasLaftData = oldSearchData != null && oldSearchData.length > 0;
console.log("块数据与旧数据对比中>>")
// 新数据加载完成-进行数据对比
// 旧数据，也就是上一次数据，用于与本次比较，得出新添加数据
// 当前时间戳
let currentTime = new Date().getTime();
// 准备一个存储新数据项的容器
let newDataItems = compareAndPushDiffToHistory(searchData);
// 给新添加的过期时间（新数据有效期）
newDataItems.forEach(item=> {
// 添加过期时间
item.expires = (currentTime++) + ( 1000*60*60*24*registry.searchData.NEW_DATA_EXPIRE_DAY_NUM )
});
console.log("数据对比-新差异项：",[...newDataItems]);
// 过滤掉新数据中带有“带注释”的项
newDataItems = newDataItems.filter(item=> !item.title.startsWith("#"));
// 以前的新增数据
let oldNewItems = cache.get(registry.searchData.SEARCH_NEW_ITEMS_KEY);
// 如果第一次加载数据，那不要这次的最新数据
if(oldNewItems == null) {
cache.set(registry.searchData.SEARCH_NEW_ITEMS_KEY,[]);
return searchData;
}
// 如果还没有过期的，保留下来放在最新数据中
for(let item of oldNewItems) {
if(item != null && item.expires > currentTime) newDataItems.push(item);
}
console.log("数据对比-总新数据：",[...newDataItems])
// 总新增去重 (标记 - 过滤标记的 )
newDataItems = removeDuplicates(newDataItems,(item)=>item.title+item.desc);
// 当新数据项大于registry.searchData.showSize时，进行截取
if(! isHasLaftData) {
// 如何是第一次安装，那不应该有新数据
newDataItems = [];
}else if( newDataItems.length > registry.searchData.showSize ) {
// 如果新增超过指定数量 ，进行截取头部最新
// 先根据expires属性降序排序
newDataItems.sort((a, b) => b.expires - a.expires);
// 然后截取前15条记录
newDataItems = newDataItems.slice(0, registry.searchData.showSize );
}
// 重新缓存“New Data”
cache.set(registry.searchData.SEARCH_NEW_ITEMS_KEY,newDataItems);
// 为全局数据（注册表中）的新数据添加新数据标签
for(let nItem of newDataItems) {
for(let cItem of searchData) {
if(nItem.title === cItem.title && nItem.desc === cItem.desc) {
// 修改全局搜索数据中New Data数据添加“新数据”标签
if (! cItem.title.startsWith(registry.searchData.NEW_ITEMS_TAG)) {
cItem.title = registry.searchData.NEW_ITEMS_TAG+cItem.title;
}
break;
}
}
}
return searchData;
}
// ############ 使用用户操作的规则对加载出来的数据过滤：（责任链中的一块）
registry.searchData.USDRC.add({weight:300 ,fun:compareBlocks});
// 索引处理与缓存
const refreshIndex = function (globalSearchData) {
if(globalSearchData == null || globalSearchData.length == 0 ) return;
console.log("===刷新索引===")
// 当前最新数据，用于搜索
let newDataItems = cache.get(registry.searchData.SEARCH_NEW_ITEMS_KEY);
// 去重
globalSearchData = removeDuplicates(globalSearchData,(item)=>item.title+item.desc)
// 将 index 给 newDataItems ,不然new中的我们选择与实际选择的不一致问题 ！
// 给全局数据创建索引
globalSearchData.forEach((item,index)=>{item.index=index});
// 给NEW建索引
newDataItems.forEach(NItem=>{
for(let CItem of globalSearchData) {
if( CItem.title.includes(NItem.title) && NItem.desc === CItem.desc) {
NItem.index = CItem.index;
break;
}
}
})
// 重新缓存“New Data”
cache.set(registry.searchData.SEARCH_NEW_ITEMS_KEY,newDataItems);
// 重新缓存全局数据
cacheSearchData(globalSearchData);
}
// 加入到数据改变后事件处理
registry.searchData.dataChangeEventListener.push(refreshIndex);
// 模块二
registry.view.viewVisibilityController = (function() {
// 整个视图对象
let viewDocument = null;
let initView = function () {
// 初始化视图
let view = document.createElement("div")
view.id = "my_search_box";
let menu_icon = "data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBzdGFuZGFsb25lPSJubyI/PjwhRE9DVFlQRSBzdmcgUFVCTElDICItLy9XM0MvL0RURCBTVkcgMS4xLy9FTiIgImh0dHA6Ly93d3cudzMub3JnL0dyYXBoaWNzL1NWRy8xLjEvRFREL3N2ZzExLmR0ZCI+PHN2ZyB0PSIxNjc3MDgxNTk3NzA3IiBjbGFzcz0iaWNvbiIgdmlld0JveD0iMCAwIDEwMjQgMTAyNCIgdmVyc2lvbj0iMS4xIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHAtaWQ9IjEzNDYxIiB4bWxuczp4bGluaz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94bGluayIgd2lkdGg9IjIwMCIgaGVpZ2h0PSIyMDAiPjxwYXRoIGQ9Ik0yMjQuMiA0NzIuM2MtMTMtNS43LTMuNy0yMy41IDguMi0xOSA5MSAzNCAxNDYuOCAxMDguNyAxODIuNCAxMzguNSA1LjYgNC43IDE0IDIuOSAxNy4zLTMuNSAxNi44LTMyIDQ1LjgtMTEzLjctNTcuMS0xNjguNi04Ny4zLTQ2LjUtMTg4LTUzLjYtMjQ3LjMtODIuMi0xNC41LTctMzEuMSA0LjYtMjkuOSAyMC43IDUgNjkuNyAyOC45IDEyNC43IDYyLjMgMTgxLjUgNjcuMyAxMTQuMyAxNDAuNiAxMzIuOSAyMTYuNiAxMDQgMi4yLTAuOSA0LjUtMS44IDctMyA3LTMuNCA4LjMtMTIuOSAyLjUtMTguMSAwLjEgMC00NS43LTY5LjMtMTYyLTE1MC4zeiIgZmlsbD0iI0ZGRDQwMSIgcC1pZD0iMTM0NjIiPjwvcGF0aD48cGF0aCBkPSJNMjgyLjcgODQ5LjljNzkuNS0xMzcgMTcyLjQtMjYzLjEgMzg1LjQtNDAxLjMgOS44LTYuNCAyLjEtMjEuNS04LjktMTcuNEM0OTcuNyA0OTIuOCA0MjkuNyA1ODUgMzczLjMgNjQwLjhjLTguNyA4LjctMjMuNCA2LjMtMjkuMS00LjYtMjcuMi01MS44LTY5LjUtMTc0LjEgOTcuMy0yNjMuMSAxNDcuNy03OC44IDMxOS45LTkxLjQgNDI5LjctOTMuMyAxOC45LTAuMyAzMS41IDE5LjQgMjMuMyAzNi40Qzg2My43IDM4MCA4NDIuNiA0NzggNzg5LjkgNTY3LjYgNjgwLjggNzUzLjEgNTQ1LjUgNzY2LjcgNDIyLjIgNzE5LjhjLTguOC0zLjQtMTguOC0wLjItMjQgNy43LTE2LjYgMjUuMi01MC4zIDgwLjEtNTguNyAxMjIuNC0xMS40IDU2LjgtODIuMiA0My45LTU2LjggMHoiIGZpbGw9IiM4QkMwM0MiIHAtaWQ9IjEzNDYzIj48L3BhdGg+PHBhdGggZD0iTTM3NSA0MTkuNmMtMzAuMSAyOC4yLTQ1LjggNTcuNy01Mi40IDg2LjEgNDAuNiAzMi40IDcwLjIgNjcuNyA5Mi4xIDg1LjkgMS4yIDEgMi41IDEuNiAzLjkgMi4xIDYuNS02LjcgMTMuMy0xMy43IDIwLjQtMjAuNyAxNS4yLTM3LjkgMjUuMy0xMDUuNy02NC0xNTMuNHpNMzE4LjggNTQ4LjJjMS42IDM2LjEgMTQuNyA2Ny42IDI1LjUgODguMSA1LjcgMTAuOSAyMC4zIDEzLjMgMjkuMSA0LjYgNC45LTQuOSAxMC0xMCAxNS4xLTE1LjQtMC42LTEtMS4zLTItMi4yLTIuOCAwLTAuMS0yMC4xLTMwLjUtNjcuNS03NC41eiIgZmlsbD0iIzhCQTAwMCIgcC1pZD0iMTM0NjQiPjwvcGF0aD48L3N2Zz4=";
const matchResultDocumentId = "matchResult", textViewDocumentId = "text_show",searchInputDocumentId = "my_search_input",matchItemsId = "matchItems",searchBoxId = "searchBox",logoButtonId = "logoButton",msInputFilesId = "ms-input-files";
view.innerHTML = (`
`)
// 挂载到文档中
document.body.appendChild(view)
// 整个视图对象放在组件全局中/注册表中
viewDocument = registry.view.viewDocument = view;
// 想要追加请看下面registry.view.element是否已经包含，没有在那下面追加即可~
// 搜索框对象
let searchInputDocument = $(document.getElementById(searchInputDocumentId)),
matchItems = $(document.getElementById(matchItemsId)),
searchBox = $(document.getElementById(searchBoxId)),
logoButton = $(document.getElementById(logoButtonId)),
textView = $(document.getElementById(textViewDocumentId)),
matchResult = $(document.getElementById(matchResultDocumentId)),
msInputFiles = $(document.getElementById(msInputFilesId));
// 将视图对象放到注册表中
registry.view.element = {
input: searchInputDocument,
logoButton,
matchItems,
searchBox,
matchResult,
textView,
files: msInputFiles
}
// 开启files 粘贴事件监听
registry.searchData.searchForFile.start();
// 菜单函数(点击输入框右边按钮时会调用)
function onClickLogo() {
// alert("小彩蛋：可以搜索一下“系统项”了解脚本基本使用哦~");
// 调用手动触发搜索函数,如果已经搜索过，搜索空串（清理）
let keyword = "[系统项]";
registry.searchData.triggerSearchHandle(searchInputDocument.val()==keyword?'':keyword);
// 重新聚焦搜索框
registry.view.element.input.focus()
}
const isLogoButtonPressedRef = registry.view.logo.isLogoButtonPressedRef;
// 按下按钮时设置变量为 true
logoButton.on('mousedown', function() {
isLogoButtonPressedRef.value = true;
});
// 按钮弹起时设置变量为 false，并让输入框聚焦
logoButton.on('mouseup', function() {
isLogoButtonPressedRef.value = false;
onClickLogo() // 触发logo点击事件
searchInputDocument.focus(); // 输入框聚焦
});
// 防止鼠标拖出按钮后弹起无法触发 mouseup
logoButton.on('mouseleave', function() {
if (isLogoButtonPressedRef.value) {
isLogoButtonPressedRef.value = false;
searchInputDocument.focus(); // 输入框聚焦
}
});
// 设置视图已经初始化
registry.view.initialized = true;
// 在搜索的结果集中上下选择移动然后回车（相当点击）
searchInputDocument.keyup(function(event){
let keyword = $(event.target).val().trim();
// 当不为空时，放到全局keyword中
if(keyword) {
registry.searchData.keyword = event.target.value;
}
// 处理keyword中的":"字符
if(keyword.endsWith("::") || keyword.endsWith("：：")) {
keyword = keyword.replace(/::|：：/,registry.searchData.subSearch.searchBoundary).replace(/\s+/," ");
// 每次要形成一个" : "的时候去掉重复的" : : " -> " : "
keyword = keyword.replace(/((\s{1,2}:)+ )/,registry.searchData.subSearch.searchBoundary);
$(event.target).val(keyword.toUpperCase());
}
});
// searchInputDocument.keydown：这个监听用来处理其它键（非上下选择）的。
searchInputDocument.keydown(function (event){
// 阻止键盘事件冒泡 | 阻止输入框外监听到按钮，应只作用于该输入框
event.stopPropagation();
// 判断一个输入框的东西，如果如果按下的是删除，判断一下是不是"搜索模式"
let keyword = $(event.target).val();
let input = event.target;
if(event.key == "Backspace" ) { // 按的是删除键-块删除
if(keyword.endsWith(registry.searchData.subSearch.searchBoundary)) {
// 取消默认事件-删除
event.preventDefault();
return;
}else if(/^\s*[\[<][^\[\]<>]*[\]>]\s*$/.test( keyword )) {
// 如果输入框只有[xxx]或那就清空掉输入框
searchInputDocument.val('')
// keyword重置为空字符后触发搜索
registry.searchData.triggerSearchHandle();
event.preventDefault();
return;
}else if(keyword === ""){
registry.searchData.searchForFile.delete();
}
}else if ( ! event.shiftKey && event.keyCode === 9 ) { // Tab键
if(! registry.searchData.subSearch.isSubSearchMode()) {
// 转大写
event.target.value = event.target.value.toUpperCase()
// 添加搜索pro模式分隔符
event.target.value += registry.searchData.subSearch.searchBoundary
// 阻止默认行为，避免跳转到下一个元素
registry.searchData.triggerSearchHandle();
}
event.preventDefault();
}else if (event.shiftKey && event.keyCode === 9 ) { // 按下shift + tab键时取消搜索模式
if(registry.searchData.subSearch.isSubSearchMode()) {
// 在这里编写按下shift+tab键时要执行的代码
let input = event.target;
input.value = input.value.split(registry.searchData.subSearch.searchBoundary)[0]
event.target.value = event.target.value.toLowerCase();
// 手动触发输入事件
input.dispatchEvent(new Event("input", { bubbles: true }));
}
event.preventDefault();
}
})
// searchInputDocument.keydown：这个监听用来处理上下选择范围的操作
searchInputDocument.keydown(function (event){
let e = event || window.event;
if(e && e.keyCode!=38 && e.keyCode!=40 && e.keyCode!=13) return;
if(e && e.keyCode==38){ // 上
registry.searchData.pos --;
}
if(e && e.keyCode==40){ //下
registry.searchData.pos ++;
}
// 如果是回车 && registry.searchData.pos == 0 时，设置 registry.searchData.pos = 1 (这样是为了搜索后回车相当于点击第一个)
if(e && e.keyCode==13 && registry.searchData.pos == 0){ // 回车选择的元素
// 如果当前是在搜索中就忽略回车这个操作
if(registry.searchData.searchEven.isSearching) return;
registry.searchData.pos = 1;
}
// 当指针位置越出时，位置重定向
if(registry.searchData.pos < 1 || registry.searchData.pos > registry.searchData.searchData.length ) {
if(registry.searchData.pos < 1) {
// 回到最后一个
registry.searchData.pos = registry.searchData.searchData.length;
}else {
// 回到第一个
registry.searchData.pos = 1;
}
}
// 设置显示样式
let activeItem = $(registry.view.element.matchItems.find('li')[registry.searchData.pos-1]);
// 设置活跃背景颜色
let activeBackgroundColor = "#dee2e6";
activeItem.css({
"background":activeBackgroundColor
})
// 设置其它子元素背景为默认统一背景
activeItem.siblings().css({
"background":"#fff"
})
// 看是不是item detail内容显示中，如果是回车发送send事件，否则才是结果集显示的回车选择
if(e && e.keyCode==13 && activeItem.find("a").length > 0 && !registry.script.tryRunTextViewHandler()){ // 回车
// 点击当前活跃的项，点击
activeItem.find("a")[0].click();
}
// 取消冒泡
e.stopPropagation();
// 取消默认事件
e.preventDefault();
});
// 将输入框的控制按钮设置可见性函数公开放注册表中
registry.view.setButtonVisibility = function (buttonVisibility = false) {
// registry.view.setButtonVisibility
logoButton.css({
"display": buttonVisibility?"block":"none"
})
}
// 高权重项特殊搜索关键词直达
registry.searchData.searchEven.event[registry.searchData.specialKeyword.highFrequency] = function(search,rawKeyword) {
return DataWeightScorer.highFrequency(45);
}
// 历史记录特殊搜索关键词直达
registry.searchData.searchEven.event[registry.searchData.specialKeyword.history] = function(search,rawKeyword) {
return SelectHistoryRecorder.history(15);
}
// 向搜索事件（只会触发一个）中添加一个“NEW”搜索关键词
registry.searchData.searchEven.event["new|"+registry.searchData.specialKeyword.new] = function(search,rawKeyword) {
let showNewData = null;
let activeSearchData = registry.searchData.getData();
// 如果当前注册表中全局搜索数据为空，使用缓存的数据
if(activeSearchData == null ) {
let cacheAllSearchData = cache.get(registry.searchData.SEARCH_DATA_KEY);
if(cacheAllSearchData != null && cacheAllSearchData.data != null) activeSearchData = cacheAllSearchData.data;
}
// 如果最新数据都没有，使用旧数据（上一次）
if(activeSearchData == null ) {
let oldCacheAllSearchData = cache.get(registry.searchData.OLD_SEARCH_DATA_KEY);
if(oldCacheAllSearchData != null) activeSearchData = oldCacheAllSearchData;
}
// 只展示 newItems 数据中data也存在的项
let newItems = cache.get(registry.searchData.SEARCH_NEW_ITEMS_KEY)??[];
if(newItems.length > 0 && activeSearchData.length > 0) {
// 返回的showNewData是左边的（activeSearchData），而不是右边的（newItems）,但newItems多出来 的属性也会合并到activeSearchData的item
showNewData = compareArrayDiff(activeSearchData,newItems,registry.searchData.idFun,0)
}
if(showNewData == null) return [];
// 对数据进行排序
showNewData.sort(function(item1, item2){return item2.expires - item1.expires});
showNewData.map((item,index)=>{
let dayNumber = registry.searchData.NEW_DATA_EXPIRE_DAY_NUM;
// 去掉[新] 再都加[新]，使得就算没有也在显示时也是有新标签的
item.title = registry.searchData.NEW_ITEMS_TAG+item.title.toReplaceAll(registry.searchData.NEW_ITEMS_TAG,"")
// 添加“几天前”
item.title = item.title + " | " + Math.floor( (Date.now() - (item.expires - 1000*60*60*24*dayNumber) )/(1000*60*60*24) )+"天前"; //toDateString
return item;
})
// 将最新的一条由“新”改为“最新一条”
showNewData[0].title = showNewData[0].title.toReplaceAll(registry.searchData.NEW_ITEMS_TAG,"[最新一条]")
return showNewData;
}
// 可填充搜索模式优先路由(key是正则字符串，value为字符串类型是转发，如果是函数，是自定义搜索逻辑）
const searchableSpecialRouting = {
"^\\s*$": "问AI",
"^问AI$": async (search,rawKeyword,keywordForFill0)=>{
return await search(keywordForFill0,{isAccurateSearch : true});
}
}
// 返回undfind表示没有定义匹配对应的SpecialRouting，执行通用路由 | null表示跳过 | 返回数组表示SpecialRouting执行搜索得到的结果
const searchableSpecialRoutingHandler = async function(search,rawKeyword){
const keywordForFill0 = registry.searchData.subSearch.getParentKeyword(rawKeyword);
for(let key of Object.keys(searchableSpecialRouting)) {
if(isMatch(key,keywordForFill0)) {
const value = searchableSpecialRouting[key];
if(typeof value === "string") {
registry.searchData.triggerSearchHandle(value+registry.searchData.subSearch.searchBoundary)
return [];
}
if(typeof value === "function") return await value(search,rawKeyword,keywordForFill0);
}
}
// 表示没有匹配到SpecialRouting
return undefined;
}
registry.searchData.searchEven.event[".*"+registry.searchData.subSearch.searchBoundary+".*"] = async function(search,rawKeyword) {
const specialRoutinResult = await searchableSpecialRoutingHandler(search,rawKeyword)
// 当没有优先Result, 只搜索“可搜索”项
return Array.isArray(specialRoutinResult)
? specialRoutinResult
: await search(`${registry.searchData.searchProTag} ${registry.searchData.subSearch.getParentKeyword()}`);
}
// 搜索AOP
async function searchAOP(search,rawKeyword) {
// 转发到对应的AOP处理器中（keyword规则订阅者）
let data = registry.searchData.getData();
console.log("搜索data:",data)
return await registry.searchData.searchEven.send(search,rawKeyword);
}
function searchUnitHandler(beforeData = [],keyword = "") {
// 触发搜索事件
for(let e of registry.searchData.onSearch) e(keyword);
// 如果没有搜索内容，返回空数据
keyword = keyword.trim().toUpperCase();
if(keyword == "" || registry.searchData.getData().length == 0 ) return [];
// 切割搜索内容以空格隔开，得到多个 keyword
let searchUnits = keyword.split(/\s+/);
// 弹出一个 keyword
keyword = searchUnits.pop();
// 本次搜索的总数据容器
let searchResultData = [];
let searchLevelData = [
[],[],[] // 分别是匹配标题/desc/url 的结果
]
// 数据出来的总数据
//let searchData = []
// 前置处理函数,这里使用观察者模式
// searchPreFun(keyword);
// 搜索操作
// 为实现当关键词只有一位时，不使用转拼音搜索，后面搜索涉及到的转拼音操作要使用它，而不是直接调用toPinyin
function getPinyinByKeyword(str,isOnlyFomCacheFind=false) {
if(registry.searchData.keyword.length > 1 ) return str.toPinyin(isOnlyFomCacheFind)??"";
return str??"";
}
let pinyinKeyword = getPinyinByKeyword(keyword);
let searchBegin = Date.now()
for (let dataItem of beforeData) {
/* 取消注释会导致虽然是15条，但有些匹配度高的依然不能匹配
// 如果已达到搜索要显示的条数，则不再搜索 && 已经是本次最后一次过滤了 => 就不要扫描全部数据了，只搜出15条即可
let currentMeetConditionItemSize = searchLevelData[0].length + searchLevelData[1].length + searchLevelData[2].length;
if(currentMeetConditionItemSize >= registry.searchData.showSize && searchUnits.length == 0 && registry.searchData.subSearch.isSubSearchMode() ) break;
*/
// 将数据放在指定搜索层级数据上DeepSeek
if(dataItem.title.includes("DeepSeek")) debugger;
if (
(( getPinyinByKeyword(dataItem.title,true).includes(pinyinKeyword) || dataItem.title.toUpperCase().includes(keyword) ) && searchLevelData[0].push(dataItem) )
|| (( getPinyinByKeyword(dataItem.desc,true).includes(pinyinKeyword) || dataItem.desc.toUpperCase().includes(keyword)) && searchLevelData[1].push(dataItem) )
|| ( `${registry.searchData.links.stringifyForSearch(dataItem.links)}${dataItem.resource}${dataItem.vassal}`.substring(0, 4096).toUpperCase().includes(keyword) && searchLevelData[2].push(dataItem) )
) {} // 若满足条件的数据对象则会添加到对应的盒子中
}
let searchEnd = Date.now();
console.logout("常规搜索主逻辑耗时："+(searchEnd - searchBegin ) +"ms");
// 将上面层级数据进行权重排序然后放在总容器中
searchResultData.push(...DataWeightScorer.sort(searchLevelData[0],registry.searchData.idFun));
searchResultData.push(...DataWeightScorer.sort(searchLevelData[1],registry.searchData.idFun));
searchResultData.push(...DataWeightScorer.sort(searchLevelData[2],registry.searchData.idFun));
if(searchUnits.length > 0 && searchUnits[searchUnits.length-1].trim() != registry.searchData.subSearch.searchBoundary.trim()) {
// 递归搜索
searchResultData = searchUnitHandler(searchResultData,searchUnits.join(" "));
}
return searchResultData;
}
// ==标题tag处理==
// 1、标题tag颜色选择器
function titleTagColorMatchHandler(tagValue) {
let vcObj = {
"系统项":"background:rgb(0,210,13);",
"非最佳":"background:#fbbc05;",
"推荐":"background:#ea4335;",
"装机必备":"background:#9933E5;",
"好物":"background:rgb(247,61,3);",
"安卓应用":"background:#73bb56;",
"Adults only": "background:rgb(244,201,13);",
"可搜索":"background:#4c89fb;border-radius:0px !important;",
"新":"background:#f70000;",
"最新一条":"background:#f70000;",
"精选好课":"background:#221109;color:#fccd64 !important;"
};
let resultTagColor = "background:#5eb95e;";
Object.getOwnPropertyNames(vcObj).forEach(function(key){
if(key == tagValue) {
resultTagColor = vcObj[key];
}
});
return resultTagColor;
}
// 2、标题内容处理程序
function titleTagHandler(title) {
if(!(/[\[]?/.test(title) && /[\]]?/.test(title))) return -1;
// 格式是：[tag]title 这种的
const regex = /(\[[^\[\]]*\])/gm;
let m;
let resultTitle = title;
while ((m = regex.exec(title)) !== null) {
// 这对于避免零宽度匹配的无限循环是必要的
if (m.index === regex.lastIndex) {
regex.lastIndex++;
}
let tag = m[0];
if(tag == null || tag.length == 0) return -1;
let tagCore = tag.substring(1,tag.length - 1);
// 正确提取
resultTitle = resultTitle.toReplaceAll(tag,`${tagCore}`);
}
return resultTitle;
}
// 3、添加标题处理器 titleTagHandler
registry.view.titleTagHandler.handlers.push(titleTagHandler)
// 给输入框加事件
// 执行 debounce 函数返回新函数
let handler = async function (e) {
// 搜索使用的数据版本
let version = registry.searchData.version;
let rawKeyword = e.target.value;
// 在本次搜索加入到历史前检查(如果之前是子搜索模式且现在还是子搜索模式那就跳过搜索,因为内是子搜索内容被修改不进行搜索)
if(registry.searchData.subSearch.isEnteredSubSearchMode && registry.searchData.subSearch.isSubSearchMode()
&& registry.searchData.searchHistory.seeCurrentEqualsLastByRealKeyword()) return;
// 添加到搜索历史（维护这个历史有用是为了子搜索模式的“进”-“出”）
registry.searchData.searchHistory.add(rawKeyword)
// 字符串重叠匹配度搜索（类AI搜索）
async function stringOverlapMatchingDegreeSearch(rawKeyword) {
const endTis = registry.view.tis.beginTis("(;｀O´)o 匹配度模式搜索中...")
// 这里为什么要用异步，不果不会那上面设置的tis会得不到渲染，先保证上面已经渲染完成再执行下面函数
return await new Promise((resolve,reject)=>{
waitViewRenderingComplete(() => {
try {
// 搜索逻辑开始
// `registry.searchData.getData()`会被排序desc
// 为什么需要拷贝data，因为全局的搜索位置不能改变！！
const searchBegin = Date.now();
let searchResult = overlapMatchingDegreeForObjectArray(rawKeyword.toUpperCase(),[...registry.searchData.getData()], (item)=>{
const str2ScopeMap = {}
const { tags , cleaned } = extractTagsAndCleanContent(`${item.title}`);
str2ScopeMap[cleaned.toUpperCase()] = 4;
str2ScopeMap[`${item.describe}${tags.join()}`.toUpperCase()] = 2;
str2ScopeMap[`${item.links && registry.searchData.links.stringifyForSearch(item.links)}${item.resource}${item.vassal}`.substring(0, 4096).toUpperCase()] = 1;
return str2ScopeMap;
},"desc",{sort:"desc",onlyHasScope:true});
const searchEnd = Date.now();
console.log("启动类AI搜索结果 ：",searchResult)
console.logout("类AI搜索主逻辑耗时："+(searchEnd - searchBegin ) +"ms");
resolve(searchResult)
}catch (e) {
console.error("类AI搜索异常！",e)
resolve([])
}finally {
endTis()
}
})
})
}
// 常规方式搜索（搜索逻辑入口）
async function search(rawKeyword,{isAccurateSearch = false} = {}) {
let processedKeyword = rawKeyword.trim().split(/\s+/).reverse().join(" ");
version = registry.searchData.version;
// 常规搜索
let searchResult = searchUnitHandler(registry.searchData.getData(),processedKeyword);
// 如果常规搜索不到使用类AI搜索(不能是精确搜索 && 常规搜索没有结果 && 搜索keyword不为空串)
if(!isAccurateSearch && (searchResult == null || searchResult.length === 0) && `${rawKeyword}`.trim().length > 0 ) {
searchResult = await stringOverlapMatchingDegreeSearch(rawKeyword)
}
return searchResult;
}
// 搜索AOP或说搜索代理
// 递归搜索，根据空字符切换出来的多个keyword
// let searchResultData = searchUnitHandler(registry.searchData.data,key)
let searchResultData = await searchAOP(search,rawKeyword);
// 如果搜索的内容无效，跳过内容的显示
if(searchResultData == null) return;
// 放到视图上
// 置空内容
matchItems.html("")
// 最多显示条数
let show_item_number = registry.searchData.showSize ;
function getFaviconImgHtml(searchResultItem) {
if(searchResultItem == null) return null;
let resource = searchResultItem.resource.trim();
let customIcon = null;
if(searchResultItem.icon != null) {
customIcon = searchResultItem.icon;
}else {
let type = searchResultItem.type;
// 如果不是url，那其它类型就需要自定义图标
let typesAndImg = {
"sketch":"data:image/png;base64,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",
"script":"data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBzdGFuZGFsb25lPSJubyI/PjwhRE9DVFlQRSBzdmcgUFVCTElDICItLy9XM0MvL0RURCBTVkcgMS4xLy9FTiIgImh0dHA6Ly93d3cudzMub3JnL0dyYXBoaWNzL1NWRy8xLjEvRFREL3N2ZzExLmR0ZCI+PHN2ZyB0PSIxNjkyMzU4NTM5NjI1IiBjbGFzcz0iaWNvbiIgdmlld0JveD0iMCAwIDEwMjQgMTAyNCIgdmVyc2lvbj0iMS4xIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHAtaWQ9Ijc2MjUiIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB3aWR0aD0iMjAwIiBoZWlnaHQ9IjIwMCI+PHBhdGggZD0iTTk1OC4xNyA0NDcuNEw3NjAuNjkgMjQ5LjkybC02NS44MiA2NS44MyAxOTcuNDcgMTk3LjQ3TDY5NC44NyA3MTAuN2w2NS44MiA2NS44MiAxOTcuNDgtMTk3LjQ3IDY1LjgzLTY1Ljgzek0yNjMuMyAyNDkuOTJMNjUuODIgNDQ3LjQgMCA1MTMuMjJsNjUuODIgNjUuODNMMjYzLjMgNzc2LjUybDY1LjgyLTY1LjgyLTE5Ny40Ny0xOTcuNDggMTk3LjQ3LTE5Ny40N3pNMzQzLjI0NyA5NDkuNDgzTDU5MC45NiA1Mi4xOWw4OS43MiAyNC43NjgtMjQ3LjcxMyA4OTcuMjk1eiIgZmlsbD0iIzIzMTgxNSIgcC1pZD0iNzYyNiI+PC9wYXRoPjwvc3ZnPg=="
}
// url与sketch类型可互转，主要看resource
type = (type == "url" || type == "sketch")?(isUrl(resource)?"url":"sketch"):type;
if(type != "url") customIcon = typesAndImg[type];
}
if(customIcon != null) {
return `
`
}else {
return `})
`
}
}
// 标题内容处理器
function titleContentHandler(title) {
// 对标题去掉所有tag
const { cleaned } = extractTagsAndCleanContent(title)
title = cleaned
// 如果带#将加上删除线,通过加obsolete类名方式
return `${title.replace(/^#/,"")}`;
}
let matchItemsHtml = "";
// 真正渲染到列表的数据项
let searchData = []
for(let searchResultItem of searchResultData ) {
// 限制条数
if(show_item_number-- <= 0 && !registry.searchData.isSearchAll) {
break;
}
// 显示时清理标签-虽然在加载数据时已经清理了，但这是后备方案
// clearHideTag(searchResultItem);
// 将数据放入局部容器中
searchData.push(searchResultItem)
let isSketch = !isUrl(searchResultItem.resource);// searchResultItem.resource.trim().toUpperCase().indexOf("HTTP") != 0;
let vassalSvg = ``;
// 构建快捷link html
function buildRelatedLinksHtml(links) {
if (links == null || links.length === 0) return '';
let html = `';
return html;
}
// 将符合的数据装载到视图
let item = `
${getFaviconImgHtml(searchResultItem)}
${registry.view.titleTagHandler.execute(clearHideTagForTitle(searchResultItem.title))}${titleContentHandler(searchResultItem.title)}
（${searchResultItem.desc}）
${buildRelatedLinksHtml(searchResultItem.links)}
${searchResultItem.vassal !=null?''+vassalSvg+'':''}
`
matchItemsHtml += item;
}
matchItems.html(matchItemsHtml);
let loadErrorTagIcon = "data:image/svg+xml;base64,<svg version="1.2" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 200 200" width="200" height="200">
	<title>ap8zc-vrmdo</title>
	<defs>
		<image  width="194" height="194" id="img1" href="data:image/png;base64,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"/>
	</defs>
	<style>
	</style>
	<use id="Background" href="#img1" x="6" y="0"/>
</svg>";
// 给刚才添加的img添加事件
for(let imgObj of registry.view.element.matchItems.find('img')) {
// 加载完成事件，去除加载背景
imgObj.onload = function(e) {
$(e.target).css({
"background": "#fff"
})
}
// 加载失败，设置自定义失败的本地图片
imgObj.onerror = function(e,a,b,c) {
let currentErrorImg = $(e.target);
let standbyFaviconAttr = "standbyFavicon";
let standbyFavicon = currentErrorImg.attr(standbyFaviconAttr);
if(standbyFavicon != null) {
// 如果备用favicon使用
currentErrorImg.attr("src",standbyFavicon)
currentErrorImg.removeAttr(standbyFaviconAttr)
}else {
// 如果备用favicon直接使用加载失败图标base64
currentErrorImg.attr("src",loadErrorTagIcon)
}
}
}
// 隐藏文本显示视图
textView.css({
"display":"none"
})
// 让搜索结果显示
let matchResultDisplay = "block";
if(searchResultData.length < 1) matchResultDisplay="none";
matchResult.css({
"display":matchResultDisplay,
"overflow":"hidden"
})
// 将显示搜索的数据放入全局容器中
registry.searchData.searchData = searchData;
// 指令归位（置零）
registry.searchData.pos = 0;
}
registry.view.element.matchItems.on("click","li > a",function(e) {
let targetObj = e.target;
// 如果当前标签是svg标签，那委托给父节点
while ( targetObj != null && !/^(a|A)$/.test(targetObj.tagName)) {
targetObj = targetObj.parentNode
}
// 取消默认事件，全部都是手动操作
e.preventDefault();
// 取消冒泡
window.event? window.event.cancelBubble = true : e.stopPropagation();
// 设置为阅读模式
// $("#my_search_input").val(":read");
// 获取当前结果在搜索数组中的索引
let dataIndex = parseInt($(targetObj).attr("index"));
let dataVersion = parseInt($(targetObj).attr("version"));
let currentSearchDataVersion = registry.searchData.version;
let itemData = registry.searchData.getData()[dataIndex];
if(itemData == null || dataVersion != currentSearchDataVersion ) {
console.log("后备方案（没有找到了？"+(itemData == null)+",数据版本改变了？"+(dataVersion != currentSearchDataVersion)+")")
// 索引出现问题-启动后备方案-全局搜索
let title = $(targetObj).parent().find(".item_title").text();
let desc = $(targetObj).parent().find(".item_desc").text();
// 从全局数据中根据title与desc进行匹配
itemData = registry.searchData.findSearchDataItem(title,desc)
// 从历史数据中找，根据title与desc进行匹配
if(itemData == null) itemData = registry.searchData.findSearchDataItem(title,desc,SelectHistoryRecorder.history)
}
// 给选择的item加分，便于后面调整排序 (这里的idFun使用注册表中已经有的，也是我们确认item唯一的函数)
if(itemData != null) DataWeightScorer.select(itemData,registry.searchData.idFun);
// 记录选择的item项
SelectHistoryRecorder.select(itemData,registry.searchData.idFun);
// === 如果是简述搜索信息，那就取消a标签的默认跳转事件===
let hasVassal = $(targetObj).attr("vassal") != null;
// 初始化textView注册表中的对象
function showTextPage(title,desc,body) {
registry.view.textView.show(`标题：${title}
描述：${desc}
简述内容：
${md2html(body)} `)
}
if(hasVassal) {
showTextPage(itemData.title,"主项的相关/附加内容",itemData.vassal);
// 挂载一键code复制
codeCopyMount("#text_show");
return;
}else if(itemData.type == "script"){
// 是脚本，执行脚本
let callBeforeParse = new CallBeforeParse();
let jscript = ( itemData.resourceObj == null || itemData.resourceObj.script == null ) ?"function (obj) {alert('- _ - 脚本异常！')}":itemData.resourceObj.script;
// 调用里面的函数，传入注册表对象
// 打开网址函数
function open(url) {
let openUrl = url;
return {
simulator(operate = (click, roll, dimension) => {}) { // 模拟器
if(openUrl == null || operate == null || typeof operate != 'function') return;
let pageSimulatorScript = operate.toString();
addPageSimulatorScript(openUrl,pageSimulatorScript); // 保存模拟操作，模拟脚本将在指定时间内打开指定网址有效
window.open(openUrl); // 打开网址
return this;
}
}
}
let view = {
beforeCallback: null,
afterCallback: null,
mountBefore(handle) {
this.beforeCallback = handle;
return this;
},
mountAfter(handle) {
this.afterCallback = handle;
return this;
},
// mount是脚本项-脚本js调用
mount() {
// 看脚本js是否给beforeCallback ，如果有在此执行
if(this.beforeCallback != null) this.beforeCallback();
// 挂载MS_SCRIPT_ENV 实现系统脚本API到视图
registry.script.openSessionForMSSE();
// 挂载视图
let viewHtml = itemData.resourceObj['view:html'];
let viewCss = itemData.resourceObj['view:css'];
let viewJs = itemData.resourceObj['view:js'];
registry.view.textView.show(viewHtml,viewCss,viewJs);
// wait view complate alfter ...
waitViewRenderingComplete(()=>{
registry.script.tryRunTextViewHandler();
// 看脚本js是否给afterCallback ，如果有在此执行
if(this.afterCallback != null) this.afterCallback();
})
}
}
// 设置logo为运行图标
registry.view.logo.change("data:image/svg+xml;base64,PHN2ZyB2ZXJzaW9uPSIxLjIiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyIgdmlld0JveD0iMCAwIDM5IDM5IiB3aWR0aD0iMzkiIGhlaWdodD0iMzkiPgoJPHRpdGxlPuW+ruS/oeaIquWbvl8yMDIzMDgxODIzMDIxNzwvdGl0bGU+Cgk8ZGVmcz4KCQk8aW1hZ2UgIHdpZHRoPSIyMyIgaGVpZ2h0PSIyMyIgaWQ9ImltZzEiIGhyZWY9ImRhdGE6aW1hZ2UvcG5nO2Jhc2U2NCxpVkJPUncwS0dnb0FBQUFOU1VoRVVnQUFBQmNBQUFBWEFRTUFBQURhNUViakFBQUFBWE5TUjBJQjJja3Nmd0FBQUFOUVRGUkZ4MVJRaGlaMHV3QUFBQXhKUkVGVWVKeGpZS0FkQUFBQVhBQUJZNkd4Z1FBQUFBQkpSVTVFcmtKZ2dnPT0iLz4KCTwvZGVmcz4KCTxzdHlsZT4KCTwvc3R5bGU+Cgk8dXNlIGlkPSJCYWNrZ3JvdW5kIiBocmVmPSIjaW1nMSIgeD0iOCIgeT0iOCIvPgo8L3N2Zz4=")
try {
Function('obj',`(${jscript})(obj)`)({registry,cache,$,open,view})
} catch (error) {
setTimeout(()=>{alert("Ծ‸Ծ 你选择的是脚本项，而当前页面安全策略不允许此操作所依赖的函数！这种情况是极少数的，请换个页面试试！")},20)
console.logout("脚本执行失败！",error);
}
// logo图标还原
setTimeout(()=>{registry.view.logo.reset();},200)
return;
}else if(! isUrl(itemData.resource)) {
showTextPage(itemData.title,itemData.desc,itemData.resource)
return;
}
// 隐藏视图
registry.view.viewVisibilityController(false)
const initUrl = itemData.resource;//$(targetObj).attr("href"); // 不作改变的URL
let url = initUrl; // 进行修改，形成要跳转的真正url
let temNum = url.matchFetch(/\[\[[^\[\]]*\]\]/gm, function (matchStr,index) { // temNum是url中有几个 "[[...]]", 得到后，就已经得到解析了
let templateStr = matchStr;
// 使用全局的keyword, 构造出真正的keyword
let keyword = registry.searchData.keyword.split(":").reverse();
keyword.pop();
keyword = keyword.reverse().join(":").trim();
let parseAfterStr = matchStr.replace(/{keyword}/g,keyword).replace(/\[\[+|\]\]+/g,"");
url = url.replace(templateStr,parseAfterStr);
});
// 如果搜索的真正keyword为空字符串，则去掉模板跳转
if( registry.searchData.keyword.split(registry.searchData.subSearch.searchBoundary).length < 2
|| registry.searchData.keyword.split(registry.searchData.subSearch.searchBoundary)[1].trim() == "" ) {
url = registry.searchData.clearUrlSearchTemplate(initUrl);
}
// 跳转（url如果有模板，可能已经去掉模板，取决于是“搜索模式”）
window.open(url);
})
//registry.searchData.searchHandle = handler;
const refresh = debounce(handler, 300)
// 第一次触发 scroll 执行一次 fn，后续只有在停止滑动 1 秒后才执行函数 fn
searchInputDocument.on('input', refresh)
}
function ensureViewHide() {
// 隐藏视图
// 如果视图还没有初始化，直接退出
if (! registry.view.initialized) return;
// 如果正在查看查看“简讯”，先退出简讯
const nowMode = registry.view.seeNowMode();
if(nowMode === registry.view.modeEnum.SHOW_ITEM_DETAIL) {
// 让简讯隐藏
registry.view.element.textView.css({"display":"none"})
// 让搜索结果显示
registry.view.element.matchResult.css({ display:"block",overflow: "hidden" })
// 通知简讯back事件
registry.view.itemDetailBackAfterEventListener.forEach(listener=>listener())
return;
}
// 让视图隐藏
viewDocument.style.display = "none";
// 将输入框内容置空,在置空前将值备份，好让未好得及的操作它
registry.view.element.input.val("")
// 将之前搜索结果置空
registry.view.element.matchItems.html("")
// 隐藏文本显示视图
registry.view.element.textView.css({
"display":"none"
})
// 让搜索结果隐藏
registry.view.element.matchResult.css({
"display":"none"
})
// 视图隐藏-清理旧数据
registry.searchData.clearData();
// 触发视图隐藏事件
registry.view.viewHideEventAfterListener.forEach(fun=>fun());
}
function showView() {
// 让视图可见
viewDocument.style.display = "block";
//聚焦
registry.view.element.input.focus()
// 当输入框失去焦点时，隐藏视图
registry.view.element.input.blur(function() {
const isLogoButtonPressedRef = registry.view.logo.isLogoButtonPressedRef
if(isLogoButtonPressedRef.value) {
console.logout("隐藏跳过，因为isLogoButtonPressedRef")
return
};
setTimeout(function(){
const isDebuging = isInstructions("debug");
const isSearching = registry.searchData.searchEven.isSearching;
// 当前视图是否在展示数据，如搜索结果，简述内容？如果在展示不隐藏
let isWaitSearch = registry.view.seeNowMode() === registry.view.modeEnum.WAIT_SEARCH;
if(isDebuging || isSearching || !isWaitSearch || isLogoButtonPressedRef.value) {
console.logout("隐藏跳过，条件列表不满足！")
return
};
registry.view.viewVisibilityController(false);
},registry.view.delayedHideTime)
});
}
// 返回给外界控制视图显示与隐藏
return function (isSetViewVisibility) {
if (isSetViewVisibility) {
// 让视图可见 >>>
// 如果还没初始化先初始化 // 初始化数据 initData();
if (! registry.view.initialized) {
// 初始化视图
initView();
// 初始化数据
// initData();
}
// 让视图可见
showView();
} else {
// 隐藏视图 >>>
ensureViewHide();
}
}
})();
// 触发策略——快捷键
let useKeyTrigger = function (viewVisibilityController) {
let isFirstShow = true;
// 将视图与触发策略绑定
function showFun() {
// 让视图可见
viewVisibilityController(true);
// 触发视图首次显示事件
if(isFirstShow) {
for(let e of registry.view.viewFirstShowEventListener) e();
isFirstShow = false;
}
}
window.addEventListener('message', event => {
// console.log("父容器接收到了信息~~")
if(event.data == MY_SEARCH_SCRIPT_VIEW_SHOW_EVENT) {
showFun() // 接收显示呼出搜索框
}
});
triggerAndEvent("ctrl+alt+s", showFun)
triggerAndEvent("Escape", function () {
// 如果视图还没有初始化，就跳过
if(registry.view.viewDocument == null ) return;
// 让视图不可见
viewVisibilityController(false);
})
}
// 触发策略组
let trigger_group = [useKeyTrigger];
// 初始化入选的触发策略
(function () {
for (let trigger of trigger_group) {
trigger(registry.view.viewVisibilityController);
}
})();
// 打开视图进行配置
// 显示配置视图
// 是否显示进度 - 进度控制
function clearCache() {
cache.remove(registry.searchData.SEARCH_DATA_KEY);
// 如果处于debug模式，也清理其它的
if(isInstructions("debug")) {
cache.remove(registry.searchData.CACHE_FAVICON_SOURCE_KEY);
}
// 触发缓存被清理事件
for(let fun of registry.searchData.dataCacheRemoveEventListener) fun();
}
GM_registerMenuCommand("订阅管理",function() {
showConfigView();
});
GM_registerMenuCommand("清理缓存",function() {
clearCache();
});
function giveTagsStatus(tagsOfData,userUnfollowList) {
// 赋予tags一个是否选中状态
// 将 userUnfollowList 转为以key为userUnfollowList的item.name值是Item的方便检索
let userUnfollowMap = userUnfollowList.reduce(function(result, item) {
result[item] = '';
return result;
}, {});
tagsOfData.forEach(item=>{
if(userUnfollowMap[item.name] != null ) {
// 默认都是选中状态，如果item在userUnfollowList上将此tag状态改为未选中状态
item.status = 0;
}
})
return tagsOfData;
}
function showConfigView() {
// 剃除已转关注的，添加新关注的
function reshapeUnfollowList(userUnfollowList,userFollowList,newUserUnfollowList) {
// 剃除已转关注的
userUnfollowList = userUnfollowList.filter(item => !userFollowList.includes(item));
// 添加新关注的
userUnfollowList = userUnfollowList.concat(newUserUnfollowList.filter(item => !userUnfollowList.includes(item)));
return userUnfollowList;
}
if($("#subscribe_save")[0] != null) return;
// 显示视图
// 用户维护的取消关注标签列表
let userUnfollowList = cache.get(registry.searchData.USER_UNFOLLOW_LIST_CACHE_KEY)?? registry.searchData.USER_DEFAULT_UNFOLLOW;
// 当前数据所有的标签
let tagsOfData = cache.get(registry.searchData.DATA_ITEM_TAGS_CACHE_KEY);
// 使用 userUnfollowList 给 tagsOfData中的标签一个是否选中状态，在userUnfollowList中不选中，不在选中，添加一个属性到tagsOfData用boolean表达
tagsOfData = giveTagsStatus(tagsOfData,userUnfollowList);
// 生成多选框html
let tagsCheckboxHtml = "";
tagsOfData.forEach(item=>{
tagsCheckboxHtml += `
`
})
DivPage(`
#my-search-view {
width: 500px;
max-height: 100%;
max-width: 100%;
background: pink;
position: fixed;
right: 0px;
top: 0px;
z-index: 2147383656;
padding: 20px;
box-sizing: border-box;
border-radius: 14px;
text-align: left;
button {
cursor: pointer;
}
._topController {
width: 100%;
position: absolute;
top: 0px;
right: 0px;
text-align: right;
padding: 15px 15px 0px;
box-sizing: border-box;
* {
cursor: pointer;
}
#topController_close {
font-sise: 15px;
color: #e8221e;
}
}
.page {
.control_title {
margin: 10px 0px 5px;
font-size: 17px;
color: black;
}
}
.home {
.submitable {
color: #3CB371;
}
.tagsCheckBoxDiv > div {
width: 32%;
display: inline-block;
margin: 0px;
padding: 0px;
overflow: hidden;
text-overflow: ellipsis;
white-space: nowrap;
}
#all_subscribe {
width: 100%;
height: 150px;
box-sizing: border-box;
border: 4px solid #f5f5f5;
}
#subscribe_save {
margin-top: 20px;
border: none;
border-radius: 3px;
padding: 4px 17px;
cursor: pointer;
box-sizing: border-box;
background: #6161bb;
color: #fff;
}
.view-base-button {
background: #fff;
border: none;
font-size: 15px;
padding: 1px 10px;
cursor: pointer;
margin: 2px;
color: black;
}
._topController span {
color: #3CB371;
}
.home label {
font-size: 13px;
}
}
.tis-hub {
.logo-search {
display: flex;
flex-direction: column;
align-items: center;
img {
display: block;
width: 40px;
height: 40px;
}
.keyword {
display: flex;
font-size: 12px;
width: 70%;
margin-top: 5px;
input {
border: none;
padding: 0 6px;
min-width: 100px;
line-height: 25px;
height: 25px;
flex-grow: 1;
}
button {
padding: 0 12px;
border: none;
background: #f0f0f0;
line-height: 25px;
height: 25px;
}
}
}
.search-type {
display: flex;
padding: 10px 0;
label {
display: flex;
align-items: center;
margin-right: 20px;
font-size: 14px;
input {
padding: 0;
margin: 0 3px 0 0;
}
}
}
.result-list {
min-height: 300px;
padding-top: 15px;
.hub-tis {
display: flex;
justify-content: space-between;
margin-bottom: 12px;
align-items: center;
button {
font-size: 10px;
line-height: 22px;
height: 22px;
padding: 0 15px;
border-radius: 3px;
border: none;
}
.tis-info {
display: flex;
flex-direction: column;
.title {
font-size: 14px;
font-weight: bold;
color: rgb(103, 0, 0);
}
.describe {
font-size: 12px;
font-weight: 400;
display: block;
font-size: smaller;
margin: 0.5em 0px;
color: #333333;
}
}
}
}
}
}
`,`
X
订阅总览：
公共仓库：
关注标签：
订阅市场
`,function (selector,remove) {
let subscribe_text = selector("#all_subscribe");
let subscribe_save = selector("#subscribe_save");
let topController_close = selector("#topController_close");
let openTisHub = selector("#openTisHub");
let tisHubLink = "https://github.com/My-Search/TisHub/issues";
let pushTis = selector("#pushTis");
let commitableTisList = null;
let clearToken = selector("#clearToken");
let mySearchView = selector("#my-search-view");
let currentPage = setPage(); // 默认显示的是home页
// 刷新页
function setPage(page = "home") {
$(mySearchView).find('.page').hide().filter(`.${page}`).show();
}
setPage("home");
// 刷新视图状态
async function refreshViewState() {
// 更新token状态
$(clearToken).css({"display":GithubAPI.getToken() == null?"none":"inline-block"})
// 更新可提交数
let tisList = await TisHub.getTisHubAllTis();
if(tisList != null && tisList.length != 0) {
commitableTisList = TisHub.tisFilter(subscribe_text.value,tisList)??[]
$(pushTis).find("span").text(commitableTisList.length);
}
}
// 初始化subscribe_text的值
subscribe_text.value = getSubscribe();
// 初始化其它状态,通过调用refreshViewState()
refreshViewState();
// 当SubscribeText多行输入框内容发生改变时，刷新更新可提交数,通过调用refreshViewState()
let refreshSubscribeText = debounce(()=>{refreshViewState() }, 300)
subscribe_text.oninput = ()=>{refreshSubscribeText();}
// 保存
function configViewClose() {
remove();
}
// 点击保存时
subscribe_save.onclick=function() {
// 保存用户选择的关注标签（维护数据）
// 获取所有多选框元素
var checkboxes = selector(".tagsCheckBoxDiv input",true);
// 初始化已选中和未选中的数组
var userFollowList = [];
var newUserUnfollowList = [];
// 遍历多选框元素，将选中的元素的value值添加到checkedValues数组中，
// 未选中的元素的value值添加到uncheckedValues数组中
for (var i = 0; i < checkboxes.length; i++) {
if (checkboxes[i].checked) {
userFollowList.push(checkboxes[i].value);
} else {
newUserUnfollowList.push(checkboxes[i].value);
}
}
// 剃除已转关注的，添加新关注的
newUserUnfollowList = reshapeUnfollowList( userUnfollowList,userFollowList,newUserUnfollowList);
cache.set(registry.searchData.USER_UNFOLLOW_LIST_CACHE_KEY,newUserUnfollowList);
// 保存到对象
let allSubscribe = subscribe_text.value;
let validCount = editSubscribe(allSubscribe);
// 清除视图
configViewClose();
// 清理缓存，让数据重新加载
clearCache();
alert("保存配置成功！有效订阅数："+validCount);
}
// 打开TitHub
openTisHub.onclick = function() {
// window.open(tisHubLink, "_blank");
setPage("tis-hub");
}
// push到TisHub公共仓库中
pushTis.onclick =async function () {
if(! confirm("是否确认要提交到TisHub公共仓库？")) return;
if(commitableTisList == null || commitableTisList.length == 0) {
alert("经过与TisHub中订阅的比较，本地没有可提交的订阅！")
return;
}
if(GithubAPI.getToken(true) == null) {
alert("获取token失败，无法继续！");
return;
}
// 组装提交的body
let body = (()=>{
let _body = "";
for(let tis of commitableTisList) _body+=tis;
return _body;
})();
if ( body == "") return;
let userInfo = await GithubAPI.setToken().getUserInfo();
if(userInfo == null) {
alert("提交异常，请检查网络或提交的Token信息！")
return;
}
GithubAPI.commitIssues({
"title": userInfo.name+"的订阅",
"body": body
}).then(response=>{
refreshViewState();
alert("提交成功(issues)！感谢您的参与，脚本因你而更加精彩。")
}).catch(error=>alert("提交失败~"))
}
// 清理token
clearToken.onclick = function(){
GithubAPI.clearToken(); // 清理token
refreshViewState(); // 刷新视图变量
};
// 关闭
$(topController_close).click(configViewClose)
// 点击搜索tis-hub
let installedList = cache.get(registry.searchData.USE_INSTALL_TISHUB_CACHE_KEY) || []; // [ {name: "官方订阅",describe: "这是官方订阅...", body: "