@ikenxuan/amagi 1.5.4 → 1.5.6

package/lib/index.d.ts

@@ -1,8 +1,8 @@
-export * from './model/index.js';
-export * from './business/index.js';
-export * from './types/index.js';
-export * from './server/index.js';
-import { client } from './server/index.js';
+export * from "./model/index.js";
+export * from "./business/index.js";
+export * from "./types/index.js";
+export * from "./server/index.js";
+import { client } from "./server/index.js";
 declare const amagi: typeof client;
 export { amagi as default };
 export { amagi as Amagi };

package/lib/index.js

@@ -1,8 +1,8 @@
-export * from './model/index.js';
-export * from './business/index.js';
-export * from './types/index.js';
-export * from './server/index.js';
-import { client } from './server/index.js';
+export * from "./model/index.js";
+export * from "./business/index.js";
+export * from "./types/index.js";
+export * from "./server/index.js";
+import { client } from "./server/index.js";
 const amagi = client;
 export { amagi as default };
 export { amagi as Amagi };

package/lib/model/logger.js

@@ -2,27 +2,27 @@ import log from 'loglevel';
 import prefix from 'loglevel-plugin-prefix';
 import chalk from 'chalk';
 const colors = {
-    TRACE: chalk.magenta,
-    DEBUG: chalk.cyan,
-    INFO: chalk.blue,
-    WARN: chalk.yellow,
-    ERROR: chalk.red,
+  TRACE: chalk.magenta,
+  DEBUG: chalk.cyan,
+  INFO: chalk.blue,
+  WARN: chalk.yellow,
+  ERROR: chalk.red
 };
 prefix.reg(log);
 log.enableAll();
 prefix.apply(log, {
-    format(level, name, timestamp) {
-        const levelKey = level.toUpperCase();
-        if (!(levelKey in colors)) {
-            throw new Error(`Invalid log level: ${levelKey}`);
-        }
-        return `${chalk.gray(`[${timestamp}]`)} ${colors[levelKey](level)} ${chalk.green(`${name}:`)}`;
-    },
+  format(level, name, timestamp) {
+    const levelKey = level.toUpperCase();
+    if (!(levelKey in colors)) {
+      throw new Error(`Invalid log level: ${levelKey}`);
+    }
+    return `${chalk.gray(`[${timestamp}]`)} ${colors[levelKey](level)} ${chalk.green(`${name}:`)}`;
+  }
 });
 prefix.apply(log.getLogger('critical'), {
-    format(level, name, timestamp) {
-        return chalk.red.bold(`[${timestamp}] ${level} ${name}:`);
-    },
+  format(level, name, timestamp) {
+    return chalk.red.bold(`[${timestamp}] ${level} ${name}:`);
+  }
 });
 const logger = log;
 export default logger;

package/lib/model/networks.d.ts

@@ -4,35 +4,35 @@ interface HeadersObject {
     [key: string]: string;
 }
 export default class Networks {
-    url: string | URL;
-    method: string;
-    Headers: any;
-    type: string;
-    body?: string;
-    fetch: any;
-    isGetResult: boolean;
-    timeout: number;
-    timer: NodeJS.Timeout | undefined;
-    data: {};
-    redirect: string;
-    constructor(data: NetworksConfigType);
-    get config(): NetworksConfigType;
-    getfetch(): Promise<Response | boolean>;
-    returnResult(): Promise<Response>;
-    /** 最终地址（跟随重定向） */
-    getLongLink(): Promise<string>;
-    /** 获取首个302 */
-    getLocation(): Promise<string>;
-    /** 获取数据并处理数据的格式化，默认json */
-    getData(new_fetch?: string): Promise<any | boolean>;
-    /** 获取响应头 */
-    getHeaders(): Promise<HeadersObject | null>;
-    /** 一次性获取响应头和响应体 */
-    getHeadersAndData(): Promise<object>;
-    Tojson(): Promise<any>;
-    ToText(): Promise<void>;
-    ToArrayBuffer(): Promise<void>;
-    ToBlob(): Promise<void>;
-    timeoutPromise(timeout: number): Promise<Response>;
+  url: string | URL;
+  method: string;
+  Headers: any;
+  type: string;
+  body?: string;
+  fetch: any;
+  isGetResult: boolean;
+  timeout: number;
+  timer: NodeJS.Timeout | undefined;
+  data: {};
+  redirect: string;
+  constructor(data: NetworksConfigType);
+  get config(): NetworksConfigType;
+  getfetch(): Promise<Response | boolean>;
+  returnResult(): Promise<Response>;
+  /** 最终地址（跟随重定向） */
+  getLongLink(): Promise<string>;
+  /** 获取首个302 */
+  getLocation(): Promise<string>;
+  /** 获取数据并处理数据的格式化，默认json */
+  getData(new_fetch?: string): Promise<any | boolean>;
+  /** 获取响应头 */
+  getHeaders(): Promise<HeadersObject | null>;
+  /** 一次性获取响应头和响应体 */
+  getHeadersAndData(): Promise<object>;
+  Tojson(): Promise<any>;
+  ToText(): Promise<void>;
+  ToArrayBuffer(): Promise<void>;
+  ToBlob(): Promise<void>;
+  timeoutPromise(timeout: number): Promise<Response>;
 }
 export {};

package/lib/model/networks.js

@@ -1,224 +1,230 @@
 import fetch, { Response } from 'node-fetch';
 import { logger } from '../model/index.js';
+const controller = new AbortController();
 export default class Networks {
-    url;
-    method;
-    Headers;
-    type;
-    body;
-    fetch;
-    isGetResult;
-    timeout;
-    timer;
-    data;
-    redirect;
-    constructor(data) {
-        this.Headers = new Headers();
-        if (data.headers && Object.keys(data.headers).length > 0) {
-            for (const [key, value] of Object.entries(data.headers)) {
-                this.Headers.append(key, value);
-            }
-        }
-        else
-            this.Headers = {};
-        this.url = data.url || '';
-        this.type = data.type || 'json';
-        this.method = data.method || 'GET';
-        this.body = data.body || ''; // 用于POST请求
-        this.data = {};
-        this.timeout = data.timeout || 15000;
-        this.isGetResult = false;
-        this.timer = undefined;
-        this.redirect = 'follow'; // 默认跟随重定向
-    }
-    get config() {
-        let data = {
-            headers: this.Headers,
-            method: this.method,
-        };
-        if (this.method === 'POST') {
-            data = { ...data, body: JSON.stringify(this.body) || '' };
-        }
-        return data;
-    }
-    async getfetch() {
-        try {
-            const result = await this.returnResult();
-            if (result.status === 504) {
-                return result;
-            }
-            this.isGetResult = true;
-            return result;
-        }
-        catch (error) {
-            logger.info(error);
-            return false;
-        }
+  url;
+  method;
+  Headers;
+  type;
+  body;
+  fetch;
+  isGetResult;
+  timeout;
+  timer;
+  data;
+  redirect;
+  constructor(data) {
+    this.Headers = new Headers();
+    if (data.headers && Object.keys(data.headers).length > 0) {
+      for (const [key, value] of Object.entries(data.headers)) {
+        this.Headers.append(key, value);
+      }
     }
-    async returnResult() {
-        return await fetch(this.url, this.config);
+    else
+      this.Headers = {};
+    this.url = data.url || '';
+    this.type = data.type || 'json';
+    this.method = data.method || 'GET';
+    this.body = data.body || ''; // 用于POST请求
+    this.data = {};
+    this.timeout = data.timeout || 15000;
+    this.isGetResult = false;
+    this.timer = undefined;
+    this.redirect = 'follow'; // 默认跟随重定向
+  }
+  get config() {
+    let data = {
+      headers: this.Headers,
+      method: this.method
+    };
+    if (this.method === 'POST') {
+      data = { ...data, body: JSON.stringify(this.body) || '' };
     }
-    /** 最终地址（跟随重定向） */
-    async getLongLink() {
-        try {
-            const result = await this.returnResult();
-            return result.url;
-        }
-        catch (error) {
-            logger.error(error);
-            return '';
-        }
+    return data;
+  }
+  async getfetch() {
+    try {
+      const result = await this.returnResult();
+      if (result.status === 504) {
+        return result;
+      }
+      this.isGetResult = true;
+      return result;
     }
-    /** 获取首个302 */
-    async getLocation() {
-        try {
-            const response = await fetch(this.url, {
-                method: 'GET',
-                redirect: 'manual', // 不跟随重定向
-            });
-            // 取location返回
-            return response.headers.get('location');
-        }
-        catch (error) {
-            logger.error(error);
-            return '';
-        }
+    catch (error) {
+      logger.info(error);
+      return false;
     }
-    /** 获取数据并处理数据的格式化，默认json */
-    async getData(new_fetch = '') {
-        try {
-            if (!new_fetch) {
-                const result = await this.returnResult();
-                if (result.status === 504) {
-                    return result;
-                }
-                this.fetch = result;
-                this.isGetResult = true;
-            }
-            else {
-                this.fetch = new_fetch;
-            }
-            switch (this.type) {
-                case 'json':
-                    await this.Tojson();
-                    break;
-                case 'text':
-                    await this.ToText();
-                    break;
-                case 'arrayBuffer':
-                    await this.ToArrayBuffer();
-                    break;
-                case 'blob':
-                    await this.ToBlob();
-                    break;
-            }
-            return this.fetch;
-        }
-        catch (error) {
-            logger.error(error);
-            return false;
-        }
+  }
+  async returnResult() {
+    return await fetch(this.url, this.config);
+  }
+  /** 最终地址（跟随重定向） */
+  async getLongLink() {
+    try {
+      const result = await this.returnResult();
+      return result.url;
     }
-    /** 获取响应头 */
-    async getHeaders() {
-        try {
-            this.fetch = await this.returnResult();
-            if (this.fetch) {
-                if (this.fetch.headers) {
-                    const headers = this.fetch.headers;
-                    const headersObject = {};
-                    for (const [key, value] of headers.entries()) {
-                        headersObject[key] = value;
-                    }
-                    return headersObject;
-                }
-                else {
-                    logger.error('未获取到响应头');
-                    return null;
-                }
-            }
-            else {
-                logger.error('未获取到响应对象');
-                return null;
-            }
-        }
-        catch (error) {
-            logger.error('获取响应头失败:', error);
-            return null;
-        }
+    catch (error) {
+      logger.error(error);
+      return '';
     }
-    /** 一次性获取响应头和响应体 */
-    async getHeadersAndData() {
-        try {
-            // 发起网络请求获取响应对象
-            this.fetch = await this.returnResult();
-            // 初始化响应头和响应数据
-            let headers = null;
-            let data = null;
-            if (this.fetch) {
-                // 获取响应头
-                if (this.fetch.headers) {
-                    headers = {};
-                    const fetchHeaders = this.fetch.headers;
-                    for (const [key, value] of fetchHeaders.entries()) {
-                        headers[key] = value;
-                    }
-                }
-                else {
-                    logger.error('未获取到响应头');
-                }
-                // 获取响应数据
-                switch (this.type) {
-                    case 'json':
-                        data = await this.fetch.json();
-                        break;
-                    case 'text':
-                        data = await this.fetch.text();
-                        break;
-                    case 'arrayBuffer':
-                        data = await this.ToArrayBuffer();
-                        break;
-                    case 'blob':
-                        data = await this.ToBlob();
-                        break;
-                }
-            }
-            else {
-                logger.error('未获取到响应对象');
-            }
-            return { headers, data };
-        }
-        catch (error) {
-            logger.error('获取响应头和数据失败:', error);
-            return { headers: null, data: null };
-        }
+  }
+  /** 获取首个302 */
+  async getLocation() {
+    try {
+      const response = await fetch(this.url, {
+        method: 'GET',
+        redirect: 'manual' // 不跟随重定向
+      });
+      // 取location返回
+      return response.headers.get('location');
+    }
+    catch (error) {
+      logger.error(error);
+      return '';
+    }
+  }
+  /** 获取数据并处理数据的格式化，默认json */
+  async getData(new_fetch = '') {
+    try {
+      if (!new_fetch) {
+        const result = await this.returnResult();
+        if (result.status === 504) {
+          return result;
+        }
+        if (result.status === 429) {
+          logger.warn('HTTP 响应状态码: 429');
+          throw new Error('ratelimit triggered, 触发 https://www.douyin.com/ 的速率限制！！！');
+        }
+        this.fetch = result;
+        this.isGetResult = true;
+      }
+      else {
+        this.fetch = new_fetch;
+      }
+      switch (this.type) {
+      case 'json':
+        await this.Tojson();
+        break;
+      case 'text':
+        await this.ToText();
+        break;
+      case 'arrayBuffer':
+        await this.ToArrayBuffer();
+        break;
+      case 'blob':
+        await this.ToBlob();
+        break;
+      default:
+      }
+      return this.fetch;
     }
-    async Tojson() {
-        if (this.fetch.headers.get('content-type').includes('json')) {
-            this.fetch = await this.fetch.json();
+    catch (error) {
+      logger.error(error);
+      return false;
+    }
+  }
+  /** 获取响应头 */
+  async getHeaders() {
+    try {
+      this.fetch = await this.returnResult();
+      if (this.fetch) {
+        if (this.fetch.headers) {
+          const headers = this.fetch.headers;
+          const headersObject = {};
+          for (const [key, value] of headers.entries()) {
+            headersObject[key] = value;
+          }
+          return headersObject;
         }
         else {
-            this.fetch = await this.fetch.text();
-            this.type = 'text';
-        }
+          logger.error('未获取到响应头');
+          return null;
+        }
+      }
+      else {
+        logger.error('未获取到响应对象');
+        return null;
+      }
+    }
+    catch (error) {
+      logger.error('获取响应头失败:', error);
+      return null;
     }
-    async ToText() {
-        this.fetch = await this.fetch.text();
+  }
+  /** 一次性获取响应头和响应体 */
+  async getHeadersAndData() {
+    try {
+      // 发起网络请求获取响应对象
+      this.fetch = await this.returnResult();
+      // 初始化响应头和响应数据
+      let headers = null;
+      let data = null;
+      if (this.fetch) {
+        // 获取响应头
+        if (this.fetch.headers) {
+          headers = {};
+          const fetchHeaders = this.fetch.headers;
+          for (const [key, value] of fetchHeaders.entries()) {
+            headers[key] = value;
+          }
+        }
+        else {
+          logger.error('未获取到响应头');
+        }
+        // 获取响应数据
+        switch (this.type) {
+        case 'json':
+          data = await this.fetch.json();
+          break;
+        case 'text':
+          data = await this.fetch.text();
+          break;
+        case 'arrayBuffer':
+          data = await this.ToArrayBuffer();
+          break;
+        case 'blob':
+          data = await this.ToBlob();
+          break;
+        default:
+        }
+      }
+      else {
+        logger.error('未获取到响应对象');
+      }
+      return { headers, data };
     }
-    async ToArrayBuffer() {
-        this.fetch = await this.fetch.arrayBuffer();
+    catch (error) {
+      logger.error('获取响应头和数据失败:', error);
+      return { headers: null, data: null };
     }
-    async ToBlob() {
-        this.fetch = await this.fetch.blob();
+  }
+  async Tojson() {
+    if (this.fetch.headers.get('content-type').includes('json')) {
+      this.fetch = await this.fetch.json();
     }
-    timeoutPromise(timeout) {
-        const controller = new AbortController();
-        return new Promise((resolve, reject) => {
-            this.timer = setTimeout(() => {
-                logger.info('执行力');
-                controller.abort();
-                resolve(new Response('timeout', { status: 504, statusText: 'timeout' }));
-            }, timeout);
-        });
+    else {
+      this.fetch = await this.fetch.text();
+      this.type = 'text';
     }
+  }
+  async ToText() {
+    this.fetch = await this.fetch.text();
+  }
+  async ToArrayBuffer() {
+    this.fetch = await this.fetch.arrayBuffer();
+  }
+  async ToBlob() {
+    this.fetch = await this.fetch.blob();
+  }
+  timeoutPromise(timeout) {
+    return new Promise((resolve, reject) => {
+      this.timer = setTimeout(() => {
+        logger.info('执行力');
+        controller.abort();
+        resolve(new Response('timeout', { status: 504, statusText: 'timeout' }));
+      }, timeout);
+    });
+  }
 }

package/lib/server/client.d.ts

@@ -6,18 +6,18 @@ interface initClientParams {
     bilibili: string;
 }
 export declare class client {
-    private readonly douyin;
-    private readonly bilibili;
-    /**
+  private readonly douyin;
+  private readonly bilibili;
+  /**
      *
      * @param cookies 包含抖音和B站cookie的参数对象
      */
-    constructor(cookies: initClientParams);
-    /**
+  constructor(cookies: initClientParams);
+  /**
      * 初始化 fastify 实例
      * @param log 是否启用日志
      * @returns fastify 实例
      */
-    initServer(log?: boolean): Promise<FastifyInstance>;
+  initServer(log?: boolean): Promise<FastifyInstance>;
 }
 export {};