K3vinb5/kodjodevf-mangayomi-extensions
1
0
Fork 0
mirror of https://github.com/kodjodevf/mangayomi-extensions.git synced 2026-02-14 19:01:15 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #136 from Swakshan/extension/aniplay

Browse Source 
New source: Aniplay
This commit is contained in:
Moustapha Kodjo Amadou
2025-01-15 06:26:50 +01:00
committed by GitHub
parent cd24fb6322 e5d584a974
commit 3f074ce534
1 changed files with 523 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

523
javascript/anime/src/en/aniplay.js Normal file
View File

@@ -0,0 +1,523 @@
const mangayomiSources = [{
"name": "Aniplay",
"lang": "en",
"baseUrl": "https://aniplaynow.live",
"apiUrl": "https://aniplaynow.live",
"iconUrl": "https://www.google.com/s2/favicons?sz=128&domain=https://aniplaynow.live/",
"typeSource": "single",
"itemType": 1,
"version": "1.0.0",
"dateFormat": "",
"dateFormatLocale": "",
"pkgPath": "anime/src/en/aniplay.js"
}];
class DefaultExtension extends MProvider {
constructor() {
super();
this.client = new Client();
}
getHeaders(url) {
return {
Referer: this.source.apiUrl
}
}
getPreference(key) {
const preferences = new SharedPreferences();
return preferences.get(key);
}
// code from torrentioanime.js
anilistQuery() {
return `
query ($page: Int, $perPage: Int, $sort: [MediaSort], $search: String) {
Page(page: $page, perPage: $perPage) {
pageInfo {
currentPage
hasNextPage
}
media(type: ANIME, sort: $sort, search: $search, status_in: [RELEASING, FINISHED, NOT_YET_RELEASED]) {
id
title {
romaji
english
native
}
coverImage {
extraLarge
large
}
description
status
tags {
name
}
genres
studios {
nodes {
name
}
}
countryOfOrigin
isAdult
}
}
}
`.trim();
}
// code from torrentioanime.js
anilistLatestQuery() {
const currentTimeInSeconds = Math.floor(Date.now() / 1000);
return `
query ($page: Int, $perPage: Int, $sort: [AiringSort]) {
Page(page: $page, perPage: $perPage) {
pageInfo {
currentPage
hasNextPage
}
airingSchedules(
airingAt_greater: 0
airingAt_lesser: ${currentTimeInSeconds - 10000}
sort: $sort
) {
media {
id
title {
romaji
english
native
}
coverImage {
extraLarge
large
}
description
status
tags {
name
}
genres
studios {
nodes {
name
}
}
countryOfOrigin
isAdult
}
}
}
}
`.trim();
}
// code from torrentioanime.js
async getAnimeDetails(anilistId) {
const query = `
query($id: Int){
Media(id: $id){
id
title {
romaji
english
native
}
coverImage {
extraLarge
large
}
description
status
tags {
name
}
genres
studios {
nodes {
name
}
}
format
countryOfOrigin
isAdult
}
}
`.trim();
const variables = JSON.stringify({ id: anilistId });
const res = await this.makeGraphQLRequest(query, variables);
const media = JSON.parse(res.body).data.Media;
const anime = {};
anime.name = (() => {
var preferenceTitle = this.getPreference("aniplay_pref_title");
switch (preferenceTitle) {
case "romaji":
return media?.title?.romaji || "";
case "english":
return media?.title?.english?.trim() || media?.title?.romaji || "";
case "native":
return media?.title?.native || "";
default:
return "";
}
})();
anime.imageUrl = media?.coverImage?.extraLarge || "";
anime.description = (media?.description || "No Description")
.replace(/<br><br>/g, "\n")
.replace(/<.*?>/g, "");
anime.status = (() => {
switch (media?.status) {
case "RELEASING":
return 0;
case "FINISHED":
return 1;
case "HIATUS":
return 2;
case "NOT_YET_RELEASED":
return 3;
default:
return 5;
}
})();
const tagsList = media?.tags?.map(tag => tag.name).filter(Boolean) || [];
const genresList = media?.genres || [];
anime.genre = [...new Set([...tagsList, ...genresList])].sort();
const studiosList = media?.studios?.nodes?.map(node => node.name).filter(Boolean) || [];
anime.author = studiosList.sort().join(", ");
anime.format = media.format
return anime;
}
// code from torrentioanime.js
async makeGraphQLRequest(query, variables) {
const res = await this.client.post("https://graphql.anilist.co", {},
{
query, variables
});
return res;
}
// code from torrentioanime.js
parseSearchJson(jsonLine, isLatestQuery = false) {
const jsonData = JSON.parse(jsonLine);
jsonData.type = isLatestQuery ? "AnilistMetaLatest" : "AnilistMeta";
const metaData = jsonData;
const mediaList = metaData.type == "AnilistMeta"
? metaData.data?.Page?.media || []
: metaData.data?.Page?.airingSchedules.map(schedule => schedule.media) || [];
const hasNextPage = metaData.type == "AnilistMeta" || metaData.type == "AnilistMetaLatest"
? metaData.data?.Page?.pageInfo?.hasNextPage || false
: false;
const animeList = mediaList
.filter(media => !((media?.countryOfOrigin === "CN" || media?.isAdult) && isLatestQuery))
.map(media => {
const anime = {};
anime.link = media?.id?.toString() || "";
anime.name = (() => {
var preferenceTitle = this.getPreference("aniplay_pref_title");
switch (preferenceTitle) {
case "romaji":
return media?.title?.romaji || "";
case "english":
return media?.title?.english?.trim() || media?.title?.romaji || "";
case "native":
return media?.title?.native || "";
default:
return "";
}
})();
anime.imageUrl = media?.coverImage?.extraLarge || "";
return anime;
});
return { "list": animeList, "hasNextPage": hasNextPage };
}
async getPopular(page) {
const variables = JSON.stringify({
page: page,
perPage: 30,
sort: "TRENDING_DESC"
});
const res = await this.makeGraphQLRequest(this.anilistQuery(), variables);
return this.parseSearchJson(res.body)
}
async getLatestUpdates(page) {
const variables = JSON.stringify({
page: page,
perPage: 30,
sort: "TIME_DESC"
});
const res = await this.makeGraphQLRequest(this.anilistLatestQuery(), variables);
return this.parseSearchJson(res.body, true)
}
async search(query, page, filters) {
const variables = JSON.stringify({
page: page,
perPage: 30,
sort: "POPULARITY_DESC",
search: query
});
const res = await this.makeGraphQLRequest(this.anilistQuery(), variables);
return this.parseSearchJson(res.body)
}
get supportsLatest() {
throw new Error("supportsLatest not implemented");
}
async aniplayRequest(slug, body) {
var next_action = ""
if (slug.indexOf("info/") > -1) {
next_action = 'f3422af67c84852f5e63d50e1f51718f1c0225c4'
} else if (slug.indexOf("watch/") > -1) {
next_action = '5dbcd21c7c276c4d15f8de29d9ef27aef5ea4a5e'
}
var url = `${this.source.baseUrl}/anime/${slug}`
var headers = {
"referer": "https://aniplaynow.live",
'next-action': next_action,
"Content-Type": "application/json",
}
var response = await new Client().post(url, headers, body);
if (response.statusCode != 200) {
throw new Error("Error: " + response.statusText);
}
return JSON.parse(response.body.split('1:')[1])
}
async getDetail(url) {
var anilistId = url
var animeData = await this.getAnimeDetails(anilistId)
var slug = `info/${anilistId}`
var body = [anilistId, true, false]
var result = await this.aniplayRequest(slug, body)
if (result.length < 1) {
throw new Error("Error: No data found for the given URL");
}
var user_provider = this.getPreference("aniplay_pref_provider");
var choice = result[0]
for (var ch of result) {
if (ch["providerId"] == user_provider) {
choice = ch
break;
}
}
var user_mark_filler_ep = this.getPreference("aniplay_pref_mark_filler");
var chapters = []
var epList = choice.episodes
for (var ep of epList) {
var title = ep.title
var num = ep.number
var isFiller = ep.isFiller
var name = isFiller && user_mark_filler_ep ? `E${num}:(F) ${title}` : `E${num}: ${title}`
var dateUpload = "createdAt" in ep ? new Date(ep.createdAt) : new Date().now()
dateUpload = dateUpload.valueOf().toString();
delete ep.img
delete ep.title
delete ep.description
delete ep.isFiller
var epUrl = `${anilistId}||${JSON.stringify(ep)}||${choice.providerId}`
chapters.push({ name, url: epUrl, dateUpload })
}
var format = animeData.format
if(format === "MOVIE") chapters[0].name = "Movie"
animeData.link = `${this.source.baseUrl}/anime/${slug}`
animeData.chapters = chapters.reverse()
return animeData
}
// Sorts streams based on user preference.
async sortStreams(streams) {
var sortedStreams = [];
var copyStreams = streams.slice()
var pref = await this.getPreference("aniplay_pref_video_resolution");
for (var stream of streams) {
if (stream.quality.indexOf(pref) > -1) {
sortedStreams.push(stream);
var index = copyStreams.indexOf(stream);
if (index > -1) {
copyStreams.splice(index, 1);
}
break;
}
}
return [...sortedStreams, ...copyStreams]
}
// Extracts the streams url for different resolutions from a hls stream.
async extractStreams(url, providerId) {
const response = await new Client().get(url);
const body = response.body;
const lines = body.split('\n');
var streams = [{
url: url,
originalUrl: url,
quality: "auto",
}];
for (let i = 0; i < lines.length; i++) {
if (lines[i].startsWith('#EXT-X-STREAM-INF:')) {
var resolution = lines[i].match(/RESOLUTION=(\d+x\d+)/)[1];
var m3u8Url = lines[i + 1].trim();
if (providerId === "anya") {
m3u8Url = `https://prox.uqable.easypanel.host${m3u8Url}`
} else if (providerId === "yuki") {
var orginalUrl = url
m3u8Url = orginalUrl.replace("master.m3u8", m3u8Url)
}
streams.push({
url: m3u8Url,
originalUrl: m3u8Url,
quality: `${resolution} - ${providerId}`,
});
}
}
return streams
}
async getAnyaStreams(result) {
var m3u8Url = result.sources[0].url
m3u8Url = `https://prox.uqable.easypanel.host/fetch?url=${m3u8Url}&ref=https://anix.sh`
return await this.extractStreams(m3u8Url, "anya");
}
async getYukiStreams(result) {
var m3u8Url = result.sources[0].url
var streams = await this.extractStreams(m3u8Url, "yuki");
var subtitles = result.tracks
streams[0].subtitles = subtitles
return streams
}
// For anime episode video list
async getVideoList(url) {
var urlSplits = url.split("||")
var anilistId = urlSplits[0]
var epData = JSON.parse(urlSplits[1])
var providerId = urlSplits[2]
var user_audio_type = this.getPreference("aniplay_pref_audio_type");
var subOrDub = epData.hasDub && user_audio_type === "dub" ? "dub" : "sub"
var slug = `watch/${anilistId}`
var body = [
anilistId,
providerId,
epData.id,
epData.number.toString(),
subOrDub
]
var result = await this.aniplayRequest(slug, body)
if (result === null) {
throw new Error("Error: No data found for the given URL");
}
var streams = []
if (providerId == "anya") {
streams = await this.getAnyaStreams(result)
}
else {
streams = await this.getYukiStreams(result)
}
return await this.sortStreams(streams)
}
// For manga chapter pages
async getPageList() {
throw new Error("getPageList not implemented");
}
getFilterList() {
throw new Error("getFilterList not implemented");
}
getSourcePreferences() {
return [
{
"key": "aniplay_pref_title",
"listPreference": {
"title": "Preferred Title",
"summary": "",
"valueIndex": 0,
"entries": ["Romaji", "English", "Native"],
"entryValues": ["romaji", "english", "native"],
}
},
{
"key": "aniplay_pref_provider",
"listPreference": {
"title": "Preferred provider",
"summary": "",
"valueIndex": 0,
"entries": ["Anya", "Yuki"],
"entryValues": ["anya", "yuki"],
}
}, {
"key": "aniplay_pref_mark_filler",
"switchPreferenceCompat": {
"title": "Mark filler episodes",
"summary": "Filler episodes will be marked with (F)",
"value": false
}
},
{
"key": "aniplay_pref_audio_type",
"listPreference": {
"title": "Preferred audio type",
"summary": "Sub/Dub",
"valueIndex": 0,
"entries": ["Sub", "Dub"],
"entryValues": ["sub", "dub"],
}
}, {
key: 'aniplay_pref_video_resolution',
listPreference: {
title: 'Preferred video resolution',
summary: '',
valueIndex: 0,
entries: ["Auto", "1080p", "720p", "480p", "360p"],
entryValues: ["auto", "1080", "720", "480", "360"]
}
},
]
}
}