@alova/wormhole
Version:
More modern openAPI generating solution for alova.js
139 lines (138 loc) • 4.27 kB
JavaScript
;
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.fetchData = fetchData;
exports.removeUndefined = removeUndefined;
exports.isEmpty = isEmpty;
exports.capitalizeFirstLetter = capitalizeFirstLetter;
exports.existsPromise = existsPromise;
exports.resolveConfigFile = resolveConfigFile;
exports.strHashCode = strHashCode;
exports.getType = getType;
const promises_1 = __importDefault(require("node:fs/promises"));
const node_path_1 = __importDefault(require("node:path"));
const alova_1 = require("alova");
const fetch_1 = __importDefault(require("alova/fetch"));
const logger_1 = require("../helper/logger");
async function fetchData(url) {
return (0, alova_1.createAlova)({ requestAdapter: (0, fetch_1.default)() })
.Get(url)
.then((response) => {
if (!response.ok) {
throw logger_1.logger.throwError(`HTTP error! status: ${response.status}`, {
url,
});
}
return response.text();
});
}
// Remove all empty undefined values
function removeUndefined(obj) {
const defaultObject = Array.isArray(obj) ? [] : {};
if (typeof obj !== 'object' || !obj) {
return obj;
}
return Object.keys(obj).reduce((result, key) => {
const value = removeUndefined(obj[key]);
if (value !== undefined) {
result[key] = value;
}
return result;
}, defaultObject);
}
function isEmpty(value) {
return value === null || value === undefined || value === '';
}
function capitalizeFirstLetter(str) {
if (!str)
return str;
return str.charAt(0).toUpperCase() + str.slice(1);
}
async function existsPromise(path, mode) {
try {
await promises_1.default.access(path, mode);
return true;
}
catch {
return false;
}
}
async function resolveConfigFile(projectPath) {
const extensions = ['js', 'cjs', 'mjs', 'ts', 'mts', 'cts'];
for (const ext of extensions) {
const configFile = node_path_1.default.join(projectPath, `alova.config.${ext}`);
if (await existsPromise(configFile)) {
return configFile;
}
}
return null;
}
function strHashCode(str) {
let hash = 0;
let i;
let chr;
if (str.length === 0) {
return hash;
}
for (i = 0; i < str.length; i += 1) {
chr = str.charCodeAt(i);
hash = (hash << 5) - hash + chr;
hash |= 0; // Convert to 32bit integer
}
return hash;
}
function getType(value) {
// 处理 null 和 undefined
if (value === null)
return 'null';
if (value === undefined)
return 'undefined';
// 基本类型
const type = typeof value;
if (type !== 'object' && type !== 'function') {
if (type === 'number' && Number.isNaN(value))
return 'NaN';
if (type === 'number' && !Number.isFinite(value)) {
return value > 0 ? 'Infinity' : '-Infinity';
}
if (type === 'number' && Number.parseInt(`${value}`, 10) === value) {
return 'integer';
}
return type;
}
// 特殊对象类型
if (Array.isArray(value))
return 'Array';
if (value instanceof Date)
return 'Date';
if (value instanceof RegExp)
return 'RegExp';
if (value instanceof Map)
return 'Map';
if (value instanceof Set)
return 'Set';
if (value instanceof Promise)
return 'Promise';
if (value instanceof Error)
return 'Error';
// 函数类型
if (typeof value === 'function') {
if (value.constructor.name === 'AsyncFunction')
return 'AsyncFunction';
if (value.constructor.name === 'GeneratorFunction')
return 'GeneratorFunction';
return 'Function';
}
// 其他对象类型
const tag = Object.prototype.toString.call(value).slice(8, -1);
if (tag !== 'Object')
return tag;
// 自定义类实例
if (value.constructor && value.constructor !== Object) {
return `Class (${value.constructor.name})`;
}
// 普通对象
return 'Object';
}