邀您一起看：墨雨云间

海阔视界规则分享，当前分享的是：二级页面详情￥page_detail￥墨雨云间@@{"data":"{\"associatedModelsMapForJoinTable\":{},\"associatedModelsMapWithFK\":{},\"associatedModelsMapWithoutFK\":{},\"fieldsToSetToDefault\":[],\"gmtModified\":0,\"id\":0,\"last_chapter_rule\":\"\",\"listToClearAssociatedFK\":[],\"listToClearSelfFK\":[],\"pageList\":[{\"col_type\":\"movie_3\",\"name\":\"搜索建议\",\"path\":\"searchHome\",\"rule\":\"function 搜索建议(arr, pic) {\\n    var rule_name = MY_RULE.title;\\n    var img = getItem(rule_name + '建议海报');\\n    if(img=='undefined') img='https://vkceyugu.cdn.bspapp.com/VKCEYUGU-80953a7e-7873-4802-9cc1-ea559e692799/feaf84ad-6267-4dc1-b743-a67389eddf75.jpg';\\n    var name = getItem(rule_name + '建议片名');\\n    if (pic == '海报开') {\\n        arr.push({\\n            img: img,\\n            col_type: 'card_pic_1',\\n            extra: {\\n                id: 'img'\\n            },\\n            desc: \\\"0\\\",\\n            url: 'hiker://search?s=' + name + '&rule=' + rule_name,\\n        })\\n    }\\n    arr.push({\\n        url: '\\\"hiker://search?s=\\\" + input + \\\"&rule=\\\"+MY_RULE.title ',\\n        desc: \\\"搜索…\\\",\\n        col_type: \\\"input\\\",\\n        extra: {\\n            onChange: $.toString((rule_name) => {\\n                let sug = config.sug || [];\\n                for (let i in sug) {\\n                    deleteItem(sug[i]);\\n                }\\n                if (input == '') deleteItemByCls(\\\"#s\\\");\\n                if (input) {\\n                    if (input == '清除搜索记录') writeFile('hiker://files/cache/搜索记录.json', '');\\n                    initConfig({\\n                        sug: [input]\\n                    });\\n                    http.fetch('https://suggest.video.iqiyi.com/?if=mobile&key=' + input, {}).success(data => {\\n                        var gg = JSON.parse(data).data;\\n                       \\n                        putVar('建议数据', gg)\\n                        var dd = gg.find((e) => (e.picture_url))\\n                        if (dd) {\\n                            setItem(rule_name + '建议海报', dd.picture_url)\\n                            setItem(rule_name + '建议片名', dd.name)\\n                            //log(dd.word)\\n                            updateItem('img', {\\n                                img: dd.picture_url,\\n                                url: 'hiker://search?s=' + dd.name + '&rule=' + rule_name,\\n                                extra: {\\n                                    id: 'img'\\n                                }\\n                            })\\n                        }\\n                    }).error(msg => log(msg.toString())).start(log(2))\\n                    var gg = JSON.parse(getVar('建议数据'));\\n                    deleteItemByCls(\\\"#s\\\");\\n                    for (let i in gg) {\\n                        var nn = gg[i].name;\\n                        addItemAfter(\\\"12input\\\", {\\n                            title: nn,\\n                            url: $(\\\"#noLoading#\\\").lazyRule((nn, rule_name) => {\\n                                let localData = request('hiker://files/cache/搜索记录.json');\\n                                if (!localData) localData = \\\"[]\\\";\\n                                let lishi = JSON.parse(localData);\\n                                let ccc = lishi.indexOf(nn);\\n                                if (ccc > -1) {\\n                                    lishi.splice(ccc, 1)\\n                                };\\n                                lishi.push(nn);\\n                                lishi = lishi.slice(-$.his);\\n                                writeFile('hiker://files/cache/搜索记录.json', JSON.stringify(lishi));\\n                                return 'hiker://search?s=' + nn + '&rule=' + rule_name\\n                            }, nn, rule_name),\\n                            col_type: \\\"text_1\\\",\\n                            extra: {\\n                                id: input,\\n                                cls: \\\"#s\\\"\\n                            }\\n                        });\\n                    }\\n                } else {\\n                    //默认\\n                    let localData = request('hiker://files/cache/搜索记录.json');\\n                    if (!localData) localData = \\\"[]\\\";\\n                    let lishi = JSON.parse(localData).slice(-$.his);\\n                    config.sug = lishi;\\n                    initConfig({\\n                        sug: config.sug\\n                    });\\n                    \\n                    if(config.sug.length>0)\\n                    {\\n                    addItemAfter(\\\"12input\\\", {\\n                            title: '搜索历史记录:'+config.sug.length+'条',\\n                            desc:'点此清除搜索记录',\\n                            url: $('确定要清空搜索记录吗？').confirm(()=>{\\n                                writeFile('hiker://files/cache/搜索记录.json', '');\\n                    initConfig({\\n                        sug: []\\n                    });\\n                    refreshPage()\\n                            }),\\n                            col_type: \\\"text_1\\\",\\n                            extra: {\\n                                id: 'his',\\n                                cls: \\\"#s\\\"\\n                            }\\n                        });\\n                    }\\n                    for (let it of config.sug) {\\n                        addItemAfter(\\\"12input\\\", {\\n                            title: it,\\n                            url: 'hiker://search?s=' + it + '&rule=' + rule_name,\\n                            col_type: \\\"flex_button\\\",\\n                            extra: {\\n                                id: it,\\n                                cls: \\\"#s\\\"\\n                            }\\n                        });\\n                    }\\n                    \\n                }\\n            }, rule_name),\\n            titleVisible: false,\\n            id: \\\"12input\\\"\\n        }\\n    });\\n    for (let i = 0; i < 2; i++) {\\n        arr.push({\\n            col_type: \\\"blank_block\\\"\\n        })\\n    }\\n    //setResult(d)\\n}\\n$.exports={\\n    搜索建议\\n}\\n//搜索建议(d, '海报开')\"}],\"saved\":false,\"title\":\"搜片.dr\",\"version\":0,\"url\":\"https://dyxs31.com/show-267489/?url=搜片.com#immersiveTheme#;get;UTF-8;{User-Agent@Mozilla/5.0 (Linux；； Android 11；； Mi 10 Pro) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.152 Mobile Safari/537.36}\",\"col_type\":\"movie_1\",\"find_rule\":\"js:\\nrequire(config.自动匹配);\\n//香免();\\nvar lazy=$('#noLoading#').lazyRule(()=>{\\n    return  'video://'+input\\n})\\n//自动二级();\\n自动二级(lazy);\",\"group\":\"#️⃣道长DR\",\"ua\":\"mobile\",\"preRule\":\"require('https://gitcode.net/qq_32394351/dr/-/raw/master/js/预处理.js');\\n$.extend({\\n    his:30\\n});\",\"pages\":\"[{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"搜索建议\\\",\\\"path\\\":\\\"searchHome\\\",\\\"rule\\\":\\\"function 搜索建议(arr, pic) {\\\\n    var rule_name = MY_RULE.title;\\\\n    var img = getItem(rule_name + '建议海报');\\\\n    if(img=='undefined') img='https://vkceyugu.cdn.bspapp.com/VKCEYUGU-80953a7e-7873-4802-9cc1-ea559e692799/feaf84ad-6267-4dc1-b743-a67389eddf75.jpg';\\\\n    var name = getItem(rule_name + '建议片名');\\\\n    if (pic == '海报开') {\\\\n        arr.push({\\\\n            img: img,\\\\n            col_type: 'card_pic_1',\\\\n            extra: {\\\\n                id: 'img'\\\\n            },\\\\n            desc: \\\\\\\"0\\\\\\\",\\\\n            url: 'hiker://search?s=' + name + '&rule=' + rule_name,\\\\n        })\\\\n    }\\\\n    arr.push({\\\\n        url: '\\\\\\\"hiker://search?s=\\\\\\\" + input + \\\\\\\"&rule=\\\\\\\"+MY_RULE.title ',\\\\n        desc: \\\\\\\"搜索…\\\\\\\",\\\\n        col_type: \\\\\\\"input\\\\\\\",\\\\n        extra: {\\\\n            onChange: $.toString((rule_name) => {\\\\n                let sug = config.sug || [];\\\\n                for (let i in sug) {\\\\n                    deleteItem(sug[i]);\\\\n                }\\\\n                if (input == '') deleteItemByCls(\\\\\\\"#s\\\\\\\");\\\\n                if (input) {\\\\n                    if (input == '清除搜索记录') writeFile('hiker://files/cache/搜索记录.json', '');\\\\n                    initConfig({\\\\n                        sug: [input]\\\\n                    });\\\\n                    http.fetch('https://suggest.video.iqiyi.com/?if=mobile&key=' + input, {}).success(data => {\\\\n                        var gg = JSON.parse(data).data;\\\\n                       \\\\n                        putVar('建议数据', gg)\\\\n                        var dd = gg.find((e) => (e.picture_url))\\\\n                        if (dd) {\\\\n                            setItem(rule_name + '建议海报', dd.picture_url)\\\\n                            setItem(rule_name + '建议片名', dd.name)\\\\n                            //log(dd.word)\\\\n                            updateItem('img', {\\\\n                                img: dd.picture_url,\\\\n                                url: 'hiker://search?s=' + dd.name + '&rule=' + rule_name,\\\\n                                extra: {\\\\n                                    id: 'img'\\\\n                                }\\\\n                            })\\\\n                        }\\\\n                    }).error(msg => log(msg.toString())).start(log(2))\\\\n                    var gg = JSON.parse(getVar('建议数据'));\\\\n                    deleteItemByCls(\\\\\\\"#s\\\\\\\");\\\\n                    for (let i in gg) {\\\\n                        var nn = gg[i].name;\\\\n                        addItemAfter(\\\\\\\"12input\\\\\\\", {\\\\n                            title: nn,\\\\n                            url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((nn, rule_name) => {\\\\n                                let localData = request('hiker://files/cache/搜索记录.json');\\\\n                                if (!localData) localData = \\\\\\\"[]\\\\\\\";\\\\n                                let lishi = JSON.parse(localData);\\\\n                                let ccc = lishi.indexOf(nn);\\\\n                                if (ccc > -1) {\\\\n                                    lishi.splice(ccc, 1)\\\\n                                };\\\\n                                lishi.push(nn);\\\\n                                lishi = lishi.slice(-$.his);\\\\n                                writeFile('hiker://files/cache/搜索记录.json', JSON.stringify(lishi));\\\\n                                return 'hiker://search?s=' + nn + '&rule=' + rule_name\\\\n                            }, nn, rule_name),\\\\n                            col_type: \\\\\\\"text_1\\\\\\\",\\\\n                            extra: {\\\\n                                id: input,\\\\n                                cls: \\\\\\\"#s\\\\\\\"\\\\n                            }\\\\n                        });\\\\n                    }\\\\n                } else {\\\\n                    //默认\\\\n                    let localData = request('hiker://files/cache/搜索记录.json');\\\\n                    if (!localData) localData = \\\\\\\"[]\\\\\\\";\\\\n                    let lishi = JSON.parse(localData).slice(-$.his);\\\\n                    config.sug = lishi;\\\\n                    initConfig({\\\\n                        sug: config.sug\\\\n                    });\\\\n                    \\\\n                    if(config.sug.length>0)\\\\n                    {\\\\n                    addItemAfter(\\\\\\\"12input\\\\\\\", {\\\\n                            title: '搜索历史记录:'+config.sug.length+'条',\\\\n                            desc:'点此清除搜索记录',\\\\n                            url: $('确定要清空搜索记录吗？').confirm(()=>{\\\\n                                writeFile('hiker://files/cache/搜索记录.json', '');\\\\n                    initConfig({\\\\n                        sug: []\\\\n                    });\\\\n                    refreshPage()\\\\n                            }),\\\\n                            col_type: \\\\\\\"text_1\\\\\\\",\\\\n                            extra: {\\\\n                                id: 'his',\\\\n                                cls: \\\\\\\"#s\\\\\\\"\\\\n                            }\\\\n                        });\\\\n                    }\\\\n                    for (let it of config.sug) {\\\\n                        addItemAfter(\\\\\\\"12input\\\\\\\", {\\\\n                            title: it,\\\\n                            url: 'hiker://search?s=' + it + '&rule=' + rule_name,\\\\n                            col_type: \\\\\\\"flex_button\\\\\\\",\\\\n                            extra: {\\\\n                                id: it,\\\\n                                cls: \\\\\\\"#s\\\\\\\"\\\\n                            }\\\\n                        });\\\\n                    }\\\\n                    \\\\n                }\\\\n            }, rule_name),\\\\n            titleVisible: false,\\\\n            id: \\\\\\\"12input\\\\\\\"\\\\n        }\\\\n    });\\\\n    for (let i = 0; i < 2; i++) {\\\\n        arr.push({\\\\n            col_type: \\\\\\\"blank_block\\\\\\\"\\\\n        })\\\\n    }\\\\n    //setResult(d)\\\\n}\\\\n$.exports={\\\\n    搜索建议\\\\n}\\\\n//搜索建议(d, '海报开')\\\"}]\"}","picUrl":"https://pic1.imgyzzy.com/upload/vod/2024-06-02/17172986941.jpg@Referer=","title":"墨雨云间"}