Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- 海阔视界规则分享，当前分享的是：小程序￥home_rule_v2￥base64://@哔咔漫画@{"last_chapter_rule":"","title":"哔咔漫画","author":"TyrantGenesis","url":"hiker://empty$$fypage","version":3,"col_type":"movie_3","class_name":"","type":"other","class_url":"","area_name":"","area_url":"","sort_name":"","year_name":"","sort_url":"","year_url":"","find_rule":"js:\n$.require('hiker://page/picacg').baseParse();","search_url":"","group":"漫画","searchFind":"","detail_col_type":"movie_1","detail_find_rule":"","sdetail_col_type":"movie_1","sdetail_find_rule":"","ua":"pc","preRule":"","pages":"[{\"col_type\":\"movie_3\",\"name\":\"picacg\",\"path\":\"picacg\",\"rule\":\"const picacg = {\\n    // BaseUrl: \\\"https://picaapi.picacomic.com/\\\",\\n    BaseUrl: \\\"http://172.67.222.24/\\\",\\n    empty: 'hiker://empty',\\n    picacg_path: \\\"hiker://files/rules/js/TyrantGenesis_哔咔设置.js\\\",\\n    searchHistory: \\\"hiker://files/rules/js/TyrantGenesis_哔咔搜索历史.js\\\",\\n    apiKey: \\\"C69BAF41DA5ABD1FFEDC6D2FEA56B\\\",\\n    nonce: \\\"b1ab87b4800d4d4590a11701b8551afa\\\",\\n    secretKey: \\\"~d}$Q7$eIni=V)9\\\\\\\\RK/P.RM4;9[7|@/CA}b~OW!3?EV`:<>M7pddUBL5n|0/*Cn\\\",\\n    d: [],\\n    data: {\\n        rankTT: getItem('rankTT', 'H24'),\\n        sort: getItem('sort', 'ua'),\\n        searchValue: getItem('searchValue', ''),\\n        searchHistoryShowStatus: getItem('searchHistoryShowStatus', '0'),\\n        infoTab: getItem('infoTab', '1'),\\n        infoReverse: getItem('infoReverse', '1'),\\n    },\\n    share_account: {\\n        name: 'hiker_share',\\n        passwd: 'hiker_share_12345678'\\n    },\\n    defaultConfig: {\\n        searchHistoryMax: 100,\\n        searchHistoryShowLimit: 20,\\n    },\\n    images: [],\\n    episodes: [],\\n    headers: {\\n        \\\"accept\\\":            \\\"application/vnd.picacomic.com.v1+json\\\",\\n        \\\"app-channel\\\":       \\\"2\\\",\\n        \\\"time\\\":              (new Date().getTime()/1000).toFixed(0),\\n        \\\"app-version\\\":       \\\"2.2.1.2.3.3\\\",\\n        \\\"app-uuid\\\":          \\\"defaultUuid\\\",\\n        \\\"app-platform\\\":      \\\"android\\\",\\n        \\\"app-build-version\\\": \\\"44\\\",\\n        \\\"Content-Type\\\":      \\\"application/json; charset=UTF-8\\\",\\n        \\\"User-Agent\\\":        \\\"okhttp/3.8.1\\\",\\n        \\\"image-quality\\\":     \\\"original\\\",\\n        \\\"Host\\\":              \\\"picaapi.picacomic.com\\\",\\n    },\\n    encrypt: (url, ts, method) => {\\n        eval(getCryptoJS())\\n        let raw = url.replace(picacg.BaseUrl, \\\"\\\") + ts + picacg.nonce + method + picacg.apiKey\\n        raw = raw.toLocaleLowerCase()\\n        return CryptoJS.HmacSHA256(raw, picacg.secretKey).toString(CryptoJS.enc.Hex)\\n    },\\n    httpRequest: (path, method, data) => {\\n        let responseJson\\n        const request_url = picacg.BaseUrl + path\\n        let headers = picacg.headers\\n        headers['api-key'] = picacg.apiKey\\n        headers.nonce = picacg.nonce\\n        headers.signature = picacg.encrypt(request_url, headers.time, method)\\n        try {\\n            if (fileExist(picacg.picacg_path)) headers.authorization = fetch(picacg.picacg_path).split('\\\\n')[2]\\n        } catch (e) {\\n            writeFile(picacg.picacg_path, '')\\n            toast('账号异常,请重新登录')\\n            refreshPage(false)\\n        }\\n\\n        responseJson = method === 'GET' ? fetch(request_url, {headers: headers}) : fetch(request_url, {headers: headers, method: method, body: data})\\n\\n        const response = JSON.parse(responseJson)\\n\\n        // 自动登录\\n        if (response.code === 401 && response.error === '1005') {\\n            let email, password\\n            try {\\n                if (fileExist(picacg.picacg_path)) {\\n                    email = fetch(picacg.picacg_path).split('\\\\n')[0]\\n                    password = fetch(picacg.picacg_path).split('\\\\n')[1]\\n                }\\n            } catch (e) {\\n                writeFile(picacg.picacg_path, '')\\n                toast('账号异常,请重新登录')\\n                refreshPage(true)\\n            }\\n            if (! email || ! password) {\\n                writeFile(picacg.picacg_path, '')\\n                toast('账号异常,请重新登录')\\n                refreshPage(true)\\n            } else {\\n                const autoLoginResponse = picacg.post('auth/sign-in', {\\n                    email: email,\\n                    password: password,\\n                })\\n                if (autoLoginResponse.code === 400) {\\n                    return 'toast://'+ (autoLoginResponse.detail || autoLoginResponse.message)\\n                } else {\\n                    const setting = email + '\\\\n' + password + '\\\\n' +autoLoginResponse.data.token\\n                    writeFile(picacg.picacg_path, setting)\\n                    refreshPage(true)\\n                }\\n            }\\n        }\\n        return response\\n    },\\n    get: path => picacg.httpRequest(path, 'GET', ''),\\n    post: (path, data) => picacg.httpRequest(path, 'POST', data),\\n    baseParse: () => {\\n        if (! fileExist(picacg.picacg_path) || ! fetch(picacg.picacg_path)) {\\n            picacg.d.push({\\n                title: '登录哔咔',\\n                url: $(picacg.empty).rule(() => {\\n                    const picacg = $.require('hiker://page/picacg')\\n                    picacg.login()\\n                    setResult(picacg.d);\\n                }),\\n                col_type: 'text_center_1'\\n            })\\n            picacg.d.push({\\n                title: '注册哔咔',\\n                url: $(picacg.empty).rule(() => {\\n                    const picacg = $.require('hiker://page/picacg')\\n                    picacg.register()\\n                    setResult(picacg.d);\\n                }),\\n                col_type: 'text_center_1'\\n            })\\n            picacg.d.push({\\n                title: '共享账号登录',\\n                url: $(picacg.empty).lazyRule(() => {\\n                    const picacg = $.require('hiker://page/picacg')\\n                    return picacg.shareLogin()\\n                }),\\n                col_type: 'text_center_1'\\n            })\\n        } else {\\n            try {\\n                const userInfo = picacg.get('users/profile').data.user\\n\\n                picacg.d.push({\\n                    title: '用户『'+userInfo.name+'』 # 个人中心',\\n                    pic_url: 'https://git.tyrantg.com/tyrantgenesis/hikerViewRules/raw/master/assets/images/pica.jpg',\\n                    url: $(picacg.empty).rule(() => {\\n                        const picacg = $.require('hiker://page/picacg')\\n                        picacg.settingPage()\\n                        setResult(picacg.d)\\n                    }),\\n                    col_type: 'avatar',\\n                })\\n            } catch (e) {}\\n\\n            picacg.d.push({\\n                url: $(picacg.empty+\\\"#fullTheme#$$fypage\\\").rule(() => {\\n                    const picacg = $.require('hiker://page/picacg')\\n                    picacg.getSearch()\\n                    setResult(picacg.d)\\n                }),\\n                title: '请输入关键词',\\n                col_type: \\\"icon_1_search\\\",\\n            })\\n            picacg.d.push({\\n                title: '排行榜',\\n                url: $(picacg.empty+\\\"#fullTheme#\\\").rule(() => {\\n                    const picacg = $.require('hiker://page/picacg')\\n                    picacg.getRanking()\\n                    setResult(picacg.d)\\n                }),\\n                col_type: 'text_3',\\n            })\\n            picacg.d.push({\\n                title: '随机本子',\\n                url: $(picacg.empty+\\\"#fullTheme#$$fypage\\\").rule(() => {\\n                    const picacg = $.require('hiker://page/picacg')\\n                    picacg.getRandom()\\n                    setResult(picacg.d)\\n                }),\\n                col_type: 'text_3',\\n            })\\n            picacg.d.push({\\n                title: '我的收藏',\\n                url: $(picacg.empty+\\\"#fullTheme#$$fypage\\\").rule(() => {\\n                    const picacg = $.require('hiker://page/picacg')\\n                    picacg.getFavourite()\\n                    setResult(picacg.d)\\n                }),\\n                col_type: 'text_3',\\n            })\\n            picacg.d.push({\\n                col_type: 'line_blank'\\n            })\\n            picacg.getCategories()\\n        }\\n\\n        setResult(picacg.d);\\n    },\\n    login: () => {\\n        picacg.d.push({\\n            desc: '请输入用户名',\\n            col_type: 'input',\\n            extra: {\\n                titleVisible: false,\\n                onChange: $.toString(() => {\\n                    if (input) setItem('email', input)\\n                })\\n            }\\n        })\\n        picacg.d.push({\\n            desc: '请输入密码',\\n            col_type: 'input',\\n            extra: {\\n                titleVisible: false,\\n                onChange: $.toString(() => {\\n                    if (input) setItem('password', input)\\n                })\\n            }\\n        })\\n        picacg.d.push({\\n            title: '登录',\\n            url: $(picacg.empty).lazyRule(() => {\\n                const picacg = $.require('hiker://page/picacg')\\n                const response = picacg.post('auth/sign-in', {\\n                    email: getItem('email', ''),\\n                    password: getItem('password', ''),\\n                })\\n                if (response.code === 400) {\\n                    return 'toast://'+ (response.detail || response.message)\\n                } else {\\n                    const setting = getItem('email', '') + '\\\\n' + getItem('password', '') + '\\\\n' +response.data.token\\n                    writeFile(picacg.picacg_path, setting)\\n                    toast('登录成功')\\n                    back(true)\\n                    return picacg.empty\\n                }\\n            }),\\n            col_type: 'text_center_1',\\n            extra: {\\n                lineVisible: false,\\n            }\\n        })\\n\\n    },\\n    shareLogin: () => {\\n        const response = picacg.post('auth/sign-in', {\\n            email: picacg.share_account.name,\\n            password: picacg.share_account.passwd,\\n        })\\n        if (response.code === 400) {\\n            return 'toast://'+ (response.detail || response.message)\\n        } else {\\n            const setting = getItem('email', '') + '\\\\n' + getItem('password', '') + '\\\\n' +response.data.token\\n            writeFile(picacg.picacg_path, setting)\\n            refreshPage(false)\\n            return \\\"toast://登录成功\\\"\\n        }\\n    },\\n    register: () => {\\n        picacg.d.push({\\n            desc: '请输入昵称',\\n            col_type: 'input',\\n            extra: {\\n                titleVisible: false,\\n                onChange: $.toString(() => {\\n                    if (input) setItem('name', input)\\n                })\\n            }\\n        })\\n        picacg.d.push({\\n            desc: '请输入用户名',\\n            col_type: 'input',\\n            extra: {\\n                titleVisible: false,\\n                onChange: $.toString(() => {\\n                    if (input) setItem('email', input)\\n                })\\n            }\\n        })\\n        picacg.d.push({\\n            desc: '请输入密码',\\n            col_type: 'input',\\n            extra: {\\n                titleVisible: false,\\n                onChange: $.toString(() => {\\n                    if (input) setItem('password', input)\\n                })\\n            }\\n        })\\n        picacg.d.push({\\n            title: '注册',\\n            url: $(picacg.empty).lazyRule(() => {\\n                const picacg = $.require('hiker://page/picacg')\\n                const response = picacg.post('auth/register', {\\n                    email: getItem('email', ''),\\n                    password: getItem('password', ''),\\n                    name: getItem('name', ''),\\n                    birthday: '1970-01-01',\\n                    gender: 'f',\\n                    question1: 'question1',\\n                    question2: 'question2',\\n                    question3: 'question3',\\n                    answer1: 'answer1',\\n                    answer2: 'answer2',\\n                    answer3: 'answer3',\\n                })\\n\\n                if (response.code === 400) {\\n                    return 'toast://'+ (response.detail || response.message)\\n                } else {\\n                    const loginResponse = picacg.post('auth/sign-in', {\\n                        email: getItem('email', ''),\\n                        password: getItem('password', ''),\\n                    })\\n                    const setting = getItem('email', '') + '\\\\n' + getItem('password', '') + '\\\\n' +loginResponse.data.token\\n                    writeFile(picacg.picacg_path, setting)\\n                    toast('注册成功，已自动登录')\\n                    back(true)\\n                    return picacg.empty\\n                }\\n            }),\\n            col_type: 'text_center_1',\\n            extra: {\\n                lineVisible: false,\\n            }\\n        })\\n    },\\n    getSearch: () => {\\n        addListener('onClose', $.toString(() => {\\n            clearItem('sort')\\n            clearItem('searchValue')\\n            clearItem('searchHistoryShowStatus')\\n        }))\\n\\n        const page = MY_URL.split('$$')[1]\\n\\n        if (parseInt(page) === 1) {\\n            picacg.d.push({\\n                title: '搜索',\\n                url: $.toString(() => {\\n                    const picacg = $.require('hiker://page/picacg')\\n                    picacg.setSearchHistory(input)\\n                    setItem('searchValue', input)\\n                    refreshPage(false)\\n                    return \\\"hiker://empty\\\"\\n                }),\\n                desc: '请输入关键词',\\n                col_type: 'input',\\n                extra: {\\n                    defaultValue: picacg.data.searchValue,\\n                    onChange: $.toString(() => {\\n                        if (getItem('searchValue', '') && ! input) {\\n                            clearItem('searchValue')\\n                            clearItem('searchHistoryShowStatus')\\n                            refreshPage(false)\\n                            return \\\"hiker://empty\\\"\\n                        }\\n                    })\\n                }\\n            })\\n\\n            if (! picacg.data.searchValue) {\\n                if (fileExist(picacg.searchHistory) && fetch(picacg.searchHistory)) {\\n                    const searchHistory = fetch(picacg.searchHistory).split('||').filter(item => item)\\n                    picacg.d.push({\\n                        title: '搜索记录：',\\n                        url: picacg.empty,\\n                        col_type: 'text_1',\\n                        extra: {\\n                            lineVisible: false\\n                        },\\n                    })\\n\\n                    let picacgConfig = picacg.defaultConfig\\n                    searchHistory.forEach((history, index) => {\\n                        if (picacg.data.searchHistoryShowStatus === '1' || (picacg.data.searchHistoryShowStatus === '0' && picacgConfig.searchHistoryShowLimit - index >= 1)) {\\n                            picacg.d.push({\\n                                title: history,\\n                                url: $(picacg.empty).lazyRule(history => {\\n                                    const picacg = $.require('hiker://page/picacg')\\n                                    picacg.setSearchHistory(history)\\n                                    setItem('searchValue', history)\\n                                    refreshPage(false)\\n                                    return \\\"hiker://empty\\\"\\n                                }, history),\\n                                col_type: 'flex_button'\\n                            })\\n                        }\\n                    })\\n\\n                    picacg.d.push({\\n                        title: picacg.data.searchHistoryShowStatus === '1' ? '折叠记录' : '展开记录',\\n                        url: $(picacg.empty).lazyRule(params => {\\n                            setItem('searchHistoryShowStatus', params.status ? '0' : '1')\\n                            refreshPage(true)\\n                            return \\\"hiker://empty\\\"\\n                        }, {\\n                            status: picacg.data.searchHistoryShowStatus === '1'\\n                        }),\\n                        col_type: 'text_2',\\n                    })\\n                    picacg.d.push({\\n                        title: '清除记录',\\n                        url: $(picacg.empty).lazyRule(params => {\\n                            writeFile(params.filename, '')\\n                            refreshPage(true)\\n                            return \\\"hiker://empty\\\"\\n                        }, {\\n                            filename: picacg.searchHistory\\n                        }),\\n                        col_type: 'text_2',\\n                    })\\n                }\\n\\n                const hot_data = picacg.get('keywords')\\n                picacg.d.push({\\n                    col_type: 'line_blank'\\n                })\\n                picacg.d.push({\\n                    title: '热门搜索：',\\n                    url: picacg.empty,\\n                    col_type: 'text_1',\\n                    extra: {\\n                        lineVisible: false\\n                    },\\n                })\\n                hot_data.data.keywords.forEach(hot => {\\n                    picacg.d.push({\\n                        title: hot,\\n                        url: $(picacg.empty).lazyRule(hot => {\\n                            const picacg = $.require('hiker://page/picacg')\\n                            picacg.setSearchHistory(hot)\\n                            setItem('searchValue', hot)\\n                            refreshPage(false)\\n                            return \\\"hiker://empty\\\"\\n                        }, hot),\\n                        col_type: 'flex_button'\\n                    })\\n                })\\n            } else {\\n                picacg.makeSort()\\n            }\\n        }\\n\\n        picacg.getSearchResult(page, '')\\n    },\\n    getSearchResult: (page, value) => {\\n        const searchValue = value ? value : picacg.data.searchValue\\n        if (searchValue) {\\n            const response = picacg.post('comics/advanced-search?page='+page, {\\n                keyword: searchValue,\\n                sort: picacg.data.sort,\\n            })\\n            response.data.comics.docs.forEach(comic => {\\n                picacg.d.push({\\n                    title: comic.title,\\n                    desc: comic.author,\\n                    pic_url: /*comic.thumb.fileServer+*/'https://storage.wikawika.xyz/static/'+comic.thumb.path,\\n                    url: $(picacg.empty+'#immersiveTheme##noHistory#$$fypage').rule((id) => {\\n                        const picacg = $.require('hiker://page/picacg')\\n                        picacg.getInfo(id)\\n                        setResult(picacg.d);\\n                    }, comic._id),\\n                    col_type: 'movie_3'\\n                })\\n            })\\n        }\\n    },\\n    setSearchHistory: value => {\\n        let picacgConfig = picacg.defaultConfig\\n        let searchHistory = fetch(picacg.searchHistory).split('||').filter(item => item)\\n\\n        if (searchHistory.includes(value)) {\\n            for (let i in searchHistory) {\\n                if (searchHistory[i] === value) {\\n                    searchHistory.splice(i, 1)\\n                    break\\n                }\\n            }\\n        } else if (searchHistory.length >= picacgConfig.searchHistoryMax) {\\n            searchHistory = searchHistory.slice(0, picacgConfig.searchHistoryMax - 1)\\n        }\\n\\n        searchHistory.unshift(value)\\n        writeFile(picacg.searchHistory, searchHistory.join('||'))\\n    },\\n    getRanking: () => {\\n        addListener('onClose', $.toString(() => {\\n            clearItem('rankTT')\\n        }))\\n        const tabs = [\\n            {title: '24小时', id: 'H24'},\\n            {title: '7天', id: 'D7'},\\n            {title: '30天', id: 'D30'},\\n        ]\\n        picacg.d.push({\\n            title: '排行榜',\\n            url: picacg.empty,\\n            col_type: 'text_center_1',\\n            extra: {\\n                lineVisible: false\\n            },\\n        })\\n        picacg.d.push({\\n            col_type: 'line_blank'\\n        })\\n        tabs.forEach(item => {\\n            picacg.d.push({\\n                title: picacg.data.rankTT === item.id ? '‘‘’’<strong><font color=\\\"#ff1493\\\">'+item.title+'</font></strong>' : item.title,\\n                url: $(picacg.empty).lazyRule((item) => {\\n                    setItem('rankTT', item.id)\\n                    refreshPage(false)\\n                    return 'hiker://empty'\\n                }, item),\\n                col_type: 'text_3',\\n            })\\n        })\\n        picacg.d.push({\\n            col_type: 'line_blank'\\n        })\\n        const response = picacg.get('comics/leaderboard?tt='+picacg.data.rankTT+'&ct=VC')\\n\\n        response.data.comics.forEach(comic => {\\n            picacg.d.push({\\n                title: comic.title,\\n                desc: comic.author,\\n                pic_url: /*comic.thumb.fileServer+*/'https://storage.wikawika.xyz/static/'+comic.thumb.path,\\n                url: $(picacg.empty+'#immersiveTheme##noHistory#$$fypage').rule((id) => {\\n                    const picacg = $.require('hiker://page/picacg')\\n                    picacg.getInfo(id)\\n                    setResult(picacg.d);\\n                }, comic._id),\\n                col_type: 'movie_3'\\n            })\\n        })\\n    },\\n    getRandom: () => {\\n        const page = MY_URL.split('$$')[1]\\n        if (parseInt(page) === 1) {\\n            picacg.d.push({\\n                title: '随机本子',\\n                url: picacg.empty,\\n                col_type: 'text_center_1',\\n                extra: {\\n                    lineVisible: false\\n                },\\n            })\\n            picacg.d.push({\\n                col_type: 'line_blank'\\n            })\\n        }\\n        const response = picacg.get('comics/random?page='+page)\\n        response.data.comics.forEach(comic => {\\n            picacg.d.push({\\n                title: comic.title,\\n                desc: comic.author,\\n                pic_url: /*comic.thumb.fileServer+*/'https://storage.wikawika.xyz/static/'+comic.thumb.path,\\n                url: $(picacg.empty+'#immersiveTheme##noHistory#$$fypage').rule((id) => {\\n                    const picacg = $.require('hiker://page/picacg')\\n                    picacg.getInfo(id)\\n                    setResult(picacg.d);\\n                }, comic._id),\\n                col_type: 'movie_3'\\n            })\\n        })\\n    },\\n    getFavourite: () => {\\n        const page = MY_URL.split('$$')[1]\\n        if (parseInt(page) === 1) {\\n            picacg.d.push({\\n                title: '我的收藏',\\n                url: picacg.empty,\\n                col_type: 'text_center_1',\\n                extra: {\\n                    lineVisible: false\\n                },\\n            })\\n            picacg.d.push({\\n                col_type: 'line_blank'\\n            })\\n        }\\n        const response = picacg.get('users/favourite?s=dd&page='+page)\\n        response.data.comics.docs.forEach(comic => {\\n            picacg.d.push({\\n                title: comic.title,\\n                desc: comic.author,\\n                pic_url: /*comic.thumb.fileServer+*/'https://storage.wikawika.xyz/static/'+comic.thumb.path,\\n                url: $(picacg.empty+'#immersiveTheme##noHistory#$$fypage').rule((id) => {\\n                    const picacg = $.require('hiker://page/picacg')\\n                    picacg.getInfo(id)\\n                    setResult(picacg.d);\\n                }, comic._id),\\n                col_type: 'movie_3'\\n            })\\n        })\\n    },\\n    getCategories: () => {\\n        const response = picacg.get('categories')\\n        if (response.code === 200) {\\n            const no_image = ['大家都在看', '那年今天', '官方都在看'];\\n            response.data.categories.forEach((cate, index) => {\\n                let pic = no_image.includes(cate.title) ? 'https://git.tyrantg.com/tyrantgenesis/hikerViewRules/raw/master/assets/images/pica.jpg' : /*cate.thumb.fileServer+*/'https://storage.wikawika.xyz/static/'+cate.thumb.path\\n                let desc = no_image.includes(cate.title) ? '0' : '5'\\n                // let desc = '3'\\n                if (!cate.isWeb) {\\n                    picacg.d.push({\\n                        title: cate.title,\\n                        desc: desc,\\n                        pic_url: pic,\\n                        url: $(picacg.empty+'#noHistory#$$fypage').rule((title) => {\\n                            const picacg = $.require('hiker://page/picacg')\\n                            picacg.getComics(title)\\n                            setResult(picacg.d);\\n                        }, cate.title),\\n                        col_type: 'card_pic_3'\\n                    })\\n                }\\n            })\\n        }\\n    },\\n    getComics: (title) => {\\n        addListener('onClose', $.toString(() => {\\n            clearItem('sort')\\n        }))\\n        const page = MY_URL.split('$$')[1]\\n        if (parseInt(page) === 1) picacg.makeSort()\\n        const response = picacg.get('comics?c='+encodeURIComponent(title)+'&page='+page+'&s='+picacg.data.sort)\\n        if (response.code === 200) {\\n            response.data.comics.docs.forEach((comic, index) => {\\n                picacg.d.push({\\n                    title: comic.title,\\n                    desc: comic.author,\\n                    pic_url: /*comic.thumb.fileServer+*/'https://storage.wikawika.xyz/static/'+comic.thumb.path,\\n                    url: $(picacg.empty+'#immersiveTheme##noHistory#$$fypage').rule((id) => {\\n                        const picacg = $.require('hiker://page/picacg')\\n                        picacg.getInfo(id)\\n                        setResult(picacg.d);\\n                    }, comic._id),\\n                    col_type: 'movie_3'\\n                })\\n            })\\n        }\\n    },\\n    getEpisodesPicture: (id, page) => {\\n        const episodesRes = picacg.get('comics/'+id+'/eps?page='+page)\\n        if (episodesRes.code === 200 && episodesRes.data.eps.docs.length > 0) {\\n            episodesRes.data.eps.docs.forEach((ep, index) => {\\n                picacg.episodes.push({\\n                    title: ep.title,\\n                    url: ep.order,\\n                })\\n            })\\n            page = page+1\\n            picacg.getEpisodesPicture(id, page)\\n        }\\n    },\\n    getInfo: (id) => {\\n        addListener('onClose', $.toString(() => {\\n            clearItem('infoTab')\\n            clearItem('infoReverse')\\n        }))\\n        const page = MY_URL.split('$$')[1]\\n\\n        if (parseInt(page) === 1) {\\n            const response = picacg.get('comics/'+id)\\n            if (! response.data) {\\n                toast('漫画信息错误')\\n                back(false)\\n            }\\n\\n            const info = response.data.comic\\n\\n            setPageTitle(info.title)\\n\\n            picacg.d.push({\\n                title: info.title,\\n                desc:\\n                    '✨ 分类：'+info.categories.join(' ')+'\\\\n'+\\n                    '❤️ 喜欢：'+info.likesCount+'     浏览：'+info.viewsCount+'\\\\n'+\\n                    ' 详情：'+info.description,\\n                pic_url: /*info.thumb.fileServer+*/'https://storage.wikawika.xyz/static/'+info.thumb.path,\\n                url: $(picacg.empty).rule((description, image) => {\\n                    const picacg = $.require('hiker://page/picacg')\\n                    setPageTitle('本子详情')\\n                    picacg.d.push({\\n                        pic_url: image,\\n                        url: image,\\n                        col_type: 'pic_1_full'\\n                    })\\n                    picacg.d.push({\\n                        title: description,\\n                        col_type: 'long_text'\\n                    })\\n                    setResult(picacg.d)\\n                }, info.description, /*info.thumb.fileServer+*/'https://storage.wikawika.xyz/static/'+info.thumb.path),\\n                col_type: 'movie_1_vertical_pic_blur'\\n            })\\n\\n            picacg.d.push({\\n                col_type: 'line_blank'\\n            })\\n\\n            try {\\n                picacg.d.push({\\n                    title: '作者：'+info.author,\\n                    pic_url: 'https://git.tyrantg.com/tyrantgenesis/hikerViewRules/raw/master/assets/images/pica.jpg',\\n                    url: $(picacg.empty+\\\"#fullTheme##noHistory#$$fypage\\\").rule((author) => {\\n                        addListener('onClose', $.toString(() => {\\n                            clearItem('sort')\\n                            clearItem('searchValue')\\n                        }))\\n                        const page = MY_URL.split('$$')[1]\\n                        const picacg = $.require('hiker://page/picacg')\\n                        picacg.setSearchHistory(author)\\n                        if (parseInt(page) === 1) {\\n                            picacg.d.push({\\n                                title: '标签搜索：‘‘’’<strong><font color=\\\"#ff1493\\\">'+author+'</font></strong>',\\n                                url: picacg.empty,\\n                                col_type: 'text_center_1',\\n                                extra: {\\n                                    lineVisible: false\\n                                },\\n                            })\\n                            picacg.makeSort()\\n                        }\\n                        picacg.getSearchResult(page, author)\\n                        setResult(picacg.d)\\n                    }, info.author),\\n                    col_type: 'icon_2_round'\\n                })\\n                picacg.d.push({\\n                    title: '上传：'+info._creator.name,\\n                    pic_url: info._creator.avatar ? /*info._creator.avatar.fileServer+*/'https://storage.wikawika.xyz/static/'+info._creator.avatar.path : 'https://git.tyrantg.com/tyrantgenesis/hikerViewRules/raw/master/assets/images/pica.jpg',\\n                    url: $(picacg.empty+\\\"#fullTheme##noHistory#$$fypage\\\").rule((name) => {\\n                        addListener('onClose', $.toString(() => {\\n                            clearItem('sort')\\n                            clearItem('searchValue')\\n                        }))\\n                        const page = MY_URL.split('$$')[1]\\n                        const picacg = $.require('hiker://page/picacg')\\n                        picacg.setSearchHistory(name)\\n                        if (parseInt(page) === 1) {\\n                            picacg.d.push({\\n                                title: '标签搜索：‘‘’’<strong><font color=\\\"#ff1493\\\">'+name+'</font></strong>',\\n                                url: picacg.empty,\\n                                col_type: 'text_center_1',\\n                                extra: {\\n                                    lineVisible: false\\n                                },\\n                            })\\n                            picacg.makeSort()\\n                        }\\n                        picacg.getSearchResult(page, name)\\n                        setResult(picacg.d)\\n                    }, info._creator.name),\\n                    col_type: 'icon_2_round'\\n                })\\n\\n                if (info.tags.length > 0) {\\n                    info.tags.forEach(tag => {\\n                        picacg.d.push({\\n                            title: tag,\\n                            url: $(picacg.empty+\\\"#fullTheme##noHistory#$$fypage\\\").rule((tag) => {\\n                                addListener('onClose', $.toString(() => {\\n                                    clearItem('sort')\\n                                    clearItem('searchValue')\\n                                }))\\n                                const page = MY_URL.split('$$')[1]\\n                                const picacg = $.require('hiker://page/picacg')\\n                                picacg.setSearchHistory(tag)\\n                                if (parseInt(page) === 1) {\\n                                    picacg.d.push({\\n                                        title: '标签搜索：‘‘’’<strong><font color=\\\"#ff1493\\\">'+tag+'</font></strong>',\\n                                        url: picacg.empty,\\n                                        col_type: 'text_center_1',\\n                                        extra: {\\n                                            lineVisible: false\\n                                        },\\n                                    })\\n                                    picacg.makeSort()\\n                                }\\n                                picacg.getSearchResult(page, tag)\\n                                setResult(picacg.d)\\n                            }, tag),\\n                            col_type: 'flex_button',\\n                        })\\n                    })\\n\\n                    picacg.d.push({\\n                        col_type: 'line'\\n                    })\\n                }\\n            } catch (e) {}\\n\\n            // 递归获取选集\\n            picacg.getEpisodesPicture(id, 1)\\n\\n            picacg.d.push({\\n                title: info.isFavourite ? '‘‘’’<strong><font color=\\\"red\\\">取消收藏</font></strong>' : '‘‘’’<strong><font color=\\\"#00bfff\\\">收藏</font></strong>',\\n                url: $(picacg.empty).lazyRule((id, isFavourite) => {\\n                    const picacg = $.require('hiker://page/picacg')\\n                    picacg.post('comics/'+id+'/favourite', {})\\n                    toast(isFavourite?'取消收藏':'收藏成功')\\n                    refreshPage(false)\\n                    return picacg.empty\\n                }, id, info.isFavourite),\\n                col_type: 'text_3'\\n            })\\n\\n            picacg.d.push({\\n                title: info.isLiked ? '‘‘’’<strong><font color=\\\"red\\\">取消点赞</font></strong>' : '‘‘’’<strong><font color=\\\"#00bfff\\\">点赞</font></strong>',\\n                url: $(picacg.empty).lazyRule((id, isLiked) => {\\n                    const picacg = $.require('hiker://page/picacg')\\n                    picacg.post('comics/'+id+'/like', {})\\n                    toast(isLiked?'取消点赞':'点赞成功')\\n                    refreshPage(false)\\n                    return picacg.empty\\n                }, id, info.isLiked),\\n                col_type: 'text_3'\\n            })\\n\\n            picacg.d.push({\\n                title: '‘‘’’<strong><font color=\\\"#ff1493\\\">下载</font></strong>',\\n                url: \\\"hiker://page/download.view#noHistory##noRecordHistory##noRefresh#?rule=本地资源管理\\\",\\n                extra: {\\n                    chapterList: picacg.episodes,\\n                    info:{\\n                        bookName: info.title,\\n                        ruleName: MY_RULE.title,\\n                        bookTopPic: 'https://storage.wikawika.xyz/static/'+info.thumb.path,\\n                        parseCode: $.toString((id, ruleName) => {\\n                            const picacg = $.require('hiker://page/picacg?rule='+ruleName)\\n                            return picacg.getPicture(id, input)\\n                        }, id, MY_RULE.title)\\n                    },\\n                    defaultView:\\\"1\\\"\\n                },\\n                col_type: 'text_3',\\n            })\\n\\n            picacg.d.push({\\n                col_type: 'line'\\n            })\\n\\n            const tabs = [\\n                {title: '章节', id: '1'},\\n                {title: '推荐', id: '2'},\\n                {title: '看评论', id: '3'},\\n                {title: '写评论', id: '4'},\\n            ]\\n\\n            tabs.forEach(tab => {\\n                picacg.d.push({\\n                    title: picacg.data.infoTab === tab.id ? '‘‘’’<strong><font color=\\\"#ff1493\\\">'+tab.title+'</font></strong>' : tab.title,\\n                    url: $(picacg.empty).lazyRule((tab) => {\\n                        setItem('infoTab', tab.id)\\n                        refreshPage(false)\\n                        return 'hiker://empty'\\n                    }, tab),\\n                    col_type: 'text_4',\\n                })\\n            })\\n\\n            switch (picacg.data.infoTab) {\\n                case '1':\\n                    picacg.d.push({\\n                        title: picacg.data.infoReverse === '1' ? '当前排序：正序' : '当前排序：倒序',\\n                        url: $(picacg.empty).lazyRule((infoReverse) => {\\n                            setItem('infoReverse', infoReverse ? '2' : '1')\\n                            refreshPage(false)\\n                            return 'hiker://empty'\\n                        }, picacg.data.infoReverse === '1'),\\n                        col_type: 'text_center_1',\\n                    })\\n\\n                    const data = picacg.data.infoReverse === '1' ? picacg.episodes.reverse() : picacg.episodes\\n\\n                    data.forEach(ep => {\\n                        picacg.d.push({\\n                            title: ep.title,\\n                            url: $(picacg.empty).lazyRule((id, order) => {\\n                                const picacg = $.require('hiker://page/picacg')\\n                                return picacg.getPicture(id, order)\\n                            }, id, ep.url),\\n                            col_type: 'text_3'\\n                        })\\n                    })\\n                    break\\n                case '2':\\n                    const recommendationResponse = picacg.get('comics/'+id+'/recommendation')\\n                    recommendationResponse.data.comics.forEach(comic => {\\n                        picacg.d.push({\\n                            title: comic.title,\\n                            desc: comic.author,\\n                            pic_url: /*comic.thumb.fileServer+*/'https://storage.wikawika.xyz/static/'+comic.thumb.path,\\n                            url: $(picacg.empty+'#immersiveTheme##noHistory#$$fypage').rule((id) => {\\n                                const picacg = $.require('hiker://page/picacg')\\n                                picacg.getInfo(id)\\n                                setResult(picacg.d);\\n                            }, comic._id),\\n                            col_type: 'movie_3'\\n                        })\\n                    })\\n                    break\\n                case '4':\\n                    picacg.d.push({\\n                        desc: '请输入评论',\\n                        col_type: 'input',\\n                        extra: {\\n                            type: 'textarea',\\n                            height: 5,\\n                            titleVisible: false,\\n                            onChange: $.toString(() => {\\n                                if (input) setItem('comment', input)\\n                            })\\n                        }\\n                    })\\n                    picacg.d.push({\\n                        title: '提交评论',\\n                        url: $(picacg.empty).lazyRule((id) => {\\n                            const picacg = $.require('hiker://page/picacg')\\n                            const comment = getItem('comment', '')\\n                            if (! comment) {\\n                                return 'toast://请填写评论'\\n                            } else {\\n                                const sendCommentResponse = picacg.post('comics/'+id+'/comments', {\\n                                    content: comment\\n                                })\\n\\n                                if (sendCommentResponse.code === 200) {\\n                                    setItem('infoTab', '3')\\n                                    refreshPage(true)\\n                                    return 'toast://评论成功'\\n                                } else {\\n                                    return 'toast://'+(sendCommentResponse.message || sendCommentResponse.detail)\\n                                }\\n                            }\\n                        }, id),\\n                        col_type: 'text_center_1',\\n                    })\\n                    break\\n            }\\n\\n        }\\n\\n        try {\\n            if (picacg.data.infoTab === '3') {\\n                const commentsResponse = picacg.get('comics/'+id+'/comments?page='+page)\\n                commentsResponse.data.comments.docs.forEach(comment => {\\n                    let user = comment._user\\n                    if (user) {\\n                        picacg.d.push({\\n                            title: user.name,\\n                            pic_url: user.avatar ? /*user.avatar.fileServer+*/'https://storage.wikawika.xyz/static/'+user.avatar.path : 'https://git.tyrantg.com/tyrantgenesis/hikerViewRules/raw/master/assets/images/pica.jpg',\\n                            url: picacg.empty,\\n                            col_type: 'avatar'\\n                        })\\n                    }\\n                    picacg.d.push({\\n                        title: comment.content+'<br />'+ '❤️ 喜欢：'+comment.likesCount+'&nbsp;&nbsp;&nbsp;&nbsp; 回复：'+comment.commentsCount,\\n                        col_type: 'rich_text'\\n                    })\\n                    picacg.d.push({\\n                        title: comment.isLiked ? '取消点赞' : '点赞',\\n                        url: $(picacg.empty).lazyRule((id) => {\\n                            const picacg = $.require('hiker://page/picacg')\\n                            picacg.post('comments/'+id+'/like', {})\\n                            refreshPage(false)\\n                            return 'toast://提交成功'\\n                        }, comment._id),\\n                        col_type: 'text_3',\\n                    })\\n                    picacg.d.push({\\n                        title: '看回复',\\n                        url: $(picacg.empty+'$$fypage').rule((id) => {\\n                            const page = MY_URL.split('$$')[1]\\n                            const picacg = $.require('hiker://page/picacg')\\n                            const response = picacg.get('comments/'+id+'/childrens?page='+page)\\n\\n                            response.data.comments.docs.forEach(comment => {\\n                                let user = comment._user\\n                                if (user) {\\n                                    picacg.d.push({\\n                                        title: user.name,\\n                                        pic_url: user.avatar ? /*user.avatar.fileServer+*/'https://storage.wikawika.xyz/static/'+user.avatar.path : 'https://git.tyrantg.com/tyrantgenesis/hikerViewRules/raw/master/assets/images/pica.jpg',\\n                                        url: picacg.empty,\\n                                        col_type: 'avatar'\\n                                    })\\n                                }\\n                                picacg.d.push({\\n                                    title: comment.content+'<br />'+ '❤️ 喜欢：'+comment.likesCount,\\n                                    col_type: 'rich_text'\\n                                })\\n                                picacg.d.push({\\n                                    title: comment.isLiked ? '取消点赞' : '点赞',\\n                                    url: $(picacg.empty).lazyRule((id) => {\\n                                        const picacg = $.require('hiker://page/picacg')\\n                                        picacg.post('comments/'+id+'/like', {})\\n                                        refreshPage(false)\\n                                        return 'toast://提交成功'\\n                                    }, comment._id),\\n                                    col_type: 'text_center_1',\\n                                    extra: {\\n                                        lineVisible: false\\n                                    },\\n                                })\\n                                picacg.d.push({\\n                                    col_type: 'line',\\n                                })\\n                            })\\n\\n                            setResult(picacg.d);\\n                        }, comment._id),\\n                        col_type: 'text_3',\\n                    })\\n                    picacg.d.push({\\n                        title: '写回复',\\n                        url: $(picacg.empty).rule((id) => {\\n                            const picacg = $.require('hiker://page/picacg')\\n                            picacg.d.push({\\n                                desc: '请输入评论',\\n                                col_type: 'input',\\n                                extra: {\\n                                    type: 'textarea',\\n                                    height: 5,\\n                                    titleVisible: false,\\n                                    onChange: $.toString(() => {\\n                                        if (input) setItem('comment', input)\\n                                    })\\n                                }\\n                            })\\n                            picacg.d.push({\\n                                title: '提交评论',\\n                                url: $(picacg.empty).lazyRule((id) => {\\n                                    const picacg = $.require('hiker://page/picacg')\\n                                    const comment = getItem('comment', '')\\n                                    if (! comment) {\\n                                        return 'toast://请填写评论'\\n                                    } else {\\n                                        const sendCommentResponse = picacg.post('comments/'+id, {\\n                                            content: comment\\n                                        })\\n\\n                                        if (sendCommentResponse.code === 200) {\\n                                            back(false)\\n                                            return 'toast://评论成功'\\n                                        } else {\\n                                            return 'toast://'+(sendCommentResponse.message || sendCommentResponse.detail)\\n                                        }\\n                                    }\\n                                }, id),\\n                                col_type: 'text_center_1',\\n                            })\\n                            setResult(picacg.d);\\n                        }, comment._id),\\n                        col_type: 'text_3',\\n                    })\\n                    /*picacg.d.push({\\n                        title: '举报',\\n                        url: $(picacg.empty).lazyRule((id) => {\\n                            const picacg = $.require('hiker://page/picacg')\\n                            picacg.post('comics/'+id+'/report', {})\\n                            return 'toast://提交成功'\\n                        }, id),\\n                        col_type: 'text_4',\\n                    })*/\\n                    picacg.d.push({\\n                        col_type: 'line',\\n                    })\\n                })\\n            }\\n        } catch (e) {}\\n\\n    },\\n    getRecursionPicture: (id, order, page) => {\\n        const response = picacg.get('comics/'+id+'/order/'+order+'/pages?page='+page)\\n        if (response.code === 200 && response.data.pages.docs.length > 0) {\\n            response.data.pages.docs.forEach((page, index) => {\\n                // picacg.images.push(page.media.fileServer+'/static/'+page.media.path)\\n                picacg.images.push('https://storage.wikawika.xyz/static/'+page.media.path)\\n            })\\n            page = page+1\\n            picacg.getRecursionPicture(id, order, page)\\n        }\\n    },\\n    getPicture: (id, order) => {\\n        // 递归获取内容\\n        picacg.getRecursionPicture(id, order, 1)\\n        return 'pics://'+picacg.images.join('&&')\\n    },\\n    makeSort: () => {\\n        const tabs = [\\n            {title: '默认排序', id: 'ua'},\\n            {title: '新到旧', id: 'dd'},\\n            {title: '旧到新', id: 'da'},\\n            {title: '最多爱心', id: 'ld'},\\n            {title: '最多指名', id: 'vd'},\\n        ];\\n\\n        tabs.forEach(item => {\\n            picacg.d.push({\\n                title: picacg.data.sort === item.id ? '‘‘’’<strong><font color=\\\"#ff1493\\\">'+item.title+'</font></strong>' : item.title,\\n                url: $(picacg.empty).lazyRule((item) => {\\n                    setItem('sort', item.id)\\n                    refreshPage(false)\\n                    return 'hiker://empty'\\n                }, item),\\n                col_type: 'scroll_button',\\n            })\\n        })\\n\\n        picacg.d.push({\\n            col_type: 'blank_block',\\n        })\\n    },\\n    settingPage: () => {\\n        picacg.d.push({\\n            title: '签到',\\n            url: $(picacg.empty).lazyRule(() => {\\n                const picacg = $.require('hiker://page/picacg')\\n                const response = picacg.post('users/punch-in', {})\\n                if (response.code === 200) {\\n                    return 'toast://签到成功'\\n                } else {\\n                    return 'toast://'+ (response.message || response.detail)\\n                }\\n            }),\\n            col_type: 'text_center_1'\\n        })\\n        picacg.d.push({\\n            title: '我的评论',\\n            url: $(picacg.empty+'$$fypage').rule(() => {\\n                const page = MY_URL.split('$$')[1]\\n                const picacg = $.require('hiker://page/picacg')\\n                const response = picacg.get('users/my-comments?page='+page)\\n\\n                response.data.comments.docs.forEach(comment => {\\n                    let user = comment._user\\n                    if (user) {\\n                        picacg.d.push({\\n                            title: user.name,\\n                            pic_url: user.avatar ? /*user.avatar.fileServer+*/'https://storage.wikawika.xyz/static/'+user.avatar.path : 'https://git.tyrantg.com/tyrantgenesis/hikerViewRules/raw/master/assets/images/pica.jpg',\\n                            url: picacg.empty,\\n                            col_type: 'avatar'\\n                        })\\n                    }\\n                    picacg.d.push({\\n                        title: comment.content+'<br />'+ '❤️ 喜欢：'+comment.likesCount,\\n                        col_type: 'rich_text'\\n                    })\\n                    picacg.d.push({\\n                        title: comment.isLiked ? '取消点赞' : '点赞',\\n                        url: $(picacg.empty).lazyRule((id) => {\\n                            const picacg = $.require('hiker://page/picacg')\\n                            picacg.post('comments/'+id+'/like', {})\\n                            refreshPage(false)\\n                            return 'toast://提交成功'\\n                        }, comment._id),\\n                        col_type: 'text_2',\\n                        extra: {\\n                            lineVisible: false\\n                        },\\n                    })\\n                    picacg.d.push({\\n                        title: '查看漫画',\\n                        url: $(picacg.empty+'#immersiveTheme##noHistory#$$fypage').rule((id) => {\\n                            const picacg = $.require('hiker://page/picacg')\\n                            picacg.getInfo(id)\\n                            setResult(picacg.d);\\n                        }, comment._comic._id),\\n                        col_type: 'text_2',\\n                        extra: {\\n                            lineVisible: false\\n                        },\\n                    })\\n                    picacg.d.push({\\n                        col_type: 'line',\\n                    })\\n                })\\n                setResult(picacg.d)\\n            }),\\n            col_type: 'text_center_1'\\n        })\\n        picacg.d.push({\\n            title: '退出登录',\\n            url: $(picacg.empty).lazyRule(() => {\\n                const picacg = $.require('hiker://page/picacg')\\n                writeFile(picacg.picacg_path, '')\\n                toast('退出登录')\\n                back(true)\\n                return picacg.empty\\n            }),\\n            col_type: 'text_center_1'\\n        })\\n    },\\n}\\n\\n$.exports = picacg\"}]","icon":"https://git.tyrantg.com/tyrantgenesis/hikerViewRules/raw/master/assets/images/pica.jpg"}
Add Comment
Please, Sign In to add comment
