@open-audio-stack/core 0.0.13 → 0.0.15

package/build/Registry.d.ts

@@ -1,28 +1,23 @@
-import { PackageInterface, PackageValidationError, PackageValidationRec, PackageVersions, PackageVersionType } from './types/Package.js';
-import { RegistryInterface, RegistryPackages } from './types/Registry.js';
-import { PluginType } from './types/PluginType.js';
-import { PresetType } from './types/PresetType.js';
-import { ProjectType } from './types/ProjectType.js';
+import { PackageInterface, PackageVersion, PackageVersions, PackageVersionType } from './types/Package.js';
+import { RegistryInterface, RegistryPackages, RegistryType } from './types/Registry.js';
 export declare class Registry {
     registry: RegistryInterface;
     constructor(registry?: RegistryInterface);
-    packageAdd(slug: string): {
+    packageAdd(slug: string, type: RegistryType): {
         slug: string;
         version: string;
         versions: {};
     };
-    packageVersionAdd(slug: string, version: string, pkgVersion: PackageVersionType): void;
-    package(slug: string): PackageInterface;
-    packages(): RegistryPackages;
-    packagesFilter(type: typeof PluginType | typeof PresetType | typeof ProjectType): RegistryPackages;
-    packageLatest(slug: string, version?: string): PackageVersionType;
+    packageVersionAdd(slug: string, type: RegistryType, version: string, pkgVersion: PackageVersionType): void;
+    package(slug: string, type: RegistryType): PackageInterface;
+    packages(type: RegistryType): RegistryPackages;
+    packagesFilter(type: RegistryType, field: keyof PackageVersion, value: string | number | object): RegistryPackages;
+    packageLatest(slug: string, type: RegistryType, version?: string): PackageVersionType;
     packageVersionLatest(versions: PackageVersions): string;
     get(): RegistryInterface;
     name(): string;
     url(): string;
     version(): string;
-    packageRemove(slug: string): void;
-    packageVersionRemove(slug: string, version: string): void;
-    packageVersionValidate(pkgVersion: PackageVersionType): PackageValidationError[];
-    packageVersionRecommendations(pkgVersion: PackageVersionType): PackageValidationRec[];
+    packageRemove(slug: string, type: RegistryType): void;
+    packageVersionRemove(slug: string, type: RegistryType, version: string): void;
 }

package/build/Registry.js

@@ -1,42 +1,41 @@
 import * as semver from 'semver';
-import { PackageValidation, } from './types/Package.js';
-import { License } from './types/License.js';
 export class Registry {
     registry;
     constructor(registry) {
         this.registry = Object.assign({}, registry);
     }
-    packageAdd(slug) {
-        return (this.registry.packages[slug] = {
+    packageAdd(slug, type) {
+        return (this.registry[type][slug] = {
             slug,
             version: '',
             versions: {},
         });
     }
-    packageVersionAdd(slug, version, pkgVersion) {
-        let pkg = this.package(slug);
+    packageVersionAdd(slug, type, version, pkgVersion) {
+        let pkg = this.package(slug, type);
         if (!pkg) {
-            pkg = this.packageAdd(slug);
+            pkg = this.packageAdd(slug, type);
         }
         pkg.versions[version] = pkgVersion;
         pkg.version = this.packageVersionLatest(pkg.versions);
     }
-    package(slug) {
-        return this.registry.packages[slug];
+    package(slug, type) {
+        return this.registry[type][slug];
     }
-    packages() {
-        return this.registry.packages;
+    packages(type) {
+        return this.registry[type];
     }
-    packagesFilter(type) {
+    packagesFilter(type, field, value) {
         const registryFiltered = {};
-        Object.keys(this.registry.packages).forEach((slug) => {
-            if (Object.values(type).includes(this.packageLatest(slug).type))
-                registryFiltered[slug] = this.registry.packages[slug];
+        Object.keys(this.registry[type]).forEach((slug) => {
+            if (this.packageLatest(slug, type)[field] === value) {
+                registryFiltered[slug] = this.registry[type][slug];
+            }
         });
         return registryFiltered;
     }
-    packageLatest(slug, version) {
-        const pkg = this.package(slug);
+    packageLatest(slug, type, version) {
+        const pkg = this.package(slug, type);
         const pkgVersion = this.packageVersionLatest(pkg.versions);
         return pkg.versions[version || pkgVersion];
     }
@@ -61,117 +60,17 @@ export class Registry {
     version() {
         return this.registry.version;
     }
-    packageRemove(slug) {
-        delete this.registry.packages[slug];
+    packageRemove(slug, type) {
+        delete this.registry[type][slug];
     }
-    packageVersionRemove(slug, version) {
-        const pkg = this.package(slug);
+    packageVersionRemove(slug, type, version) {
+        const pkg = this.package(slug, type);
         if (pkg && pkg.versions[version]) {
             delete pkg.versions[version];
             pkg.version = this.packageVersionLatest(pkg.versions);
         }
         if (!Object.keys(pkg.versions).length) {
-            this.packageRemove(slug);
-        }
-    }
-    packageVersionValidate(pkgVersion) {
-        const fields = [
-            { name: 'audio', type: 'string' },
-            { name: 'author', type: 'string' },
-            { name: 'changes', type: 'string' },
-            { name: 'date', type: 'string' },
-            { name: 'description', type: 'string' },
-            { name: 'files', type: 'object' },
-            { name: 'image', type: 'string' },
-            { name: 'license', type: 'string' },
-            { name: 'name', type: 'string' },
-            { name: 'tags', type: 'object' },
-            { name: 'type', type: 'string' },
-            { name: 'url', type: 'string' },
-        ];
-        const errors = [];
-        fields.forEach((field) => {
-            const versionField = pkgVersion[field.name];
-            if (versionField === undefined) {
-                errors.push({
-                    field: field.name,
-                    error: PackageValidation.MISSING_FIELD,
-                    valueExpected: field.type,
-                    valueReceived: 'undefined',
-                });
-            }
-            else if (typeof versionField !== field.type) {
-                errors.push({
-                    field: field.name,
-                    error: PackageValidation.INVALID_TYPE,
-                    valueExpected: field.type,
-                    valueReceived: typeof versionField,
-                });
-            }
-        });
-        return errors;
-    }
-    // TODO refactor all this using a proper validation library.
-    packageVersionRecommendations(pkgVersion) {
-        const recs = [];
-        // Urls
-        if (!pkgVersion.url.startsWith('https://')) {
-            recs.push({
-                field: 'url',
-                rec: 'should use https url',
-            });
-        }
-        if (!pkgVersion.url.includes('github.com') && !pkgVersion.url.includes('github.io')) {
-            recs.push({
-                field: 'url',
-                rec: 'should point to GitHub',
-            });
-        }
-        // Image/audio previews
-        if (pkgVersion.image && pkgVersion.image.includes('png')) {
-            recs.push({
-                field: 'image',
-                rec: 'should use the jpg format',
-            });
-        }
-        if (pkgVersion.audio && pkgVersion.audio.includes('wav')) {
-            recs.push({
-                field: 'audio',
-                rec: 'should use the flac format',
-            });
-        }
-        // Architectures/systems
-        const supportedArchitectures = {};
-        const supportedSystems = {};
-        pkgVersion.files.forEach(file => {
-            file.architectures.forEach(architecture => {
-                supportedArchitectures[architecture] = true;
-            });
-            file.systems.forEach(system => {
-                supportedSystems[system.type] = true;
-            });
-        });
-        if (!supportedArchitectures.arm64)
-            recs.push({ field: 'architectures', rec: 'should support Arm64' });
-        if (!supportedArchitectures.bit64)
-            recs.push({ field: 'architectures', rec: 'should support Bit64' });
-        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' });
-        // Tags
-        const pluginTags = pkgVersion.tags.map(tag => tag.toLowerCase());
-        if (pluginTags.length < 2)
-            recs.push({ field: 'tags', rec: 'should have more items' });
-        // Licence
-        if (!Object.values(License).includes(pkgVersion.license)) {
-            recs.push({ field: 'license', rec: 'should be from the supported list' });
-        }
-        else if (pkgVersion.license === License.Other) {
-            recs.push({ field: 'license', rec: 'should be more specific' });
+            this.packageRemove(slug, type);
         }
-        return recs;
     }
 }

package/build/helpers/file.js

@@ -177,12 +177,12 @@ export function fileSize(filePath) {
 }
 export function fileValidateMetadata(filePath, fileMetadata) {
     const errors = [];
-    if (fileMetadata.hash !== fileHash(filePath)) {
+    if (fileMetadata.sha256 !== fileHash(filePath)) {
         errors.push({
-            field: 'hash',
+            field: 'sha256',
             error: PackageValidation.INVALID_VALUE,
             valueExpected: fileHash(filePath),
-            valueReceived: fileMetadata.hash,
+            valueReceived: fileMetadata.sha256,
         });
     }
     if (fileMetadata.size !== fileSize(filePath)) {

package/build/helpers/package.d.ts

@@ -0,0 +1,3 @@
+import { PackageValidationError, PackageValidationRec, PackageVersionType } from '../types/Package.js';
+export declare function packageRecommendations(pkgVersion: PackageVersionType): PackageValidationRec[];
+export declare function packageValidate(pkgVersion: PackageVersionType): PackageValidationError[];

package/build/helpers/package.js

@@ -0,0 +1,102 @@
+import { License } from '../types/License.js';
+import { PackageValidation, } from '../types/Package.js';
+// TODO refactor all this using a proper validation library.
+export function packageRecommendations(pkgVersion) {
+    const recs = [];
+    // Urls
+    if (!pkgVersion.url.startsWith('https://')) {
+        recs.push({
+            field: 'url',
+            rec: 'should use https url',
+        });
+    }
+    if (!pkgVersion.url.includes('github.com') && !pkgVersion.url.includes('github.io')) {
+        recs.push({
+            field: 'url',
+            rec: 'should point to GitHub',
+        });
+    }
+    // Image/audio previews
+    if (pkgVersion.image && pkgVersion.image.includes('png')) {
+        recs.push({
+            field: 'image',
+            rec: 'should use the jpg format',
+        });
+    }
+    if (pkgVersion.audio && pkgVersion.audio.includes('wav')) {
+        recs.push({
+            field: 'audio',
+            rec: 'should use the flac format',
+        });
+    }
+    // Architectures/systems
+    const supportedArchitectures = {};
+    const supportedSystems = {};
+    pkgVersion.files.forEach(file => {
+        file.architectures.forEach(architecture => {
+            supportedArchitectures[architecture] = true;
+        });
+        file.systems.forEach(system => {
+            supportedSystems[system.type] = true;
+        });
+    });
+    if (!supportedArchitectures.arm64)
+        recs.push({ field: 'architectures', rec: 'should support Arm64' });
+    if (!supportedArchitectures.bit64)
+        recs.push({ field: 'architectures', rec: 'should support Bit64' });
+    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' });
+    // Tags
+    const pluginTags = pkgVersion.tags.map(tag => tag.toLowerCase());
+    if (pluginTags.length < 2)
+        recs.push({ field: 'tags', rec: 'should have more items' });
+    // Licence
+    if (!Object.values(License).includes(pkgVersion.license)) {
+        recs.push({ field: 'license', rec: 'should be from the supported list' });
+    }
+    else if (pkgVersion.license === License.Other) {
+        recs.push({ field: 'license', rec: 'should be more specific' });
+    }
+    return recs;
+}
+export function packageValidate(pkgVersion) {
+    const fields = [
+        { name: 'audio', type: 'string' },
+        { name: 'author', type: 'string' },
+        { name: 'changes', type: 'string' },
+        { name: 'date', type: 'string' },
+        { name: 'description', type: 'string' },
+        { name: 'files', type: 'object' },
+        { name: 'image', type: 'string' },
+        { name: 'license', type: 'string' },
+        { name: 'name', type: 'string' },
+        { name: 'tags', type: 'object' },
+        { name: 'type', type: 'string' },
+        { name: 'url', type: 'string' },
+    ];
+    const errors = [];
+    fields.forEach((field) => {
+        const versionField = pkgVersion[field.name];
+        if (versionField === undefined) {
+            errors.push({
+                field: field.name,
+                error: PackageValidation.MISSING_FIELD,
+                valueExpected: field.type,
+                valueReceived: 'undefined',
+            });
+        }
+        else if (typeof versionField !== field.type) {
+            errors.push({
+                field: field.name,
+                error: PackageValidation.INVALID_TYPE,
+                valueExpected: field.type,
+                valueReceived: typeof versionField,
+            });
+        }
+    });
+    return errors;
+}

package/build/index-browser.d.ts

@@ -1,6 +1,7 @@
 export * from './Config.js';
 export * from './Registry.js';
 export * from './helpers/api.js';
+export * from './helpers/package.js';
 export * from './helpers/utils.js';
 export * from './types/Architecture.js';
 export * from './types/Config.js';

package/build/index-browser.js

@@ -8,6 +8,7 @@ export * from './Registry.js';
 // Helpers
 export * from './helpers/api.js';
 // export * from './helpers/file.js';
+export * from './helpers/package.js';
 export * from './helpers/utils.js';
 // Types
 export * from './types/Architecture.js';

package/build/index.d.ts

@@ -2,6 +2,7 @@ export * from './Config.js';
 export * from './Registry.js';
 export * from './helpers/api.js';
 export * from './helpers/file.js';
+export * from './helpers/package.js';
 export * from './helpers/utils.js';
 export * from './types/Architecture.js';
 export * from './types/Config.js';

package/build/index.js

@@ -8,6 +8,7 @@ export * from './Registry.js';
 // Helpers
 export * from './helpers/api.js';
 export * from './helpers/file.js';
+export * from './helpers/package.js';
 export * from './helpers/utils.js';
 // Types
 export * from './types/Architecture.js';

package/build/types/File.d.ts

@@ -5,7 +5,7 @@ import { System } from './System.js';
 export interface FileInterface {
     architectures: Architecture[];
     format: FileFormat;
-    hash: string;
+    sha256: string;
     size: number;
     systems: System[];
     type: FileType;

package/build/types/Registry.d.ts

@@ -1,10 +1,17 @@
 import { PackageInterface } from './Package.js';
 export interface RegistryInterface {
     name: string;
-    packages: RegistryPackages;
+    [RegistryType.Plugins]: RegistryPackages;
+    [RegistryType.Presets]: RegistryPackages;
+    [RegistryType.Projects]: RegistryPackages;
     url: string;
     version: string;
 }
+export declare enum RegistryType {
+    Plugins = "plugins",
+    Presets = "presets",
+    Projects = "projects"
+}
 export interface RegistryPackages {
     [slug: string]: PackageInterface;
 }

package/build/types/Registry.js

@@ -1 +1,6 @@
-export {};
+export var RegistryType;
+(function (RegistryType) {
+    RegistryType["Plugins"] = "plugins";
+    RegistryType["Presets"] = "presets";
+    RegistryType["Projects"] = "projects";
+})(RegistryType || (RegistryType = {}));

package/package.json

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