QLHazyCoder
266 lines
8.8 KiB
JavaScript
266 lines
8.8 KiB
JavaScript
// phone-sms/providers/nexsms.js - NexSMS provider registry adapter
|
||
(function attachNexSmsProvider(root, factory) {
|
||
root.PhoneSmsNexSmsProvider = factory();
|
||
})(typeof self !== 'undefined' ? self : globalThis, function createNexSmsProviderModule() {
|
||
const PROVIDER_ID = 'nexsms';
|
||
const DEFAULT_BASE_URL = 'https://api.nexsms.net';
|
||
const DEFAULT_SERVICE_CODE = 'ot';
|
||
const DEFAULT_SERVICE_LABEL = 'OpenAI';
|
||
const DEFAULT_COUNTRY_ID = 1;
|
||
const DEFAULT_COUNTRY_LABEL = 'Country #1';
|
||
const DEFAULT_REQUEST_TIMEOUT_MS = 20000;
|
||
|
||
function normalizeBaseUrl(value = '') {
|
||
const trimmed = String(value || '').trim() || DEFAULT_BASE_URL;
|
||
try {
|
||
return new URL(trimmed).toString().replace(/\/+$/, '');
|
||
} catch {
|
||
return DEFAULT_BASE_URL;
|
||
}
|
||
}
|
||
|
||
function normalizeText(value = '', fallback = '') {
|
||
return String(value || '').trim() || fallback;
|
||
}
|
||
|
||
function normalizeNexSmsCountryId(value, fallback = DEFAULT_COUNTRY_ID) {
|
||
const parsed = Math.floor(Number(value));
|
||
if (Number.isFinite(parsed) && parsed >= 0) {
|
||
return parsed;
|
||
}
|
||
const fallbackParsed = Math.floor(Number(fallback));
|
||
if (Number.isFinite(fallbackParsed) && fallbackParsed >= 0) {
|
||
return fallbackParsed;
|
||
}
|
||
return DEFAULT_COUNTRY_ID;
|
||
}
|
||
|
||
function normalizeNexSmsCountryLabel(value = '', fallback = DEFAULT_COUNTRY_LABEL) {
|
||
return normalizeText(value, fallback);
|
||
}
|
||
|
||
function normalizeNexSmsServiceCode(value = '', fallback = DEFAULT_SERVICE_CODE) {
|
||
const normalized = String(value || '').trim().toLowerCase().replace(/[^a-z0-9_-]+/g, '');
|
||
if (normalized) {
|
||
return normalized;
|
||
}
|
||
const fallbackNormalized = String(fallback || '').trim().toLowerCase().replace(/[^a-z0-9_-]+/g, '');
|
||
return fallbackNormalized || DEFAULT_SERVICE_CODE;
|
||
}
|
||
|
||
function normalizeNexSmsCountryOrder(value = []) {
|
||
const source = Array.isArray(value)
|
||
? value
|
||
: String(value || '')
|
||
.split(/[\r\n,，;；]+/)
|
||
.map((entry) => String(entry || '').trim())
|
||
.filter(Boolean);
|
||
const normalized = [];
|
||
const seen = new Set();
|
||
|
||
source.forEach((entry) => {
|
||
let id = -1;
|
||
let label = '';
|
||
if (entry && typeof entry === 'object' && !Array.isArray(entry)) {
|
||
id = normalizeNexSmsCountryId(entry.id ?? entry.countryId, -1);
|
||
label = normalizeText(entry.label ?? entry.countryLabel, '');
|
||
} else {
|
||
const text = String(entry || '').trim();
|
||
const structured = text.match(/^(\d+)\s*(?:[:|/-]\s*(.+))?$/);
|
||
id = normalizeNexSmsCountryId(structured?.[1] || text, -1);
|
||
label = normalizeText(structured?.[2], '');
|
||
}
|
||
if (id < 0 || seen.has(id)) {
|
||
return;
|
||
}
|
||
seen.add(id);
|
||
normalized.push({
|
||
id,
|
||
label: label || `Country #${id}`,
|
||
});
|
||
});
|
||
|
||
return normalized.slice(0, 20);
|
||
}
|
||
|
||
function resolveCountryCandidates(state = {}) {
|
||
const candidates = normalizeNexSmsCountryOrder(state?.nexSmsCountryOrder);
|
||
if (candidates.length) {
|
||
return candidates;
|
||
}
|
||
return [{
|
||
id: normalizeNexSmsCountryId(state?.nexSmsCountryId, DEFAULT_COUNTRY_ID),
|
||
label: normalizeNexSmsCountryLabel(state?.nexSmsCountryLabel, DEFAULT_COUNTRY_LABEL),
|
||
}];
|
||
}
|
||
|
||
function parsePayload(text) {
|
||
const trimmed = String(text || '').trim();
|
||
if (!trimmed) {
|
||
return '';
|
||
}
|
||
try {
|
||
return JSON.parse(trimmed);
|
||
} catch {
|
||
return trimmed;
|
||
}
|
||
}
|
||
|
||
function describePayload(raw) {
|
||
if (typeof raw === 'string') {
|
||
return raw.trim();
|
||
}
|
||
if (raw && typeof raw === 'object') {
|
||
const message = normalizeText(raw.message || raw.error || raw.msg || raw.statusText, '');
|
||
if (message) {
|
||
return message;
|
||
}
|
||
try {
|
||
return JSON.stringify(raw);
|
||
} catch {
|
||
return String(raw);
|
||
}
|
||
}
|
||
return String(raw || '').trim();
|
||
}
|
||
|
||
function isSuccessPayload(payload) {
|
||
return Boolean(payload && typeof payload === 'object' && !Array.isArray(payload) && Number(payload.code) === 0);
|
||
}
|
||
|
||
function resolveConfig(state = {}, deps = {}) {
|
||
return {
|
||
apiKey: normalizeText(state?.nexSmsApiKey),
|
||
baseUrl: normalizeBaseUrl(state?.nexSmsBaseUrl || DEFAULT_BASE_URL),
|
||
serviceCode: normalizeNexSmsServiceCode(state?.nexSmsServiceCode, DEFAULT_SERVICE_CODE),
|
||
fetchImpl: deps.fetchImpl || (typeof fetch === 'function' ? fetch.bind(globalThis) : null),
|
||
requestTimeoutMs: deps.requestTimeoutMs || DEFAULT_REQUEST_TIMEOUT_MS,
|
||
};
|
||
}
|
||
|
||
async function fetchPayload(config, path, actionLabel, options = {}) {
|
||
if (!config.fetchImpl) {
|
||
throw new Error('NexSMS 网络请求实现不可用。');
|
||
}
|
||
if (!config.apiKey) {
|
||
throw new Error('NexSMS API Key 缺失，请先在侧边栏保存接码 API Key。');
|
||
}
|
||
const controller = typeof AbortController === 'function' ? new AbortController() : null;
|
||
const timeoutId = controller
|
||
? setTimeout(() => controller.abort(), Number(config.requestTimeoutMs) || DEFAULT_REQUEST_TIMEOUT_MS)
|
||
: null;
|
||
|
||
try {
|
||
const method = String(options.method || 'GET').trim().toUpperCase() || 'GET';
|
||
const requestUrl = new URL(path.replace(/^\/+/, ''), `${config.baseUrl.replace(/\/+$/, '')}/`);
|
||
requestUrl.searchParams.set('apiKey', config.apiKey);
|
||
Object.entries(options.query || {}).forEach(([key, value]) => {
|
||
if (value === undefined || value === null || value === '') {
|
||
return;
|
||
}
|
||
requestUrl.searchParams.set(key, String(value));
|
||
});
|
||
const headers = {
|
||
Accept: 'application/json',
|
||
...(options.headers && typeof options.headers === 'object' ? options.headers : {}),
|
||
};
|
||
const requestInit = {
|
||
method,
|
||
headers,
|
||
signal: controller?.signal,
|
||
};
|
||
if (method !== 'GET' && method !== 'HEAD' && options.body !== undefined) {
|
||
requestInit.body = typeof options.body === 'string'
|
||
? options.body
|
||
: JSON.stringify(options.body);
|
||
if (!requestInit.headers['Content-Type']) {
|
||
requestInit.headers['Content-Type'] = 'application/json';
|
||
}
|
||
}
|
||
const response = await config.fetchImpl(requestUrl.toString(), requestInit);
|
||
const text = await response.text();
|
||
const payload = parsePayload(text);
|
||
if (!response.ok) {
|
||
const error = new Error(`${actionLabel}失败：${describePayload(payload) || response.status}`);
|
||
error.payload = payload;
|
||
error.status = response.status;
|
||
throw error;
|
||
}
|
||
return payload;
|
||
} catch (error) {
|
||
if (error?.name === 'AbortError') {
|
||
throw new Error(`${actionLabel}超时。`);
|
||
}
|
||
throw error;
|
||
} finally {
|
||
if (timeoutId) {
|
||
clearTimeout(timeoutId);
|
||
}
|
||
}
|
||
}
|
||
|
||
async function fetchBalance(state = {}, deps = {}) {
|
||
const config = resolveConfig(state, deps);
|
||
const payload = await fetchPayload(config, '/api/user/getBalance', 'NexSMS get balance');
|
||
if (!isSuccessPayload(payload)) {
|
||
throw new Error(`NexSMS get balance 失败：${describePayload(payload) || 'empty response'}`);
|
||
}
|
||
const balance = Number(payload?.data?.balance);
|
||
return {
|
||
balance: Number.isFinite(balance) ? balance : null,
|
||
raw: payload,
|
||
};
|
||
}
|
||
|
||
async function fetchPrices(state = {}, countryConfig = {}, deps = {}) {
|
||
const config = resolveConfig(state, deps);
|
||
const countryId = normalizeNexSmsCountryId(countryConfig?.id, DEFAULT_COUNTRY_ID);
|
||
return fetchPayload(config, '/api/getCountryByService', 'NexSMS getCountryByService', {
|
||
query: {
|
||
serviceCode: config.serviceCode,
|
||
countryId,
|
||
},
|
||
});
|
||
}
|
||
|
||
function createProvider(deps = {}) {
|
||
const providerDeps = {
|
||
fetchImpl: deps.fetchImpl,
|
||
requestTimeoutMs: deps.requestTimeoutMs || DEFAULT_REQUEST_TIMEOUT_MS,
|
||
};
|
||
return {
|
||
id: PROVIDER_ID,
|
||
label: 'NexSMS',
|
||
defaultCountryId: DEFAULT_COUNTRY_ID,
|
||
defaultCountryLabel: DEFAULT_COUNTRY_LABEL,
|
||
defaultProduct: DEFAULT_SERVICE_LABEL,
|
||
defaultServiceCode: DEFAULT_SERVICE_CODE,
|
||
normalizeCountryId: normalizeNexSmsCountryId,
|
||
normalizeCountryLabel: normalizeNexSmsCountryLabel,
|
||
normalizeCountryOrder: normalizeNexSmsCountryOrder,
|
||
normalizeServiceCode: normalizeNexSmsServiceCode,
|
||
resolveCountryCandidates,
|
||
fetchBalance: (state) => fetchBalance(state, providerDeps),
|
||
fetchPrices: (state, countryConfig) => fetchPrices(state, countryConfig, providerDeps),
|
||
describePayload,
|
||
isSuccessPayload,
|
||
};
|
||
}
|
||
|
||
return {
|
||
PROVIDER_ID,
|
||
DEFAULT_BASE_URL,
|
||
DEFAULT_COUNTRY_ID,
|
||
DEFAULT_COUNTRY_LABEL,
|
||
DEFAULT_SERVICE_CODE,
|
||
DEFAULT_SERVICE_LABEL,
|
||
createProvider,
|
||
describePayload,
|
||
isSuccessPayload,
|
||
normalizeNexSmsCountryId,
|
||
normalizeNexSmsCountryLabel,
|
||
normalizeNexSmsCountryOrder,
|
||
normalizeNexSmsServiceCode,
|
||
};
|
||
});
|