@syncbridge/common 0.6.10 → 0.6.12

package/constants.js

@@ -1,4 +1,4 @@
-export const version = '0.6.10';
+export const version = '0.6.12';
 export const OWN_ELEMENT_METADATA = Symbol.for('OWN_ELEMENT_METADATA');
 export const COMPONENT_OPTIONS = Symbol.for('COMPONENT_OPTIONS');
 export const PROCESSOR_OPTIONS = Symbol.for('PROCESSOR_OPTIONS');

package/index.d.ts

@@ -18,3 +18,5 @@ export * from './registry/extension-package.js';
 export * from './registry/extension-registry.js';
 export * from './utils/decode-profile.js';
 export * from './utils/materialize-metadata.js';
+export * from './utils/normalize-metadata.js';
+export * from './utils/type-guartds.js';

package/index.js

@@ -18,3 +18,5 @@ export * from './registry/extension-package.js';
 export * from './registry/extension-registry.js';
 export * from './utils/decode-profile.js';
 export * from './utils/materialize-metadata.js';
+export * from './utils/normalize-metadata.js';
+export * from './utils/type-guartds.js';

package/models/metadata/component-metadata.js

@@ -1,5 +1,5 @@
 import { __decorate, __metadata } from "tslib";
-import { ApiField, ComplexType } from '@opra/common';
+import { ApiField, ArrayType, ComplexType } from '@opra/common';
 import { ElementMetadata } from './element-metadata.js';
 /**
  *
@@ -13,8 +13,7 @@ __decorate([
     ApiField({
         label: 'Interfaces',
         description: 'Interfaces which this component implemented',
-        type: 'string',
-        isArray: true,
+        type: ArrayType('string'),
     }),
     __metadata("design:type", Array)
 ], ComponentMetadata.prototype, "interfaces", void 0);

package/models/metadata/element-metadata.js

@@ -1,5 +1,5 @@
 import { __decorate, __metadata } from "tslib";
-import { ApiField, ComplexType } from '@opra/common';
+import { ApiField, ArrayType, ComplexType } from '@opra/common';
 import { AuthorMetadata } from './author-metadata.js';
 import { VariableMetadataRecord } from './variable-metadata.js';
 /**
@@ -69,8 +69,7 @@ __decorate([
     ApiField({
         label: 'Tags',
         description: 'Tags of the component. Tags are used to group components',
-        type: 'string',
-        isArray: true,
+        type: ArrayType('string'),
     }),
     __metadata("design:type", Array)
 ], ElementMetadata.prototype, "tags", void 0);

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@syncbridge/common",
-  "version": "0.6.10",
+  "version": "0.6.12",
   "description": "SyncBridge Common utilities",
   "author": "Panates Inc",
   "license": "MIT",
   "dependencies": {
     "@jsopen/objects": "^2.2.0",
     "fast-deep-equal": "^3.1.3",
-    "node-events-async": "^1.5.0",
+    "node-events-async": "^1.5.2",
     "reflect-metadata": "^0.2.2",
     "semver": "^7.7.4",
-    "ts-gems": "^3.11.3",
+    "ts-gems": "^3.11.5",
     "valgen": "^5.19.5"
   },
   "peerDependencies": {

package/registry/extension-package.d.ts

@@ -3,7 +3,6 @@ import { Type } from 'ts-gems';
 import { ComponentBase } from '../classes/component-base.js';
 import { ProcessorBase } from '../classes/processor-base.js';
 import { ComponentMetadata, ProcessorMetadata } from '../models/index.js';
-import type { ExtensionRegistry } from './extension-registry.js';
 /**
  *
  */
@@ -11,18 +10,11 @@ export declare class ExtensionPackage {
     name: string;
     version: string;
     description: string;
+    path: string;
     entryPoint: string;
     components: ComponentExtension[];
     processors: ProcessorExtension[];
     errors: Error[];
-    sortVersions(): void;
-    /**
-     *
-     * @param directory
-     * @static
-     */
-    static fromDirectory(directory: string): Promise<ExtensionPackage>;
-    static fromNodePackage(specifier: string, resolver: ExtensionRegistry.Resolver | undefined): Promise<ExtensionPackage>;
 }
 /**
  *

package/registry/extension-package.js

@@ -1,13 +1,6 @@
 import 'reflect-metadata';
-import fs from 'node:fs';
-import path from 'node:path';
-import process from 'node:process';
-import { fileURLToPath, pathToFileURL } from 'node:url';
-import { updateErrorMessage } from '@jsopen/objects';
 import { SbError } from '../classes/sb-error.js';
-import { COMPONENT_OPTIONS, PROCESSOR_OPTIONS } from '../constants.js';
 import { isComponentBase, isProcessorBase } from '../utils/type-guartds.js';
-import { normalizeComponentMetadata, normalizeProcessorMetadata, } from './normalize-metadata.js';
 /**
  *
  */
@@ -15,140 +8,6 @@ export class ExtensionPackage {
     components = [];
     processors = [];
     errors = [];
-    sortVersions() {
-        this.components.sort((a, b) => a.version.localeCompare(b.version));
-        this.processors.sort((a, b) => a.version.localeCompare(b.version));
-    }
-    /**
-     *
-     * @param directory
-     * @static
-     */
-    static async fromDirectory(directory) {
-        let filename = path.join(directory, 'package.json');
-        if (!fs.existsSync(filename))
-            throw new SbError(`Directory "${directory}" does not contain package.json`);
-        const pkgJson = JSON.parse(fs.readFileSync(filename, 'utf8'));
-        if (!pkgJson.syncbridge)
-            throw new SbError(`"${pkgJson.name}" is not a SyncBridge extension package`);
-        const out = new ExtensionPackage();
-        out.name = pkgJson.name;
-        out.version = pkgJson.version;
-        out.description = pkgJson.description;
-        out.entryPoint = path.join(directory, pkgJson.module || pkgJson.main);
-        let metadata;
-        if (pkgJson.syncbridge.components) {
-            for (const ctorName of pkgJson.syncbridge.components) {
-                filename = path.join(directory, 'metadata', ctorName + '.json');
-                if (!fs.existsSync(filename)) {
-                    out.errors.push(new Error(`Component (${ctorName}) metadata file not found`));
-                    continue;
-                }
-                try {
-                    metadata = JSON.parse(fs.readFileSync(filename, 'utf8'));
-                }
-                catch {
-                    out.errors.push(new Error(`Component (${ctorName}) metadata file read error`));
-                    continue;
-                }
-                try {
-                    metadata = await normalizeComponentMetadata(metadata);
-                }
-                catch (e) {
-                    updateErrorMessage(e, `Component (${ctorName}) metadata validation error. ` + e.message);
-                    out.errors.push(e);
-                    continue;
-                }
-                if (metadata.abstract)
-                    continue;
-                out.components = out.components || [];
-                out.components.push(new ComponentExtension(out, ctorName, metadata));
-            }
-        }
-        if (pkgJson.syncbridge.processors) {
-            for (const ctorName of pkgJson.syncbridge.processors) {
-                filename = path.join(directory, 'metadata', ctorName + '.json');
-                if (!fs.existsSync(filename)) {
-                    out.errors.push(new Error(`Processors (${ctorName}) metadata file not found`));
-                    continue;
-                }
-                try {
-                    metadata = JSON.parse(fs.readFileSync(filename, 'utf8'));
-                }
-                catch {
-                    out.errors.push(new Error(`Processors (${ctorName}) metadata file read error`));
-                    continue;
-                }
-                try {
-                    metadata = await normalizeProcessorMetadata(metadata);
-                }
-                catch (e) {
-                    updateErrorMessage(e, `Processor (${ctorName}) metadata validation error. ` + e.message);
-                    out.errors.push(e);
-                    continue;
-                }
-                if (metadata.abstract)
-                    continue;
-                out.processors = out.processors || [];
-                out.processors.push(new ProcessorExtension(out, ctorName, metadata));
-            }
-        }
-        out.sortVersions();
-        return out;
-    }
-    static async fromNodePackage(specifier, resolver) {
-        // const resolver = createRequire(parentPath || import.meta.url).resolve;
-        let entryPoint = (resolver || import.meta.resolve)(specifier);
-        const pkgJson = locatePkgJson(path.dirname(entryPoint));
-        if (!pkgJson) {
-            throw new SbError(`Can't locate package.json file for "${specifier}"`);
-        }
-        if (path.isAbsolute(entryPoint) && process.platform === 'win32') {
-            entryPoint = pathToFileURL(entryPoint).href;
-        }
-        const out = new ExtensionPackage();
-        out.name = pkgJson.name;
-        out.version = pkgJson.version;
-        out.description = pkgJson.description;
-        out.entryPoint = entryPoint;
-        const module = await import(entryPoint);
-        for (const [ctorName, v] of Object.entries(module)) {
-            if (typeof v !== 'function')
-                continue;
-            let metadata = Reflect.getMetadata(COMPONENT_OPTIONS, v);
-            if (metadata) {
-                try {
-                    metadata = await normalizeComponentMetadata(metadata);
-                }
-                catch (e) {
-                    updateErrorMessage(e, `Component (${ctorName}) metadata validation error. ` + e.message);
-                    out.errors.push(e);
-                    continue;
-                }
-                if (metadata.abstract)
-                    continue;
-                out.components = out.components || [];
-                out.components.push(new ComponentExtension(out, ctorName, metadata));
-            }
-            metadata = Reflect.getMetadata(PROCESSOR_OPTIONS, v);
-            if (metadata) {
-                try {
-                    metadata = await normalizeProcessorMetadata(metadata);
-                }
-                catch (e) {
-                    updateErrorMessage(e, `Processor (${ctorName}) metadata validation error. ` + e.message);
-                    out.errors.push(e);
-                    continue;
-                }
-                if (metadata.abstract)
-                    continue;
-                out.processors = out.processors || [];
-                out.processors.push(new ProcessorExtension(out, ctorName, metadata));
-            }
-        }
-        out.sortVersions();
-        return out;
-    }
 }
 /**
  *
@@ -226,19 +85,3 @@ export class ProcessorExtension {
         return this._ctor;
     }
 }
-/**
- *
- */
-function locatePkgJson(directory) {
-    if (directory.startsWith('file:'))
-        directory = fileURLToPath(directory);
-    for (let i = 0; i < 3; i++) {
-        const f = path.resolve(directory, 'package.json');
-        if (fs.existsSync(f)) {
-            const json = JSON.parse(fs.readFileSync(f, 'utf8'));
-            if (json.name && json.version)
-                return json;
-        }
-        directory = path.dirname(directory);
-    }
-}

package/registry/extension-registry.d.ts

@@ -1,39 +1,72 @@
-import { URL } from 'node:url';
+import { ResponsiveMap } from '@opra/common';
 import { Type } from 'ts-gems';
 import { ComponentExtension, ExtensionPackage, ProcessorExtension } from './extension-package.js';
-export declare namespace ExtensionRegistry {
-    type Resolver = (specifier: string, parent?: string | URL) => string;
-    const packages: Map<string, ExtensionPackage[]>;
-    const components: Map<string, ComponentExtension[]>;
-    const processors: Map<string, ProcessorExtension[]>;
+declare const instanceSymbol: unique symbol;
+/**
+ * The `ExtensionRegistry` class is responsible for managing component and processor extensions,
+ * as well as handling the registration of extension packages. It provides methods to locate and
+ * retrieve extensions by their class name and version, and offers the ability to dynamically register
+ * packages, components, and processors at runtime.
+ *
+ * @class ExtensionRegistry
+ */
+export declare class ExtensionRegistry {
+    protected static [instanceSymbol]: ExtensionRegistry;
+    static get packages(): ResponsiveMap<ExtensionPackage[]>;
+    static get components(): ResponsiveMap<ComponentExtension[]>;
+    static get processors(): ResponsiveMap<ProcessorExtension[]>;
+    static setResolver(fn: ExtensionRegistry.PackageResolver | undefined): void;
+    static findComponent(className: string, version?: string): ComponentExtension | undefined;
+    static getComponent(className: string, version?: string): ComponentExtension;
+    static findProcessor(className: string, version?: string): ProcessorExtension | undefined;
+    static getProcessor(className: string, version?: string): ProcessorExtension;
+    static registerPackage(specifier: string): Promise<ExtensionPackage>;
+    static registerComponent(ctor: Type): Promise<ComponentExtension | undefined>;
+    static registerProcessor(ctor: Type): Promise<ProcessorExtension | undefined>;
+    static storePackage(pkg: ExtensionPackage): void;
+    protected _resolver: ExtensionRegistry.PackageResolver;
+    readonly packages: ResponsiveMap<ExtensionPackage[]>;
+    readonly components: ResponsiveMap<ComponentExtension[]>;
+    readonly processors: ResponsiveMap<ProcessorExtension[]>;
+    /**
+     *
+     */
+    setResolver(fn: ExtensionRegistry.PackageResolver | undefined): void;
     /**
      *
      */
-    function findComponent(className: string, version?: string): ComponentExtension | undefined;
+    findComponent(className: string, version?: string): ComponentExtension | undefined;
     /**
      *
      */
-    function getComponent(className: string, version?: string): ComponentExtension;
+    getComponent(className: string, version?: string): ComponentExtension;
     /**
      *
      */
-    function findProcessor(className: string, version?: string): ProcessorExtension | undefined;
+    findProcessor(className: string, version?: string): ProcessorExtension | undefined;
     /**
      *
      */
-    function getProcessor(className: string, version?: string): ProcessorExtension;
+    getProcessor(className: string, version?: string): ProcessorExtension;
     /**
      *
      */
-    function setResolver(fn: Resolver | undefined): void;
+    registerPackage(specifier: string): Promise<ExtensionPackage>;
+    registerComponent(ctor: Type): Promise<ComponentExtension | undefined>;
     /**
      *
      */
-    function registerExtensionPackage(directory: string): Promise<ExtensionPackage>;
+    registerProcessor(ctor: Type): Promise<ProcessorExtension | undefined>;
     /**
      *
      */
-    function registerNodePackage(specifier: string): Promise<ExtensionPackage>;
-    function registerComponent(ctor: Type): Promise<ComponentExtension | undefined>;
-    function registerProcessor(ctor: Type): Promise<ProcessorExtension | undefined>;
+    storePackage(pkg: ExtensionPackage): void;
+}
+/**
+ *
+ * @namespace ExtensionRegistry
+ */
+export declare namespace ExtensionRegistry {
+    type PackageResolver = (specifier: string) => string;
 }
+export {};

package/registry/extension-registry.js

@@ -1,89 +1,175 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { updateErrorMessage } from '@jsopen/objects';
+import { ResponsiveMap } from '@opra/common';
 import semver from 'semver';
 import { SbError } from '../classes/sb-error.js';
 import { COMPONENT_OPTIONS, PROCESSOR_OPTIONS } from '../constants.js';
+import { normalizeComponentMetadata, normalizeProcessorMetadata, } from '../utils/normalize-metadata.js';
 import { ComponentExtension, ExtensionPackage, ProcessorExtension, } from './extension-package.js';
-import { normalizeComponentMetadata, normalizeProcessorMetadata, } from './normalize-metadata.js';
-export var ExtensionRegistry;
-(function (ExtensionRegistry) {
-    let _resolver;
-    ExtensionRegistry.packages = new Map();
-    ExtensionRegistry.components = new Map();
-    ExtensionRegistry.processors = new Map();
-    /**
-     *
-     */
-    function findComponent(className, version = '*') {
-        return ExtensionRegistry.components
-            .get(className)
-            ?.find(v => semver.satisfies(v.version, version || '*'));
+import { locatePackageJson } from './locate-package-json.js';
+const instanceSymbol = Symbol.for('instance');
+/**
+ * The `ExtensionRegistry` class is responsible for managing component and processor extensions,
+ * as well as handling the registration of extension packages. It provides methods to locate and
+ * retrieve extensions by their class name and version, and offers the ability to dynamically register
+ * packages, components, and processors at runtime.
+ *
+ * @class ExtensionRegistry
+ */
+export class ExtensionRegistry {
+    static [instanceSymbol] = new ExtensionRegistry();
+    static get packages() {
+        return this[instanceSymbol].packages;
+    }
+    static get components() {
+        return this[instanceSymbol].components;
+    }
+    static get processors() {
+        return this[instanceSymbol].processors;
+    }
+    static setResolver(fn) {
+        this[instanceSymbol].setResolver(fn);
+    }
+    static findComponent(className, version = '*') {
+        return this[instanceSymbol].findComponent(className, version);
     }
-    ExtensionRegistry.findComponent = findComponent;
+    static getComponent(className, version = '*') {
+        return this[instanceSymbol].getComponent(className, version);
+    }
+    static findProcessor(className, version = '*') {
+        return this[instanceSymbol].findProcessor(className, version);
+    }
+    static getProcessor(className, version = '*') {
+        return this[instanceSymbol].getProcessor(className, version);
+    }
+    static async registerPackage(specifier) {
+        return this[instanceSymbol].registerPackage(specifier);
+    }
+    static async registerComponent(ctor) {
+        return this[instanceSymbol].registerComponent(ctor);
+    }
+    static async registerProcessor(ctor) {
+        return this[instanceSymbol].registerProcessor(ctor);
+    }
+    static storePackage(pkg) {
+        return this[instanceSymbol].storePackage(pkg);
+    }
+    _resolver = import.meta.resolve;
+    packages = new ResponsiveMap();
+    components = new ResponsiveMap();
+    processors = new ResponsiveMap();
     /**
      *
      */
-    function getComponent(className, version = '*') {
-        const cmp = findComponent(className, version);
-        if (cmp)
-            return cmp;
-        throw new SbError(`Component "${className}" version "${version}" not found in registry`);
+    setResolver(fn) {
+        this._resolver = fn || import.meta.resolve;
     }
-    ExtensionRegistry.getComponent = getComponent;
     /**
      *
      */
-    function findProcessor(className, version = '*') {
-        return ExtensionRegistry.processors
+    findComponent(className, version = '*') {
+        return this.components
             .get(className)
             ?.find(v => semver.satisfies(v.version, version || '*'));
     }
-    ExtensionRegistry.findProcessor = findProcessor;
     /**
      *
      */
-    function getProcessor(className, version = '*') {
-        const cmp = findProcessor(className, version);
+    getComponent(className, version = '*') {
+        const cmp = this.findComponent(className, version);
         if (!cmp) {
-            throw new SbError(`Processor "${className}" version "${version}" not found in registry`);
+            throw new SbError(`Component "${className}@${version}" not found in registry`);
         }
         return cmp;
     }
-    ExtensionRegistry.getProcessor = getProcessor;
     /**
      *
      */
-    function setResolver(fn) {
-        _resolver = fn;
+    findProcessor(className, version = '*') {
+        return this.processors
+            .get(className)
+            ?.find(v => semver.satisfies(v.version, version || '*'));
     }
-    ExtensionRegistry.setResolver = setResolver;
     /**
      *
      */
-    async function registerExtensionPackage(directory) {
-        const pkg = await ExtensionPackage.fromDirectory(directory);
-        storePackage(pkg);
-        return pkg;
+    getProcessor(className, version = '*') {
+        const cmp = this.findProcessor(className, version);
+        if (!cmp) {
+            throw new SbError(`Processor "${className}@${version}" not found in registry`);
+        }
+        return cmp;
     }
-    ExtensionRegistry.registerExtensionPackage = registerExtensionPackage;
     /**
      *
      */
-    async function registerNodePackage(specifier) {
-        const pkg = await ExtensionPackage.fromNodePackage(specifier, _resolver);
-        storePackage(pkg);
+    async registerPackage(specifier) {
+        let entryPoint = this._resolver(specifier);
+        const pkgDir = locatePackageJson(path.dirname(entryPoint));
+        if (!pkgDir) {
+            throw new SbError(`Can't locate package.json file for "${specifier}"`);
+        }
+        const pkgJson = JSON.parse(fs.readFileSync(path.join(pkgDir, 'package.json'), 'utf8'));
+        if (path.isAbsolute(entryPoint) && process.platform === 'win32') {
+            entryPoint = pathToFileURL(entryPoint).href;
+        }
+        const pkg = new ExtensionPackage();
+        pkg.name = pkgJson.name;
+        pkg.version = pkgJson.version;
+        pkg.description = pkgJson.description;
+        pkg.path = pkgDir;
+        pkg.entryPoint = entryPoint;
+        const module = await import(entryPoint);
+        for (const [ctorName, v] of Object.entries(module)) {
+            if (typeof v !== 'function')
+                continue;
+            let metadata = Reflect.getMetadata(COMPONENT_OPTIONS, v);
+            if (metadata) {
+                try {
+                    metadata = await normalizeComponentMetadata(metadata);
+                }
+                catch (e) {
+                    updateErrorMessage(e, `Component (${ctorName}) metadata validation error. ` + e.message);
+                    pkg.errors.push(e);
+                    continue;
+                }
+                if (metadata.abstract)
+                    continue;
+                pkg.components = pkg.components || [];
+                pkg.components.push(new ComponentExtension(pkg, ctorName, metadata));
+            }
+            metadata = Reflect.getMetadata(PROCESSOR_OPTIONS, v);
+            if (metadata) {
+                try {
+                    metadata = await normalizeProcessorMetadata(metadata);
+                }
+                catch (e) {
+                    updateErrorMessage(e, `Processor (${ctorName}) metadata validation error. ` + e.message);
+                    pkg.errors.push(e);
+                    continue;
+                }
+                if (metadata.abstract)
+                    continue;
+                pkg.processors = pkg.processors || [];
+                pkg.processors.push(new ProcessorExtension(pkg, ctorName, metadata));
+            }
+        }
+        this.storePackage(pkg);
         return pkg;
     }
-    ExtensionRegistry.registerNodePackage = registerNodePackage;
-    async function registerComponent(ctor) {
+    async registerComponent(ctor) {
         const _metadata = Reflect.getMetadata(COMPONENT_OPTIONS, ctor);
         if (!_metadata)
             throw new SbError(`Class "${ctor.name}" has no component metadata.`);
         if (_metadata.abstract)
             return;
         const metadata = await normalizeComponentMetadata(_metadata);
-        let versions = ExtensionRegistry.packages.get('internal');
+        let versions = this.packages.get('internal');
         if (!versions) {
             versions = [];
-            ExtensionRegistry.packages.set('internal', versions);
+            this.packages.set('internal', versions);
         }
         let pkg = versions[0];
         if (!pkg) {
@@ -94,21 +180,23 @@ export var ExtensionRegistry;
         }
         const cmp = new ComponentExtension(pkg, ctor.name, metadata, ctor);
         pkg.components.push(cmp);
-        storePackage(pkg);
+        this.storePackage(pkg);
         return cmp;
     }
-    ExtensionRegistry.registerComponent = registerComponent;
-    async function registerProcessor(ctor) {
+    /**
+     *
+     */
+    async registerProcessor(ctor) {
         const _metadata = Reflect.getMetadata(PROCESSOR_OPTIONS, ctor);
         if (!_metadata)
             throw new SbError(`Class "${ctor.name}" has no processor metadata.`);
         if (_metadata.abstract)
             return;
         const metadata = await normalizeProcessorMetadata(_metadata);
-        let versions = ExtensionRegistry.packages.get('internal');
+        let versions = this.packages.get('internal');
         if (!versions) {
             versions = [];
-            ExtensionRegistry.packages.set('internal', versions);
+            this.packages.set('internal', versions);
         }
         let pkg = versions[0];
         if (!pkg) {
@@ -119,20 +207,17 @@ export var ExtensionRegistry;
         }
         const prc = new ProcessorExtension(pkg, ctor.name, metadata, ctor);
         pkg.processors.push(prc);
-        storePackage(pkg);
+        this.storePackage(pkg);
         return prc;
     }
-    ExtensionRegistry.registerProcessor = registerProcessor;
     /**
      *
-     * @private
      */
-    function storePackage(pkg) {
-        pkg.sortVersions();
-        let pkgVersions = ExtensionRegistry.packages.get(pkg.name);
+    storePackage(pkg) {
+        let pkgVersions = this.packages.get(pkg.name);
         if (!pkgVersions) {
             pkgVersions = [];
-            ExtensionRegistry.packages.set(pkg.name, pkgVersions);
+            this.packages.set(pkg.name, pkgVersions);
         }
         let i = pkgVersions.findIndex(v => v.version === pkg.version);
         if (i >= 0)
@@ -142,10 +227,10 @@ export var ExtensionRegistry;
         pkgVersions.sort((a, b) => a.version.localeCompare(b.version));
         if (pkg.components?.length) {
             for (const cmp of pkg.components) {
-                let versions = ExtensionRegistry.components.get(cmp.className);
+                let versions = this.components.get(cmp.className);
                 if (!versions) {
                     versions = [];
-                    ExtensionRegistry.components.set(cmp.className, versions);
+                    this.components.set(cmp.className, versions);
                 }
                 i = versions.findIndex(v => v.version === cmp.version);
                 if (i >= 0)
@@ -156,10 +241,10 @@ export var ExtensionRegistry;
         }
         if (pkg.processors?.length) {
             for (const prc of pkg.processors) {
-                let versions = ExtensionRegistry.processors.get(prc.className);
+                let versions = this.processors.get(prc.className);
                 if (!versions) {
                     versions = [];
-                    ExtensionRegistry.processors.set(prc.className, versions);
+                    this.processors.set(prc.className, versions);
                 }
                 i = versions.findIndex(v => v.version === prc.version);
                 if (i >= 0)
@@ -169,4 +254,4 @@ export var ExtensionRegistry;
             }
         }
     }
-})(ExtensionRegistry || (ExtensionRegistry = {}));
+}

package/registry/locate-package-json.d.ts

@@ -0,0 +1,4 @@
+/**
+ *
+ */
+export declare function locatePackageJson(directory: string): string | undefined;

package/registry/locate-package-json.js

@@ -0,0 +1,17 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+/**
+ *
+ */
+export function locatePackageJson(directory) {
+    if (directory.startsWith('file:'))
+        directory = fileURLToPath(directory);
+    for (let i = 0; i < 3; i++) {
+        const f = path.resolve(directory, 'package.json');
+        if (fs.existsSync(f)) {
+            return directory;
+        }
+        directory = path.dirname(directory);
+    }
+}

package/utils/normalize-metadata.d.ts

@@ -0,0 +1,12 @@
+import { StackExecutor } from '../classes/stack-executor.js';
+import { ComponentMetadata, ProcessorMetadata } from '../models/index.js';
+export declare function normalizeProcessorMetadata(metadata: ProcessorMetadata): Promise<ProcessorMetadata>;
+export declare function normalizeProcessorMetadataSilent(metadata: ProcessorMetadata): Promise<{
+    metadata: ProcessorMetadata;
+    issues?: StackExecutor.Issue[];
+}>;
+export declare function normalizeComponentMetadata(metadata: ComponentMetadata): Promise<ComponentMetadata>;
+export declare function normalizeComponentMetadataSilent(metadata: ComponentMetadata): Promise<{
+    metadata: ComponentMetadata;
+    issues?: StackExecutor.Issue[];
+}>;

package/utils/normalize-metadata.js

@@ -0,0 +1,149 @@
+import { deepClone, merge } from '@jsopen/objects';
+import { SbValidationError } from '../classes/sb-error.js';
+import { ComponentMetadata, ProcessorMetadata, } from '../models/index.js';
+import { initializeModelsDocument } from '../models-document.js';
+import { resolvePromisesDeep } from './resolve-promises.js';
+export async function normalizeProcessorMetadata(metadata) {
+    const { metadata: out, issues } = await normalizeProcessorMetadataSilent(metadata);
+    if (issues?.length) {
+        const msg = 'Worker profile decoding error.\n  ' +
+            issues
+                .map(issue => `- ${issue.message}. Location: /${issue.location}`)
+                .join('\n  ');
+        issues.forEach(issue => {
+            if (issue instanceof SbValidationError)
+                delete issue.stack;
+        });
+        throw new SbValidationError(msg, {
+            issues,
+        });
+    }
+    return out;
+}
+export async function normalizeProcessorMetadataSilent(metadata) {
+    const decoder = await getProcMetadataTypeDecoder();
+    let cloned = deepClone({
+        className: metadata.className,
+        displayName: metadata.displayName,
+        description: metadata.description,
+        iconUrl: metadata.iconUrl,
+        author: metadata.author,
+        tags: metadata.tags,
+        abstract: metadata.abstract,
+        variables: metadata.variables,
+        components: metadata.components,
+        ...metadata,
+    });
+    cloned = await resolvePromisesDeep(cloned);
+    cloned.variables = normalizeVariables(cloned.variables);
+    cloned.components = normalizeComponents(cloned.components);
+    const { value, errors } = decoder.silent(cloned);
+    merge(value, metadata, { keepExisting: true, deep: 'full' });
+    return {
+        metadata: value || cloned,
+        issues: errors?.map(x => ({
+            ...x.issue,
+            severity: 'error',
+        })),
+    };
+}
+export async function normalizeComponentMetadata(metadata) {
+    const { metadata: out, issues } = await normalizeComponentMetadataSilent(metadata);
+    if (issues?.length) {
+        const msg = 'Worker profile decoding error.\n  ' +
+            issues
+                .map(issue => `- ${issue.message}. Location: /${issue.location}`)
+                .join('\n  ');
+        issues.forEach(issue => {
+            if (issue instanceof SbValidationError)
+                delete issue.stack;
+        });
+        throw new SbValidationError(msg, {
+            issues,
+        });
+    }
+    return out;
+}
+export async function normalizeComponentMetadataSilent(metadata) {
+    const decoder = await getCompMetadataTypeDecoder();
+    let cloned = deepClone({
+        className: metadata.className,
+        displayName: metadata.displayName,
+        description: metadata.description,
+        iconUrl: metadata.iconUrl,
+        author: metadata.author,
+        interfaces: metadata.interfaces,
+        tags: metadata.tags,
+        abstract: metadata.abstract,
+        variables: metadata.variables,
+        components: metadata.components,
+        ...metadata,
+    });
+    cloned = await resolvePromisesDeep(cloned);
+    cloned.variables = normalizeVariables(cloned.variables);
+    cloned.components = normalizeComponents(cloned.components);
+    const { value, errors } = decoder.silent(cloned);
+    merge(value, metadata, { keepExisting: true, deep: 'full' });
+    return {
+        metadata: value || cloned,
+        issues: errors?.map(x => ({
+            ...x.issue,
+            severity: 'error',
+        })),
+    };
+}
+function normalizeComponents(components) {
+    if (!components)
+        return;
+    for (const component of Object.values(components)) {
+        if (component.variables)
+            component.variables = normalizeVariables(component.variables);
+        if (component.components)
+            component.components = normalizeComponents(component.components);
+    }
+    return components;
+}
+function normalizeVariables(variables) {
+    if (!variables)
+        return;
+    /** Convert object enumValues to arrays */
+    for (const v of Object.values(variables)) {
+        if (v.enumValues &&
+            typeof v.enumValues === 'object' &&
+            !Array.isArray(v.enumValues)) {
+            let values = v.enumValues;
+            const keys = Object.keys(values).filter(k => !/^\d+$/.test(k));
+            values = keys.reduce((a, k) => {
+                if (values[k] != null)
+                    a.push(values[k]);
+                return a;
+            }, []);
+            v.enumValues = values;
+        }
+    }
+    return variables;
+}
+// ************************************************************************
+// ************************************************************************
+let _compMetadataTypeDecoder;
+let _procMetadataTypeDecoder;
+async function getCompMetadataTypeDecoder() {
+    if (!_compMetadataTypeDecoder) {
+        const apiDoc = await initializeModelsDocument();
+        const compMetadataType = apiDoc.node.getComplexType(ComponentMetadata);
+        _compMetadataTypeDecoder = compMetadataType.generateCodec('decode', {
+            coerce: true,
+        });
+    }
+    return _compMetadataTypeDecoder;
+}
+async function getProcMetadataTypeDecoder() {
+    if (!_procMetadataTypeDecoder) {
+        const apiDoc = await initializeModelsDocument();
+        const procMetadataType = apiDoc.node.getComplexType(ProcessorMetadata);
+        _procMetadataTypeDecoder = procMetadataType.generateCodec('decode', {
+            coerce: true,
+        });
+    }
+    return _procMetadataTypeDecoder;
+}

package/registry/normalize-metadata.d.ts

@@ -1,3 +0,0 @@
-import { ComponentMetadata, ProcessorMetadata } from '../models/index.js';
-export declare function normalizeProcessorMetadata(metadata: ProcessorMetadata): Promise<ProcessorMetadata>;
-export declare function normalizeComponentMetadata(metadata: ComponentMetadata): Promise<ComponentMetadata>;

package/registry/normalize-metadata.js

@@ -1,98 +0,0 @@
-import { deepClone, merge } from '@jsopen/objects';
-import { ComponentMetadata, ProcessorMetadata, } from '../models/index.js';
-import { initializeModelsDocument } from '../models-document.js';
-import { resolvePromisesDeep } from '../utils/resolve-promises.js';
-export async function normalizeProcessorMetadata(metadata) {
-    const decoder = await getProcMetadataTypeDecoder();
-    let out = await resolvePromisesDeep(metadata);
-    out = deepClone(out);
-    out = decoder({
-        className: out.className,
-        displayName: out.displayName,
-        description: out.description,
-        iconUrl: out.iconUrl,
-        author: out.author,
-        tags: out.tags,
-        abstract: out.abstract,
-        variables: normalizeVariables(out.variables),
-        components: normalizeComponents(out.components),
-        ...out,
-    });
-    merge(out, metadata, { keepExisting: true, deep: 'full' });
-    return out;
-}
-export async function normalizeComponentMetadata(metadata) {
-    const decoder = await getCompMetadataTypeDecoder();
-    let out = await resolvePromisesDeep(metadata);
-    out = deepClone(out);
-    out = decoder({
-        className: out.className,
-        displayName: out.displayName,
-        description: out.description,
-        iconUrl: out.iconUrl,
-        author: out.author,
-        interfaces: out.interfaces,
-        tags: out.tags,
-        abstract: out.abstract,
-        variables: normalizeVariables(out.variables),
-        components: normalizeComponents(out.components),
-        ...out,
-    });
-    merge(out, metadata, { keepExisting: true, deep: 'full' });
-    return out;
-}
-function normalizeComponents(components) {
-    if (!components)
-        return;
-    for (const component of Object.values(components)) {
-        if (component.variables)
-            component.variables = normalizeVariables(component.variables);
-        if (component.components)
-            component.components = normalizeComponents(component.components);
-    }
-    return components;
-}
-function normalizeVariables(variables) {
-    if (!variables)
-        return;
-    /** Convert object enumValues to arrays */
-    for (const v of Object.values(variables)) {
-        if (v.enumValues &&
-            typeof v.enumValues === 'object' &&
-            !Array.isArray(v.enumValues)) {
-            let values = v.enumValues;
-            const keys = Object.keys(values).filter(k => !/^\d+$/.test(k));
-            values = keys.reduce((a, k) => {
-                if (values[k] != null)
-                    a.push(values[k]);
-                return a;
-            }, []);
-            v.enumValues = values;
-        }
-    }
-    return variables;
-}
-// ************************************************************************
-// ************************************************************************
-let _compMetadataTypeDecoder;
-let _procMetadataTypeDecoder;
-async function getCompMetadataTypeDecoder() {
-    if (!_compMetadataTypeDecoder) {
-        const apiDoc = await initializeModelsDocument();
-        const compMetadataType = apiDoc.node.getComplexType(ComponentMetadata);
-        _compMetadataTypeDecoder = compMetadataType.generateCodec('decode', {
-            coerce: true,
-        });
-    }
-    return _compMetadataTypeDecoder;
-}
-async function getProcMetadataTypeDecoder() {
-    if (!_procMetadataTypeDecoder) {
-        const apiDoc = await initializeModelsDocument();
-        const procMetadataType = apiDoc.node.getComplexType(ProcessorMetadata);
-        _procMetadataTypeDecoder = procMetadataType.generateCodec('decode', {
-            coerce: true,
-        });
-    }
-    return _procMetadataTypeDecoder;
-}