ctan/esm/client-base.js

CTAN (Comprehensive TeX Archive Network) API client for Node.js

var _ClientBase_defaults, _ClientBase_validator, _Validator_ajv;
import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
import { default as Ajv } from 'ajv';
import { CtanRequestError, CtanResponseError } from "./errors.js";
import { fetch } from "./fetch.js";
export class ClientBase {
    constructor(base) {
        _ClientBase_defaults.set(this, void 0);
        _ClientBase_validator.set(this, void 0);
        if (base instanceof ClientBase) {
            __classPrivateFieldSet(this, _ClientBase_defaults, __classPrivateFieldGet(base, _ClientBase_defaults, "f"), "f");
            __classPrivateFieldSet(this, _ClientBase_validator, __classPrivateFieldGet(base, _ClientBase_validator, "f"), "f");
        }
        else {
            __classPrivateFieldSet(this, _ClientBase_defaults, { baseUrl: 'https://ctan.org', validate: true, ...base }, "f");
            __classPrivateFieldSet(this, _ClientBase_validator, new Validator(), "f");
        }
    }
    get defaults() {
        return __classPrivateFieldGet(this, _ClientBase_defaults, "f");
    }
    async get(endpoint, params, schema, config) {
        const { body, size, ...init } = {
            ...this.defaults,
            ...config,
            method: 'GET',
        };
        const url = new URL(endpoint, init.baseUrl);
        if (params !== null) {
            url.search = params.toString();
        }
        const { request, response, error } = await fetch(url.href, init);
        if (error !== undefined) {
            throw new CtanRequestError('Failed to request', request, {
                cause: error instanceof Error ? error : new Error(`${error}`),
            });
        }
        if (!response.ok) {
            throw new CtanResponseError(response.statusText, request, response);
        }
        try {
            const json = await response.json();
            if (config?.validate ?? false) {
                return json;
            }
            else {
                return __classPrivateFieldGet(this, _ClientBase_validator, "f").validate(schema, json);
            }
        }
        catch (error) {
            throw new CtanResponseError('Invalid response data', request, response, {
                cause: error instanceof Error ? error : new Error(`${error}`),
            });
        }
    }
}
_ClientBase_defaults = new WeakMap(), _ClientBase_validator = new WeakMap();
class Validator {
    constructor() {
        _Validator_ajv.set(this, void 0);
    }
    validate(schema, data) {
        __classPrivateFieldSet(this, _Validator_ajv, __classPrivateFieldGet(this, _Validator_ajv, "f") ?? new Ajv({ allowUnionTypes: true }), "f");
        if (!__classPrivateFieldGet(this, _Validator_ajv, "f").validate(schema, data)) {
            throw new Ajv.ValidationError(__classPrivateFieldGet(this, _Validator_ajv, "f").errors ?? []);
        }
        return data;
    }
}
_Validator_ajv = new WeakMap();
export function buildParams(data, keys, coerce = {
    AUTHORS: Boolean,
    FILES: Boolean,
    PKG: Boolean,
    PORTAL: Boolean,
    TOPICS: Boolean,
    drop: Array.from,
    ext: Boolean,
    'keep-url': Boolean,
    max: Number,
    offset: Number,
    ref: Boolean,
    wildcard: Boolean,
}) {
    const params = new URLSearchParams();
    if (data instanceof Object) {
        for (const key of keys) {
            if (key in data) {
                params.append(key, coerce[key]?.(data[key]) ?? data[key]);
            }
        }
    }
    return params;
}
export default ClientBase;