@nekosuneprojects/nekosunevrtools 1.1.0 → 1.1.1

package/src/downloader/client.js

@@ -0,0 +1,126 @@
+const axios = require("axios");
+const { presets, providers } = require("./providers");
+
+class DownloaderClient {
+  constructor(options = {}) {
+    this.timeoutMs = options.timeoutMs || 120000;
+    this.apiKey = options.apiKey || null;
+    this.baseUrl = resolveBaseUrl(options.baseUrl, options.preset || "nekosune");
+    this.provider = providers.compatible(this.baseUrl);
+  }
+
+  useBaseUrl(baseUrl) {
+    this.baseUrl = resolveBaseUrl(baseUrl);
+    this.provider = providers.compatible(this.baseUrl);
+    return this;
+  }
+
+  usePreset(name) {
+    this.baseUrl = resolveBaseUrl(null, name);
+    this.provider = providers.compatible(this.baseUrl);
+    return this;
+  }
+
+  async createMp3Job(link, options = {}) {
+    return this.provider.createMp3Job({
+      http: this.createHttp(options),
+      apiKey: options.apiKey || this.apiKey,
+      link,
+      uploadDest: options.uploadDest || "cdn"
+    });
+  }
+
+  async createMp4Job(link, options = {}) {
+    return this.provider.createMp4Job({
+      http: this.createHttp(options),
+      apiKey: options.apiKey || this.apiKey,
+      link,
+      uploadDest: options.uploadDest || "cdn"
+    });
+  }
+
+  async getJob(jobId, options = {}) {
+    return this.provider.getJob({
+      http: this.createHttp(options),
+      apiKey: options.apiKey || this.apiKey,
+      jobId
+    });
+  }
+
+  async waitForJob(jobId, options = {}) {
+    const intervalMs = Math.max(500, options.intervalMs || 2000);
+    const timeoutMs = Math.max(intervalMs, options.timeoutMs || 300000);
+    const started = Date.now();
+
+    while (true) {
+      const state = await this.getJob(jobId, options);
+      if (typeof options.onProgress === "function") {
+        options.onProgress(state);
+      }
+      if (state && state.status === "done") {
+        return state;
+      }
+      if (state && (state.status === "error" || state.status === "failed")) {
+        throw new Error(state.message || "Downloader job failed.");
+      }
+      if (Date.now() - started > timeoutMs) {
+        throw new Error("Downloader job wait timed out.");
+      }
+      await sleep(intervalMs);
+    }
+  }
+
+  async getInfo(url, options = {}) {
+    return this.provider.getInfo({
+      http: this.createHttp(options),
+      url,
+      flat: Boolean(options.flat || options.flatPlaylist),
+      fields: options.fields || "basic",
+      cache: typeof options.cache === "number" ? options.cache : 1
+    });
+  }
+
+  async searchYouTube(query, options = {}) {
+    return this.provider.searchYouTube({
+      http: this.createHttp(options),
+      query,
+      limit: typeof options.limit === "number" ? options.limit : 5
+    });
+  }
+
+  getStreamUrl(url) {
+    return this.provider.getStreamUrl({ url });
+  }
+
+  async stream(url, options = {}) {
+    return this.provider.stream({
+      http: this.createHttp(options),
+      url,
+      responseType: options.responseType || "stream"
+    });
+  }
+
+  createHttp(options = {}) {
+    return axios.create({ timeout: options.timeoutMs || this.timeoutMs });
+  }
+}
+
+function resolveBaseUrl(baseUrl, preset) {
+  if (baseUrl) {
+    return String(baseUrl).replace(/\/+$/, "");
+  }
+  if (preset && presets[preset]) {
+    return presets[preset];
+  }
+  throw new Error(`Unknown downloader preset "${preset}". Available: ${Object.keys(presets).join(", ")}`);
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+module.exports = {
+  DownloaderClient,
+  presets,
+  providers
+};

package/src/downloader/provider/compatible.js

@@ -0,0 +1,127 @@
+function createDownloaderProvider(baseUrl) {
+  const normalizedBaseUrl = String(baseUrl || "").replace(/\/+$/, "");
+  if (!normalizedBaseUrl) {
+    throw new Error("Missing downloader baseUrl.");
+  }
+
+  async function createMp3Job(context) {
+    return createJob(context, "mp3");
+  }
+
+  async function createMp4Job(context) {
+    return createJob(context, "mp4");
+  }
+
+  async function createJob(context, mode) {
+    const { apiKey, http, link, uploadDest } = context;
+    assertApiKey(apiKey);
+    if (!link) {
+      throw new Error(`Missing "link" for ${mode} job.`);
+    }
+
+    const response = await http.post(`${normalizedBaseUrl}/api/${mode}/jobs`, {
+      link,
+      upload_dest: uploadDest || "cdn"
+    }, {
+      headers: buildAuthHeaders(apiKey)
+    });
+
+    const body = response.data || {};
+    if (!body.job_id) {
+      throw new Error(`Downloader ${mode} job did not return job_id.`);
+    }
+
+    return {
+      provider: "downloader-compatible",
+      jobId: body.job_id,
+      raw: body
+    };
+  }
+
+  async function getJob(context) {
+    const { apiKey, http, jobId } = context;
+    assertApiKey(apiKey);
+    if (!jobId) {
+      throw new Error('Missing "jobId".');
+    }
+
+    const response = await http.get(`${normalizedBaseUrl}/api/jobs/${encodeURIComponent(jobId)}`, {
+      headers: buildAuthHeaders(apiKey)
+    });
+    return response.data || {};
+  }
+
+  async function getInfo(context) {
+    const { http, url, flat, fields, cache } = context;
+    if (!url) {
+      throw new Error('Missing "url" for info endpoint.');
+    }
+    const response = await http.get(`${normalizedBaseUrl}/api/info`, {
+      params: {
+        url,
+        flat: flat ? 1 : undefined,
+        fields: fields || undefined,
+        cache: typeof cache === "number" ? cache : undefined
+      }
+    });
+    return response.data || {};
+  }
+
+  async function searchYouTube(context) {
+    const { http, query, limit } = context;
+    if (!query) {
+      throw new Error('Missing "query" for youtube search.');
+    }
+    const response = await http.get(`${normalizedBaseUrl}/api/search/youtube`, {
+      params: {
+        q: query,
+        limit: typeof limit === "number" ? limit : undefined
+      }
+    });
+    return response.data || {};
+  }
+
+  function getStreamUrl(context) {
+    const { url } = context;
+    if (!url) {
+      throw new Error('Missing "url" for stream endpoint.');
+    }
+    return `${normalizedBaseUrl}/api/stream?url=${encodeURIComponent(url)}`;
+  }
+
+  async function stream(context) {
+    const { http, url, responseType } = context;
+    const streamUrl = getStreamUrl({ url });
+    const response = await http.get(streamUrl, {
+      responseType: responseType || "stream"
+    });
+    return response;
+  }
+
+  return {
+    createMp3Job,
+    createMp4Job,
+    getJob,
+    getInfo,
+    searchYouTube,
+    getStreamUrl,
+    stream
+  };
+}
+
+function assertApiKey(apiKey) {
+  if (!apiKey) {
+    throw new Error('Missing downloader apiKey. Pass "apiKey" in client options or call options.');
+  }
+}
+
+function buildAuthHeaders(apiKey) {
+  return {
+    "x-api-key": apiKey,
+    Authorization: `Bearer ${apiKey}`
+  };
+}
+
+module.exports = {
+  createDownloaderProvider
+};

package/src/downloader/providers.js

@@ -0,0 +1,15 @@
+const { createDownloaderProvider } = require("./provider/compatible");
+
+const presets = {
+  nekosune: "https://dl.nekosunevr.co.uk",
+  ballisticok: "https://dl.ballisticok.xyz"
+};
+
+const providers = {
+  compatible: createDownloaderProvider
+};
+
+module.exports = {
+  presets,
+  providers
+};

package/src/games/client.js

@@ -0,0 +1,162 @@
+const axios = require("axios");
+const { presets, providers } = require("./providers");
+
+class GamesClient {
+  constructor(options = {}) {
+    this.timeoutMs = options.timeoutMs || 60000;
+    this.apiKey = options.apiKey || null;
+    this.baseUrl = resolveBaseUrl(options.baseUrl, options.preset || "nekosune");
+    this.provider = providers.nekosune(this.baseUrl);
+  }
+
+  useBaseUrl(baseUrl) {
+    this.baseUrl = resolveBaseUrl(baseUrl);
+    this.provider = providers.nekosune(this.baseUrl);
+    return this;
+  }
+
+  usePreset(name) {
+    this.baseUrl = resolveBaseUrl(null, name);
+    this.provider = providers.nekosune(this.baseUrl);
+    return this;
+  }
+
+  getClashOfClansClan(clanTag, options = {}) {
+    return this.provider.getClashOfClansClan({
+      http: this.createHttp(options),
+      apiKey: options.apiKey || this.apiKey,
+      clanTag
+    });
+  }
+
+  getClashOfClansPlayer(playerTag, options = {}) {
+    return this.provider.getClashOfClansPlayer({
+      http: this.createHttp(options),
+      apiKey: options.apiKey || this.apiKey,
+      playerTag
+    });
+  }
+
+  getDivision2Player(username, platform = "psn", options = {}) {
+    return this.provider.getDivision2Player({
+      http: this.createHttp(options),
+      apiKey: options.apiKey || this.apiKey,
+      username,
+      platform
+    });
+  }
+
+  getFortnitePlayer(username, timeWindow = "lifetime", options = {}) {
+    return this.provider.getFortnitePlayer({
+      http: this.createHttp(options),
+      apiKey: options.apiKey || this.apiKey,
+      username,
+      timeWindow
+    });
+  }
+
+  getFortniteCreatorCode(creatorCode, options = {}) {
+    return this.provider.getFortniteCreatorCode({
+      http: this.createHttp(options),
+      apiKey: options.apiKey || this.apiKey,
+      creatorCode
+    });
+  }
+
+  getFortniteItemShop(options = {}) {
+    return this.provider.getFortniteItemShop({
+      http: this.createHttp(options),
+      apiKey: options.apiKey || this.apiKey
+    });
+  }
+
+  getWynncraftProfile(username, options = {}) {
+    return this.provider.getWynncraftProfile({
+      http: this.createHttp(options),
+      apiKey: options.apiKey || this.apiKey,
+      username
+    });
+  }
+
+  getHypixelProfile(username, options = {}) {
+    return this.provider.getHypixelProfile({
+      http: this.createHttp(options),
+      apiKey: options.apiKey || this.apiKey,
+      username
+    });
+  }
+
+  getRocketLeaguePlayer(username, platform = "psn", options = {}) {
+    return this.provider.getRocketLeaguePlayer({
+      http: this.createHttp(options),
+      apiKey: options.apiKey || this.apiKey,
+      username,
+      platform
+    });
+  }
+
+  getApexLegendsPlayer(username, platform = "psn", options = {}) {
+    return this.provider.getApexLegendsPlayer({
+      http: this.createHttp(options),
+      apiKey: options.apiKey || this.apiKey,
+      username,
+      platform
+    });
+  }
+
+  getBattlefield1Player(username, platform = "psn", options = {}) {
+    return this.provider.getBattlefield1Player({
+      http: this.createHttp(options),
+      apiKey: options.apiKey || this.apiKey,
+      username,
+      platform
+    });
+  }
+
+  getBattlefield5Player(username, platform = "psn", options = {}) {
+    return this.provider.getBattlefield5Player({
+      http: this.createHttp(options),
+      apiKey: options.apiKey || this.apiKey,
+      username,
+      platform
+    });
+  }
+
+  getBattlefield2042Player(username, platform = "ea", options = {}) {
+    return this.provider.getBattlefield2042Player({
+      http: this.createHttp(options),
+      apiKey: options.apiKey || this.apiKey,
+      username,
+      platform
+    });
+  }
+
+  getBattlefield6Player(username, platform = "psn", options = {}) {
+    return this.provider.getBattlefield6Player({
+      http: this.createHttp(options),
+      apiKey: options.apiKey || this.apiKey,
+      username,
+      platform
+    });
+  }
+
+  createHttp(options = {}) {
+    return axios.create({ timeout: options.timeoutMs || this.timeoutMs });
+  }
+}
+
+function resolveBaseUrl(baseUrl, preset) {
+  if (baseUrl) {
+    return String(baseUrl).replace(/\/+$/, "");
+  }
+  if (preset && presets[preset]) {
+    return presets[preset];
+  }
+  throw new Error(`Unknown games preset "${preset}". Available: ${Object.keys(presets).join(", ")}`);
+}
+
+module.exports = {
+  GamesClient,
+  presets,
+  providers
+};