@open-audio-stack/core/build/classes/Manager.js

Open-source audio plugin management software

import { apiJson } from '../helpers/api.js';
import { Config } from './Config.js';
import { Package } from './Package.js';
import { Base } from './Base.js';
export class Manager extends Base {
    config;
    packages;
    type;
    constructor(type, config) {
        super();
        this.config = new Config(config);
        this.packages = new Map();
        this.type = type;
    }
    addPackage(pkg) {
        let pkgExisting = this.packages.get(pkg.slug);
        if (!pkgExisting) {
            pkgExisting = new Package(pkg.slug);
            this.packages.set(pkg.slug, pkgExisting);
        }
        for (const [version, pkgVersion] of pkg.versions) {
            pkgExisting.addVersion(version, pkgVersion);
        }
    }
    filter(method) {
        const results = [];
        for (const [, pkg] of this.packages) {
            const pkgVersion = pkg.getVersionLatest();
            if (pkgVersion && method(pkgVersion, pkg)) {
                results.push(pkg);
            }
        }
        return results;
    }
    getPackage(slug) {
        return this.packages.get(slug);
    }
    getReport() {
        const reports = {};
        for (const [slug, pkg] of this.packages) {
            const report = pkg.getReport();
            if (Object.keys(report).length)
                reports[slug] = report;
        }
        return reports;
    }
    outputReport() {
        const reports = this.getReport();
        for (const [slug, report] of Object.entries(reports)) {
            for (const [ver, reportVersion] of Object.entries(report)) {
                this.logReport(`${slug}/${ver}`, reportVersion.errors, reportVersion.recs);
            }
        }
    }
    listPackages(installed) {
        if (installed !== undefined) {
            const packagesFiltered = [];
            Array.from(this.packages.values()).forEach(pkg => {
                Array.from(pkg.versions.values()).forEach(pkgVersion => {
                    if ((installed === true && pkgVersion.installed) || (installed === false && !pkgVersion.installed)) {
                        packagesFiltered.push(pkg);
                    }
                });
            });
            return packagesFiltered;
        }
        return Array.from(this.packages.values());
    }
    removePackage(slug) {
        if (!this.packages.has(slug))
            return;
        this.packages.delete(slug);
    }
    reset() {
        this.packages.clear();
    }
    search(query) {
        const queryLower = query.trim().toLowerCase();
        const results = [];
        for (const [slug, pkg] of this.packages) {
            const pkgVersion = pkg.getVersionLatest();
            if (!pkgVersion)
                continue;
            const pkgTags = pkgVersion.tags.map((str) => str.trim().toLowerCase());
            if (slug.indexOf(queryLower) !== -1 ||
                pkgVersion.name.trim().toLowerCase().indexOf(queryLower) !== -1 ||
                pkgVersion.description.trim().toLowerCase().indexOf(queryLower) !== -1 ||
                pkgTags.includes(queryLower)) {
                results.push(pkg);
            }
        }
        return results;
    }
    async sync() {
        const registries = this.config.get('registries');
        for (const index in registries) {
            const json = await apiJson(registries[index].url);
            const type = this.type;
            for (const slug in json[type]) {
                const pkg = new Package(slug, json[type][slug].versions);
                this.addPackage(pkg);
            }
        }
    }
    toJSON() {
        const data = {};
        for (const [slug, pkg] of this.packages.entries()) {
            data[slug] = pkg.toJSON();
        }
        return data;
    }
}