inki-music-api 2.0.0

package/README.md

@@ -0,0 +1,133 @@
+# inki-music-api
+
+`inki-music-api` 是基于 TypeScript + axios 的 lx-music 自定义源封装包，核心导出 `MusicApi` class，支持：
+
+- 统一配置化初始化
+- 必须显式加载 source（本地/远程/代码）
+- 外部源文件/代码动态加载
+- `musicUrl` 走源脚本，其它接口走内置聚合实现
+
+## 安装
+
+```bash
+npm install
+```
+
+## 快速开始
+
+```js
+const { MusicApi } = require('inki-music-api');
+
+async function main() {
+  const api = new MusicApi();
+  await api.loadSourceFromFile('./your-source.js');
+
+  const result = await api.search('kw', '周杰伦', { page: 1, limit: 5 });
+  const first = result.list[0];
+
+  const url = await api.getMusicUrl('kw', first, '128k');
+  const lyric = await api.getLyric('kw', first);
+  const pic = await api.getPic('kw', first);
+  const hot = await api.getHot('kw', { page: 1, limit: 5 });
+  const rank = await api.getRank('kw', 'hot', { page: 1, limit: 5 });
+
+  console.log(url, lyric, pic, hot.total, rank.total);
+}
+
+main();
+```
+
+## 配置项
+
+```ts
+type MusicApiConfig = {
+  initTimeout?: number;
+  requestTimeout?: number;
+  followMaxRedirects?: number;
+  rejectUnauthorized?: boolean;
+  retry?: {
+    retries?: number;
+    retryDelayMs?: number;
+    retryStatusCodes?: number[];
+    retryErrorCodes?: string[];
+  };
+  cache?: {
+    enabled?: boolean;
+    ttlMs?: number;
+    maxEntries?: number;
+  };
+};
+```
+
+默认配置：
+
+```js
+{
+  initTimeout: 15000,
+  requestTimeout: 15000,
+  followMaxRedirects: 5,
+  rejectUnauthorized: false,
+  retry: {
+    retries: 2,
+    retryDelayMs: 200,
+    retryStatusCodes: [429, 500, 502, 503, 504],
+    retryErrorCodes: ['ECONNRESET', 'ECONNABORTED', 'ETIMEDOUT', 'EAI_AGAIN']
+  },
+  cache: {
+    enabled: true,
+    ttlMs: 30000,
+    maxEntries: 1000
+  }
+}
+```
+
+## 加载外部源
+
+```js
+const api = new MusicApi();
+
+await api.loadSourceFromFile('./my-source.js');
+// 或
+await api.loadSourceFromCode(sourceCode);
+```
+
+## API
+
+- `init()`
+- `updateConfig(partialConfig)`
+- `loadSourceFromFile(filePath)`
+- `loadSourceFromCode(code)`
+- `loadSourceFromRemote(url, options)`
+- `loadSourceFormRemote(url, options)`
+- `loadSourceFormRmote(url, options)`
+- `setSource(sourceInstance)`
+- `getSupportedPlatforms()`
+- `getCapabilities(source?)`
+- `getSupportedSourceList()`
+- `search(source, keywords, { page, limit })`
+- `searchMusic({ name, singer, source, limit })`
+- `findMusic({ name, singer, albumName, interval, source })`
+- `getMusicUrl(source, musicInfo, quality)`
+- `getLyric(source, musicInfo)`
+- `getPic(source, musicInfo)`
+- `getHot(source, { page, limit })`
+- `getRank(source, rankType, { page, limit })`
+- `getComment(source, musicInfo, { page, limit })`
+- `getHotComment(source, musicInfo, { page, limit })`
+- `getMusicDetailPageUrl(source, musicInfo)`
+- `getSongListTags(source)`
+- `getSongList(source, { sortId, tagId, page, limit })`
+- `getSongListDetail(source, listId, { page, limit })`
+- `dispatch(source, action, info)`
+- `clearCache()`
+
+## 开发命令
+
+```bash
+npm run build
+npm run typecheck
+npm run lint
+npm run format:check
+npm test
+npm publish
+```

package/dist/api-error.d.ts

@@ -0,0 +1,13 @@
+import type { ApiErrorCode } from './types';
+export declare class ApiError extends Error {
+    code: ApiErrorCode;
+    statusCode?: number;
+    source?: string;
+    cause?: unknown;
+    constructor(code: ApiErrorCode, message: string, options?: {
+        statusCode?: number;
+        source?: string;
+        cause?: unknown;
+    });
+}
+export declare const toApiError: (error: unknown, fallbackCode: ApiErrorCode, fallbackMessage: string, source?: string) => ApiError;

package/dist/api-error.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toApiError = exports.ApiError = void 0;
+class ApiError extends Error {
+    constructor(code, message, options = {}) {
+        super(message);
+        this.name = 'ApiError';
+        this.code = code;
+        this.statusCode = options.statusCode;
+        this.source = options.source;
+        this.cause = options.cause;
+    }
+}
+exports.ApiError = ApiError;
+const toApiError = (error, fallbackCode, fallbackMessage, source) => {
+    if (error instanceof ApiError)
+        return error;
+    if (error instanceof Error) {
+        return new ApiError(fallbackCode, error.message || fallbackMessage, {
+            source,
+            cause: error,
+        });
+    }
+    return new ApiError(fallbackCode, fallbackMessage, {
+        source,
+        cause: error,
+    });
+};
+exports.toApiError = toApiError;

package/dist/http-client.d.ts

@@ -0,0 +1,16 @@
+import type { RequestOptions, RequestResponse, RetryConfig } from './types';
+export type RequestCallback = (err: Error | null, resp?: RequestResponse) => void;
+export interface HttpClientConfig {
+    timeout: number;
+    followMaxRedirects: number;
+    rejectUnauthorized: boolean;
+    retry: Required<RetryConfig>;
+}
+export declare class HttpClient {
+    private config;
+    constructor(config: HttpClientConfig);
+    updateConfig(config: Partial<HttpClientConfig>): void;
+    request(url: string, options: RequestOptions | RequestCallback, callback?: RequestCallback): void;
+    requestPromise<T = unknown>(url: string, options?: RequestOptions): Promise<RequestResponse<T>>;
+    private wait;
+}

package/dist/http-client.js

@@ -0,0 +1,110 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+const http_1 = require("http");
+const https_1 = require("https");
+const url_1 = require("url");
+const api_error_1 = require("./api-error");
+class HttpClient {
+    constructor(config) {
+        this.config = config;
+    }
+    updateConfig(config) {
+        this.config = { ...this.config, ...config };
+    }
+    request(url, options, callback) {
+        let requestOptions = {};
+        let cb;
+        if (typeof options === 'function') {
+            cb = options;
+        }
+        else {
+            requestOptions = options;
+            cb = callback;
+        }
+        this.requestPromise(url, requestOptions).then((resp) => cb(null, resp), (err) => cb(err));
+    }
+    async requestPromise(url, options = {}) {
+        const { method = 'GET', headers = {}, body, form, timeout = this.config.timeout, follow_max = this.config.followMaxRedirects, rejectUnauthorized = this.config.rejectUnauthorized, } = options;
+        const requestConfig = {
+            url,
+            method: method.toUpperCase(),
+            headers,
+            timeout,
+            maxRedirects: follow_max,
+            validateStatus: () => true,
+            responseType: 'text',
+            httpAgent: new http_1.Agent({ keepAlive: true }),
+            httpsAgent: new https_1.Agent({ keepAlive: true, rejectUnauthorized }),
+        };
+        if (form) {
+            const params = new url_1.URLSearchParams();
+            for (const [key, value] of Object.entries(form))
+                params.append(key, String(value));
+            requestConfig.data = params.toString();
+            requestConfig.headers = {
+                ...headers,
+                'Content-Type': 'application/x-www-form-urlencoded',
+            };
+        }
+        else if (body != null) {
+            requestConfig.data = body;
+            requestConfig.headers = {
+                ...headers,
+                'Content-Type': headers['Content-Type'] || 'application/json',
+            };
+        }
+        const maxRetry = Math.max(0, this.config.retry.retries);
+        const retryStatusCodes = new Set(this.config.retry.retryStatusCodes);
+        const retryErrorCodes = new Set(this.config.retry.retryErrorCodes);
+        const baseDelay = Math.max(0, this.config.retry.retryDelayMs);
+        for (let attempt = 0; attempt <= maxRetry; attempt += 1) {
+            try {
+                const result = await axios_1.default.request(requestConfig);
+                if (attempt < maxRetry && retryStatusCodes.has(result.status)) {
+                    await this.wait(baseDelay * (attempt + 1));
+                    continue;
+                }
+                const raw = result.data ?? '';
+                let parsed;
+                try {
+                    parsed = JSON.parse(raw);
+                }
+                catch {
+                    parsed = raw;
+                }
+                return {
+                    statusCode: result.status,
+                    headers: result.headers,
+                    body: parsed,
+                };
+            }
+            catch (error) {
+                const err = error;
+                if (attempt < maxRetry && err.code && retryErrorCodes.has(err.code)) {
+                    await this.wait(baseDelay * (attempt + 1));
+                    continue;
+                }
+                if (err.code === 'ECONNABORTED') {
+                    throw new api_error_1.ApiError('E_TIMEOUT', err.message || 'request timeout', {
+                        cause: err,
+                    });
+                }
+                throw new api_error_1.ApiError('E_REQUEST_FAILED', err.message || 'request failed', {
+                    cause: err,
+                });
+            }
+        }
+        throw new api_error_1.ApiError('E_REQUEST_FAILED', 'request failed');
+    }
+    async wait(ms) {
+        if (!ms)
+            return;
+        await new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}
+exports.HttpClient = HttpClient;

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { ApiError } from './api-error';
+export { MusicApi } from './music-api';
+export { SourceLoader, SourceInstance } from './source-loader';
+export { SUPPORTED_PLATFORMS } from './types';
+export type { ApiErrorCode, CacheConfig, CommentItem, CommentResult, MusicApiConfig, MusicInfo, MusicLyric, MusicQuality, MusicTypeInfo, RankResult, RemoteSourceOptions, RetryConfig, SearchOptions, SearchResult, SongListDetailInfo, SongListDetailResult, SongListItem, SongListResult, SongListTag, SongListTagGroup, SongListTagResult, SourceCapabilities, SourceInfo, SourceKey, SupportedPlatform, } from './types';

package/dist/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUPPORTED_PLATFORMS = exports.SourceInstance = exports.SourceLoader = exports.MusicApi = exports.ApiError = void 0;
+var api_error_1 = require("./api-error");
+Object.defineProperty(exports, "ApiError", { enumerable: true, get: function () { return api_error_1.ApiError; } });
+var music_api_1 = require("./music-api");
+Object.defineProperty(exports, "MusicApi", { enumerable: true, get: function () { return music_api_1.MusicApi; } });
+var source_loader_1 = require("./source-loader");
+Object.defineProperty(exports, "SourceLoader", { enumerable: true, get: function () { return source_loader_1.SourceLoader; } });
+Object.defineProperty(exports, "SourceInstance", { enumerable: true, get: function () { return source_loader_1.SourceInstance; } });
+var types_1 = require("./types");
+Object.defineProperty(exports, "SUPPORTED_PLATFORMS", { enumerable: true, get: function () { return types_1.SUPPORTED_PLATFORMS; } });

package/dist/lx-project-api.d.ts

@@ -0,0 +1,17 @@
+import type { HttpClient } from './http-client';
+import type { CommentResult, MusicInfo, MusicLyric, RankResult, SearchResult, SongListDetailResult, SongListResult, SongListTagResult, SourceKey } from './types';
+export declare class LxProjectApi {
+    private httpClient;
+    constructor(httpClient: HttpClient);
+    private http;
+    search(source: SourceKey, keywords: string, page?: number, limit?: number): Promise<SearchResult>;
+    hot(source: SourceKey, page?: number, limit?: number): Promise<RankResult>;
+    rank(source: SourceKey, rankType: string, page?: number, limit?: number): Promise<RankResult>;
+    lyric(source: SourceKey, musicInfo: MusicInfo): Promise<MusicLyric>;
+    pic(source: SourceKey, musicInfo: MusicInfo): Promise<string | null>;
+    comment(source: SourceKey, musicInfo: MusicInfo, page?: number, limit?: number, hot?: boolean): Promise<CommentResult>;
+    getMusicDetailPageUrl(source: SourceKey, musicInfo: MusicInfo): string | null;
+    songListTags(source: SourceKey): Promise<SongListTagResult>;
+    songList(source: SourceKey, sortId?: string, tagId?: string, page?: number, limit?: number): Promise<SongListResult>;
+    songListDetail(source: SourceKey, listId: string, page?: number, limit?: number): Promise<SongListDetailResult>;
+}