@open-audio-stack/core 0.0.22 → 0.0.24

package/build/Config.d.ts

@@ -13,7 +13,8 @@ import { SystemType } from './types/SystemType.js';
 export declare class Config {
     config: ConfigInterface;
     constructor(config?: ConfigInterface);
-    get(): ConfigInterface;
+    get(key?: keyof ConfigInterface): string | ConfigInterface | import("./types/Config.js").ConfigRegistry[] | undefined;
+    set(key: keyof ConfigInterface, val: any): string | ConfigInterface | import("./types/Config.js").ConfigRegistry[] | undefined;
     architecture(type: Architecture): import("./types/Architecture.js").ArchitectureOption;
     architectures(): import("./types/Architecture.js").ArchitectureOption[];
     fileFormat(format: FileFormat): import("./types/FileFormat.js").FileFormatOption;

package/build/Config.js

@@ -12,11 +12,24 @@ import { systemTypes } from './types/SystemType.js';
 export class Config {
     config;
     constructor(config) {
-        this.config = Object.assign({}, config);
-    }
-    get() {
+        this.config = Object.assign({
+            registries: [
+                {
+                    name: 'Open Audio Registry',
+                    url: 'https://open-audio-stack.github.io/open-audio-stack-registry',
+                },
+            ],
+        }, config);
+    }
+    get(key) {
+        if (key)
+            return this.config[key];
         return this.config;
     }
+    set(key, val) {
+        this.config[key] = val;
+        return this.get(key);
+    }
     // Architectures.
     architecture(type) {
         return architectures.filter(architecture => type === architecture.value)[0];

package/build/Manager.d.ts

@@ -0,0 +1,26 @@
+import { Config } from './Config.js';
+import { Registry } from './Registry.js';
+import { PackageVersion } from './index-browser.js';
+import { RegistryInterface, RegistryType } from './types/Registry.js';
+export declare class Manager {
+    registry: Registry;
+    config: Config;
+    constructor();
+    addPackages(json: RegistryInterface, type: RegistryType): void;
+    scan(type?: RegistryType): Promise<void>;
+    search(field: keyof PackageVersion, value: string | number | object, type?: RegistryType): import("./index-browser.js").RegistryPackages | {
+        plugins: import("./index-browser.js").RegistryPackages;
+        presets: import("./index-browser.js").RegistryPackages;
+        projects: import("./index-browser.js").RegistryPackages;
+    };
+    getByOrg(org: string, type?: RegistryType): import("./index-browser.js").RegistryPackages | {
+        plugins: import("./index-browser.js").RegistryPackages;
+        presets: import("./index-browser.js").RegistryPackages;
+        projects: import("./index-browser.js").RegistryPackages;
+    };
+    getBySlug(slug: string, type?: RegistryType, version?: string): import("./index-browser.js").PluginInterface | import("./index-browser.js").PresetInterface | import("./index-browser.js").ProjectInterface | {
+        plugins: import("./index-browser.js").PackageVersionType;
+        presets: import("./index-browser.js").PackageVersionType;
+        projects: import("./index-browser.js").PackageVersionType;
+    };
+}

package/build/Manager.js

@@ -0,0 +1,64 @@
+import { Config } from './Config.js';
+import { Registry } from './Registry.js';
+import { apiJson } from './helpers/api.js';
+import { RegistryType } from './types/Registry.js';
+export class Manager {
+    registry;
+    config;
+    constructor() {
+        this.config = new Config();
+        this.registry = new Registry();
+        this.scan();
+    }
+    addPackages(json, type) {
+        for (const slug in json[type]) {
+            this.registry.packageAdd(type, slug, json.plugins[slug]);
+        }
+        console.log(`${type}: ${this.registry.packages(type).length}`);
+    }
+    async scan(type) {
+        this.registry.reset();
+        const registries = this.config.get('registries');
+        for (const index in registries) {
+            const json = await apiJson(registries[index].url);
+            if (type) {
+                this.addPackages(json, type);
+            }
+            else {
+                this.addPackages(json, RegistryType.Plugins);
+                this.addPackages(json, RegistryType.Presets);
+                this.addPackages(json, RegistryType.Projects);
+            }
+        }
+    }
+    search(field, value, type) {
+        if (type) {
+            return this.registry.packagesSearch(type, field, value);
+        }
+        return {
+            plugins: this.registry.packagesSearch(RegistryType.Plugins, field, value),
+            presets: this.registry.packagesSearch(RegistryType.Presets, field, value),
+            projects: this.registry.packagesSearch(RegistryType.Projects, field, value),
+        };
+    }
+    getByOrg(org, type) {
+        if (type) {
+            return this.registry.packagesOrg(type, org);
+        }
+        return {
+            plugins: this.registry.packagesOrg(RegistryType.Plugins, org),
+            presets: this.registry.packagesOrg(RegistryType.Presets, org),
+            projects: this.registry.packagesOrg(RegistryType.Projects, org),
+        };
+    }
+    getBySlug(slug, type, version) {
+        if (type) {
+            return this.registry.packageLatest(type, slug, version);
+        }
+        return {
+            plugins: this.registry.packageLatest(RegistryType.Plugins, slug, version),
+            presets: this.registry.packageLatest(RegistryType.Presets, slug, version),
+            projects: this.registry.packageLatest(RegistryType.Projects, slug, version),
+        };
+    }
+}

package/build/Registry.d.ts

@@ -2,22 +2,20 @@ import { PackageInterface, PackageVersion, PackageVersions, PackageVersionType }
 import { RegistryInterface, RegistryPackages, RegistryType } from './types/Registry.js';
 export declare class Registry {
     registry: RegistryInterface;
-    constructor(registry?: RegistryInterface);
-    packageAdd(slug: string, type: RegistryType): {
-        slug: string;
-        version: string;
-        versions: {};
-    };
-    packageVersionAdd(slug: string, type: RegistryType, version: string, pkgVersion: PackageVersionType): void;
-    package(slug: string, type: RegistryType): PackageInterface;
+    constructor();
+    packageAdd(type: RegistryType, slug: string, pkg?: PackageInterface): PackageInterface;
+    packageVersionAdd(type: RegistryType, slug: string, version: string, pkgVersion: PackageVersionType): void;
+    package(type: RegistryType, slug: string): PackageInterface;
     packages(type: RegistryType): RegistryPackages;
-    packagesFilter(type: RegistryType, field: keyof PackageVersion, value: string | number | object): RegistryPackages;
-    packageLatest(slug: string, type: RegistryType, version?: string): PackageVersionType;
+    packagesSearch(type: RegistryType, field: keyof PackageVersion, value: string | number | object): RegistryPackages;
+    packagesOrg(type: RegistryType, match: string): RegistryPackages;
+    packageLatest(type: RegistryType, slug: string, version?: string): PackageVersionType;
     packageVersionLatest(versions: PackageVersions): string;
     get(): RegistryInterface;
     name(): string;
+    reset(): void;
     url(): string;
     version(): string;
-    packageRemove(slug: string, type: RegistryType): void;
-    packageVersionRemove(slug: string, type: RegistryType, version: string): void;
+    packageRemove(type: RegistryType, slug: string): void;
+    packageVersionRemove(type: RegistryType, slug: string, version: string): void;
 }

package/build/Registry.js

@@ -1,45 +1,60 @@
 import * as semver from 'semver';
 export class Registry {
     registry;
-    constructor(registry) {
-        this.registry = Object.assign({}, registry);
+    constructor() {
+        this.registry = {
+            name: 'Open Audio Registry',
+            plugins: {},
+            presets: {},
+            projects: {},
+            url: 'https://open-audio-stack.github.io/open-audio-stack-registry',
+            version: '1.0.0',
+        };
     }
-    packageAdd(slug, type) {
-        return (this.registry[type][slug] = {
+    packageAdd(type, slug, pkg) {
+        return (this.registry[type][slug] = pkg || {
             slug,
             version: '',
             versions: {},
         });
     }
-    packageVersionAdd(slug, type, version, pkgVersion) {
+    packageVersionAdd(type, slug, version, pkgVersion) {
         if (!semver.valid(version))
             throw Error(`${version} is not a valid Semantic version`);
-        let pkg = this.package(slug, type);
+        let pkg = this.package(type, slug);
         if (!pkg) {
-            pkg = this.packageAdd(slug, type);
+            pkg = this.packageAdd(type, slug);
         }
         pkg.versions[version] = pkgVersion;
         pkg.version = this.packageVersionLatest(pkg.versions);
     }
-    package(slug, type) {
+    package(type, slug) {
         return this.registry[type][slug];
     }
     packages(type) {
         return this.registry[type];
     }
-    packagesFilter(type, field, value) {
-        const registryFiltered = {};
+    packagesSearch(type, field, value) {
+        const results = {};
         Object.keys(this.registry[type]).forEach((slug) => {
-            if (this.packageLatest(slug, type)[field] === value) {
-                registryFiltered[slug] = this.registry[type][slug];
+            if (this.packageLatest(type, slug)[field] === value) {
+                results[slug] = this.registry[type][slug];
             }
         });
-        return registryFiltered;
+        return results;
     }
-    packageLatest(slug, type, version) {
+    packagesOrg(type, match) {
+        const results = {};
+        for (const slug in this.registry[type]) {
+            if (slug.startsWith(match))
+                results[slug] = this.registry[type][slug];
+        }
+        return results;
+    }
+    packageLatest(type, slug, version) {
         if (version && !semver.valid(version))
             throw Error(`${version} is not a valid Semantic version`);
-        const pkg = this.package(slug, type);
+        const pkg = this.package(type, slug);
         const pkgVersion = this.packageVersionLatest(pkg.versions);
         return pkg.versions[version || pkgVersion];
     }
@@ -58,25 +73,30 @@ export class Registry {
     name() {
         return this.registry.name;
     }
+    reset() {
+        this.registry.plugins = {};
+        this.registry.presets = {};
+        this.registry.projects = {};
+    }
     url() {
         return this.registry.url;
     }
     version() {
         return this.registry.version;
     }
-    packageRemove(slug, type) {
+    packageRemove(type, slug) {
         delete this.registry[type][slug];
     }
-    packageVersionRemove(slug, type, version) {
+    packageVersionRemove(type, slug, version) {
         if (!semver.valid(version))
             throw Error(`${version} is not a valid Semantic version`);
-        const pkg = this.package(slug, type);
+        const pkg = this.package(type, slug);
         if (pkg && pkg.versions[version]) {
             delete pkg.versions[version];
             pkg.version = this.packageVersionLatest(pkg.versions);
         }
         if (!Object.keys(pkg.versions).length) {
-            this.packageRemove(slug, type);
+            this.packageRemove(type, slug);
         }
     }
 }

package/build/helpers/file.js

@@ -184,19 +184,19 @@ export async function fileValidateMetadata(filePath, fileMetadata) {
     if (fileMetadata.sha256 !== hash) {
         errors.push({
             code: ZodIssueCode.invalid_type,
-            expected: hash,
+            expected: fileMetadata.sha256,
             message: 'Required',
             path: ['sha256'],
-            received: fileMetadata.sha256,
+            received: hash,
         });
     }
     if (fileMetadata.size !== fileSize(filePath)) {
         errors.push({
             code: ZodIssueCode.invalid_type,
-            expected: String(fileSize(filePath)),
+            expected: String(fileMetadata.size),
             message: 'Required',
             path: ['size'],
-            received: String(fileMetadata.size),
+            received: String(fileSize(filePath)),
         });
     }
     return errors;

package/build/helpers/package.js

@@ -58,9 +58,9 @@ export function packageRecommendations(pkgVersion) {
             rec: 'should use the flac format',
         });
     }
-    // Architectures/systems
     const supportedArchitectures = {};
     const supportedSystems = {};
+    const supportedFileFormats = {};
     pkgVersion.files.forEach(file => {
         file.architectures.forEach(architecture => {
             supportedArchitectures[architecture] = true;
@@ -68,18 +68,32 @@ export function packageRecommendations(pkgVersion) {
         file.systems.forEach(system => {
             supportedSystems[system.type] = true;
         });
+        supportedFileFormats[file.format] = true;
         packageRecommendationsUrl(file, recs, 'url');
     });
+    // Architectures
     if (!supportedArchitectures.arm64)
         recs.push({ field: 'architectures', rec: 'should support arm64' });
     if (!supportedArchitectures.x64)
         recs.push({ field: 'architectures', rec: 'should support x64' });
+    // Systems
     if (!supportedSystems.linux)
         recs.push({ field: 'systems', rec: 'should support Linux' });
     if (!supportedSystems.mac)
         recs.push({ field: 'systems', rec: 'should support Mac' });
     if (!supportedSystems.win)
         recs.push({ field: 'systems', rec: 'should support Windows' });
+    // Formats
+    if (supportedFileFormats.deb)
+        recs.push({
+            field: 'format',
+            rec: 'should support all Linux distributions, consider using AppImage or Tarball instead',
+        });
+    if (supportedFileFormats.rpm)
+        recs.push({
+            field: 'format',
+            rec: 'should support all Linux distributions, consider using AppImage or Tarball instead',
+        });
     // Tags
     const pluginTags = pkgVersion.tags.map(tag => tag.toLowerCase());
     if (pluginTags.length < 2)

package/build/index-browser.d.ts

@@ -1,4 +1,5 @@
 export * from './Config.js';
+export * from './Manager.js';
 export * from './Registry.js';
 export * from './helpers/api.js';
 export * from './helpers/package.js';

package/build/index-browser.js

@@ -4,6 +4,7 @@
 // Comment out any files which are not browser compatible.
 // Classes
 export * from './Config.js';
+export * from './Manager.js';
 export * from './Registry.js';
 // Helpers
 export * from './helpers/api.js';

package/build/index.d.ts

@@ -1,4 +1,5 @@
 export * from './Config.js';
+export * from './Manager.js';
 export * from './Registry.js';
 export * from './helpers/api.js';
 export * from './helpers/file.js';

package/build/index.js

@@ -4,6 +4,7 @@
 // Comment out any files which are not NodeJS compatible.
 // Classes
 export * from './Config.js';
+export * from './Manager.js';
 export * from './Registry.js';
 // Helpers
 export * from './helpers/api.js';

package/build/types/Config.d.ts

@@ -1,2 +1,10 @@
 export interface ConfigInterface {
+    pluginDir?: string;
+    presetDir?: string;
+    projectDir?: string;
+    registries?: ConfigRegistry[];
+}
+export interface ConfigRegistry {
+    name: string;
+    url: string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-audio-stack/core",
-  "version": "0.0.22",
+  "version": "0.0.24",
   "description": "Open-source audio plugin management software",
   "type": "module",
   "main": "./build/index.js",