nurlresolver/dist/UrlResolver.js

url resolver for node

import { BaseUrlResolver } from "./BaseResolver.js";
import * as allResolverImports from "./allResolvers.js";
import debug from 'debug';
const _debug = debug('nurl:BaseUrlResolver');
export class UrlResolver {
    allResolvers;
    constructor() {
        //do filtering of the resolvers here
        this.allResolvers = Object.values(allResolverImports).filter((x) => x.prototype instanceof BaseUrlResolver);
    }
    /**
       *
       * @param {string} urlToResolve
       * @returns {string}
       */
    async resolve(urlToResolve, options = {}) {
        if (!urlToResolve)
            return [];
        if (Array.isArray(urlToResolve) && urlToResolve.length === 0)
            return [];
        const _options = Object.assign({
            timeout: 30
        }, options);
        const instance = this;
        const _allResolvers = _options.customResolvers ? [...this.allResolvers, ..._options.customResolvers] : this.allResolvers;
        const _filteredResolvers = _allResolvers.filter(j => !_options.ignoreResolvers?.some(r => r.test(j.name)));
        let result = [];
        let timeoutPointer;
        const timeoutPromise = new Promise(resolve => {
            timeoutPointer = setTimeout(resolve, _options.timeout * 1000);
        });
        const actualPromise = _();
        await Promise.race([timeoutPromise, actualPromise]);
        if (timeoutPointer)
            clearTimeout(timeoutPointer);
        return result;
        async function _() {
            const urlsToResolve = typeof urlToResolve === "string" ? [urlToResolve] : urlToResolve;
            const promises = [];
            for (const iteratorurl of urlsToResolve) {
                for (const resolver of _filteredResolvers) {
                    const element = new resolver();
                    const promise = element.resolve(iteratorurl, _options, instance).then(resolvedItems => result = [...result, ...resolvedItems]);
                    promises.push(promise);
                }
            }
            await Promise.all(promises);
        }
    }
    /**
       * Resolve recursively all the urls until all not fetched. It's a heavy call and
       * can take minutes to resolve if the sources are slow to respond.
       * @param {string} urlToResolve
       * @returns {collection of resolved links}
       */
    async resolveRecursive(urlToResolve, options = {}) {
        const _options = Object.assign({
            timeout: 30
        }, options);
        const myPlayableResources = [];
        const visitedUrls = [];
        const timeoutPromise = new Promise(resolvedPromise => setTimeout(resolvedPromise, _options.timeout * 1000));
        const explode = async (urlToVisit) => {
            if (visitedUrls.includes(urlToVisit))
                return;
            visitedUrls.push(urlToVisit);
            _debug(urlToVisit);
            const resolvedUrls = await this.resolve(urlToVisit, options);
            if (resolvedUrls) {
                const p = [];
                for (const resolvedUrl of resolvedUrls) {
                    resolvedUrl.isPlayable ? myPlayableResources.push(resolvedUrl) : p.push(explode(resolvedUrl.link));
                }
                await Promise.all(p);
            }
        };
        const urlsToResolve = typeof urlToResolve === "string" ? [urlToResolve] : urlToResolve;
        const actualPromise = Promise.all(urlsToResolve.map(explode));
        await Promise.race([timeoutPromise, actualPromise]);
        return myPlayableResources;
    }
}
//# sourceMappingURL=UrlResolver.js.map