@syncbridge/common 0.6.12 → 0.7.0

package/processor-factory.js

@@ -1,5 +1,5 @@
 import equal from 'fast-deep-equal';
-import { SbError } from './classes/sb-error.js';
+import { SbError, SbValidationError } from './classes/sb-error.js';
 import { StackExecutor } from './classes/stack-executor.js';
 import { initializeModelsDocument } from './models-document.js';
 import { ExtensionRegistry } from './registry/extension-registry.js';
@@ -9,8 +9,26 @@ export var ProcessorFactory;
     ProcessorFactory.METADATA_KEY = Symbol('METADATA');
     ProcessorFactory.PROFILE_KEY = Symbol('PROFILE');
     async function createProcessor(profile, options) {
+        const { processor: out, issues } = await createProcessorSilent(profile, options);
+        if (issues?.length) {
+            const msg = 'Error while creating processor.\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;
+    }
+    ProcessorFactory.createProcessor = createProcessor;
+    async function createProcessorSilent(profile, options) {
         await initializeModelsDocument();
-        const reg = ExtensionRegistry.getProcessor(profile.processorClass, profile.processorVersion);
+        const reg = ExtensionRegistry.getProcessor(profile.processorUri, profile.processorVersion);
         const processorClass = await reg.getClass();
         const processor = new processorClass({
             name: profile.displayName,
@@ -31,7 +49,7 @@ export var ProcessorFactory;
             issues: ctx.stackExecutor.issues,
         };
     }
-    ProcessorFactory.createProcessor = createProcessor;
+    ProcessorFactory.createProcessorSilent = createProcessorSilent;
     async function updateProcessor(processor, profile, options) {
         if (options?.logger)
             processor.logger = options.logger;
@@ -93,10 +111,10 @@ export var ProcessorFactory;
                     const componentPath = curPath ? curPath + '/' + key : key;
                     const componentInstance = owner.components?.[key];
                     if (processor.stopped &&
-                        oldMetadata?.className &&
-                        oldMetadata?.className !== newMetadata.className)
+                        oldMetadata?.uri &&
+                        oldMetadata?.uri !== newMetadata.uri)
                         throw new SbError('Cannot change component class while processor running. You should stop it first.');
-                    /** Validate sub components */
+                    /** Validate sub-components */
                     if (childMetadata.components && componentInstance) {
                         _validateComponents({
                             ...ctx,
@@ -130,7 +148,7 @@ export var ProcessorFactory;
     async function _configureComponent(ctx, key, childMetadata) {
         const { newProfile, oldMetadata, oldProfile, curPath, owner, processor } = ctx;
         const childProfile = newProfile.components[key];
-        if (!childProfile?.className)
+        if (!childProfile?.uri)
             return;
         const oldChildMetadata = oldMetadata?.components?.[key];
         const oldChildProfile = oldProfile?.components?.[key];
@@ -138,7 +156,7 @@ export var ProcessorFactory;
         let componentInstance = owner.components?.[key];
         /** Create the component only if the owner stopped */ // todo implement hotplug components
         if (owner.stopped) {
-            const compReg = ExtensionRegistry.getComponent(childMetadata.className);
+            const compReg = ExtensionRegistry.getComponent(childMetadata.uri);
             /** Create the component instance */
             const compClass = await compReg.getClass();
             componentInstance = new compClass({

package/registry/extension-package.d.ts

@@ -1,8 +1,9 @@
 import 'reflect-metadata';
 import { Type } from 'ts-gems';
+import { BaseElement } from '../classes/base-element.js';
 import { ComponentBase } from '../classes/component-base.js';
 import { ProcessorBase } from '../classes/processor-base.js';
-import { ComponentMetadata, ProcessorMetadata } from '../models/index.js';
+import { ComponentMetadata, ElementMetadata, ProcessorMetadata } from '../models/index.js';
 /**
  *
  */
@@ -19,28 +20,37 @@ export declare class ExtensionPackage {
 /**
  *
  */
-export declare class ComponentExtension {
+export declare abstract class ExtensionBase {
+    abstract readonly kind: 'component' | 'processor';
+    protected _ctor?: Type;
     readonly pkg: ExtensionPackage;
     readonly exportName: string;
-    readonly metadata: ComponentMetadata;
-    protected _ctor?: Type<ComponentBase>;
-    constructor(pkg: ExtensionPackage, exportName: string, metadata: ComponentMetadata, ctor?: Type<ComponentBase>);
-    get className(): string;
+    readonly metadata: ElementMetadata;
+    readonly name: string;
+    readonly packageName: string;
+    protected constructor(pkg: ExtensionPackage, exportName: string, metadata: ElementMetadata, ctor?: Type<BaseElement>);
+    get id(): string;
+    get uri(): string;
     get displayName(): string;
     get version(): string;
+}
+/**
+ *
+ */
+export declare class ComponentExtension extends ExtensionBase {
+    readonly kind = "component";
+    protected _ctor?: Type<ComponentBase>;
+    readonly metadata: ComponentMetadata;
+    constructor(pkg: ExtensionPackage, exportName: string, metadata: ComponentMetadata, ctor?: Type<ComponentBase>);
     getClass(): Promise<Type<ComponentBase>>;
 }
 /**
  *
  */
-export declare class ProcessorExtension {
-    readonly pkg: ExtensionPackage;
-    readonly exportName: string;
-    readonly metadata: ProcessorMetadata;
+export declare class ProcessorExtension extends ExtensionBase {
+    readonly kind = "processor";
     protected _ctor?: Type<ProcessorBase>;
+    readonly metadata: ProcessorMetadata;
     constructor(pkg: ExtensionPackage, exportName: string, metadata: ProcessorMetadata, ctor?: Type<ProcessorBase>);
-    get className(): string;
-    get displayName(): string;
-    get version(): string;
     getClass(): Promise<Type<ProcessorBase>>;
 }

package/registry/extension-package.js

@@ -12,19 +12,27 @@ export class ExtensionPackage {
 /**
  *
  */
-export class ComponentExtension {
+export class ExtensionBase {
+    _ctor;
     pkg;
     exportName;
     metadata;
-    _ctor;
+    name;
+    packageName;
     constructor(pkg, exportName, metadata, ctor) {
         this.pkg = pkg;
         this.exportName = exportName;
         this.metadata = metadata;
         this._ctor = ctor;
+        const [packageName, name] = metadata.uri.split(':');
+        this.name = name;
+        this.packageName = packageName;
+    }
+    get id() {
+        return this.metadata.id;
     }
-    get className() {
-        return this.metadata.className;
+    get uri() {
+        return this.metadata.uri;
     }
     get displayName() {
         return this.metadata.displayName;
@@ -32,6 +40,17 @@ export class ComponentExtension {
     get version() {
         return this.pkg.version;
     }
+}
+/**
+ *
+ */
+export class ComponentExtension extends ExtensionBase {
+    kind = 'component';
+    constructor(pkg, exportName, metadata, ctor) {
+        super(pkg, exportName, metadata, ctor);
+        if (ctor && !isComponentBase(ctor.prototype))
+            throw new SbError(`${ctor.name} does not extends ComponentBase`);
+    }
     async getClass() {
         if (this._ctor)
             return this._ctor;
@@ -50,25 +69,12 @@ export class ComponentExtension {
 /**
  *
  */
-export class ProcessorExtension {
-    pkg;
-    exportName;
-    metadata;
-    _ctor;
+export class ProcessorExtension extends ExtensionBase {
+    kind = 'processor';
     constructor(pkg, exportName, metadata, ctor) {
-        this.pkg = pkg;
-        this.exportName = exportName;
-        this.metadata = metadata;
-        this._ctor = ctor;
-    }
-    get className() {
-        return this.metadata.className;
-    }
-    get displayName() {
-        return this.metadata.displayName;
-    }
-    get version() {
-        return this.pkg.version;
+        super(pkg, exportName, metadata, ctor);
+        if (ctor && !isProcessorBase(ctor.prototype))
+            throw new SbError(`${ctor.name} does not extends ProcessorBase`);
     }
     async getClass() {
         if (this._ctor)

package/registry/extension-registry.d.ts

@@ -1,5 +1,7 @@
 import { ResponsiveMap } from '@opra/common';
 import { Type } from 'ts-gems';
+import { ComponentBase } from '../classes/component-base.js';
+import { ProcessorBase } from '../classes/processor-base.js';
 import { ComponentExtension, ExtensionPackage, ProcessorExtension } from './extension-package.js';
 declare const instanceSymbol: unique symbol;
 /**
@@ -14,20 +16,28 @@ export declare class ExtensionRegistry {
     protected static [instanceSymbol]: ExtensionRegistry;
     static get packages(): ResponsiveMap<ExtensionPackage[]>;
     static get components(): ResponsiveMap<ComponentExtension[]>;
+    static get componentsById(): ResponsiveMap<ComponentExtension[]>;
+    static get componentsByClassName(): ResponsiveMap<ComponentExtension[]>;
     static get processors(): ResponsiveMap<ProcessorExtension[]>;
+    static get processorsById(): ResponsiveMap<ProcessorExtension[]>;
+    static get processorsByClassName(): 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 findComponent(uri: string, version?: string): ComponentExtension | undefined;
+    static getComponent(uri: string, version?: string): ComponentExtension;
+    static findProcessor(uri: string, version?: string): ProcessorExtension | undefined;
+    static getProcessor(uri: 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 registerClass<T extends ComponentBase>(ctor: Type<T>): Promise<ComponentExtension>;
+    static registerClass<T extends ProcessorBase>(ctor: Type<T>): Promise<ProcessorExtension>;
     static storePackage(pkg: ExtensionPackage): void;
     protected _resolver: ExtensionRegistry.PackageResolver;
     readonly packages: ResponsiveMap<ExtensionPackage[]>;
     readonly components: ResponsiveMap<ComponentExtension[]>;
+    readonly componentsById: ResponsiveMap<ComponentExtension[]>;
+    readonly componentsByClassName: ResponsiveMap<ComponentExtension[]>;
     readonly processors: ResponsiveMap<ProcessorExtension[]>;
+    readonly processorsById: ResponsiveMap<ProcessorExtension[]>;
+    readonly processorsByClassName: ResponsiveMap<ProcessorExtension[]>;
     /**
      *
      */
@@ -35,28 +45,25 @@ export declare class ExtensionRegistry {
     /**
      *
      */
-    findComponent(className: string, version?: string): ComponentExtension | undefined;
+    findComponent(uri: string, version?: string): ComponentExtension | undefined;
     /**
      *
      */
-    getComponent(className: string, version?: string): ComponentExtension;
+    getComponent(uri: string, version?: string): ComponentExtension;
     /**
      *
      */
-    findProcessor(className: string, version?: string): ProcessorExtension | undefined;
+    findProcessor(uri: string, version?: string): ProcessorExtension | undefined;
     /**
      *
      */
-    getProcessor(className: string, version?: string): ProcessorExtension;
+    getProcessor(uri: string, version?: string): ProcessorExtension;
     /**
      *
      */
     registerPackage(specifier: string): Promise<ExtensionPackage>;
-    registerComponent(ctor: Type): Promise<ComponentExtension | undefined>;
-    /**
-     *
-     */
-    registerProcessor(ctor: Type): Promise<ProcessorExtension | undefined>;
+    registerClass<T extends ComponentBase>(ctor: Type<T>): Promise<ComponentExtension>;
+    registerClass<T extends ProcessorBase>(ctor: Type<T>): Promise<ProcessorExtension>;
     /**
      *
      */

package/registry/extension-registry.js

@@ -5,10 +5,10 @@ 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 { CLASS_METADATA, CLASS_TYPE } from '../constants.js';
+import { locatePackageJson } from '../utils/locate-package-json.js';
 import { normalizeComponentMetadata, normalizeProcessorMetadata, } from '../utils/normalize-metadata.js';
 import { ComponentExtension, ExtensionPackage, ProcessorExtension, } from './extension-package.js';
-import { locatePackageJson } from './locate-package-json.js';
 const instanceSymbol = Symbol.for('instance');
 /**
  * The `ExtensionRegistry` class is responsible for managing component and processor extensions,
@@ -26,32 +26,41 @@ export class ExtensionRegistry {
     static get components() {
         return this[instanceSymbol].components;
     }
+    static get componentsById() {
+        return this[instanceSymbol].componentsById;
+    }
+    static get componentsByClassName() {
+        return this[instanceSymbol].componentsByClassName;
+    }
     static get processors() {
         return this[instanceSymbol].processors;
     }
+    static get processorsById() {
+        return this[instanceSymbol].processorsById;
+    }
+    static get processorsByClassName() {
+        return this[instanceSymbol].processorsByClassName;
+    }
     static setResolver(fn) {
         this[instanceSymbol].setResolver(fn);
     }
-    static findComponent(className, version = '*') {
-        return this[instanceSymbol].findComponent(className, version);
+    static findComponent(uri, version = '*') {
+        return this[instanceSymbol].findComponent(uri, version);
     }
-    static getComponent(className, version = '*') {
-        return this[instanceSymbol].getComponent(className, version);
+    static getComponent(uri, version = '*') {
+        return this[instanceSymbol].getComponent(uri, version);
     }
-    static findProcessor(className, version = '*') {
-        return this[instanceSymbol].findProcessor(className, version);
+    static findProcessor(uri, version = '*') {
+        return this[instanceSymbol].findProcessor(uri, version);
     }
-    static getProcessor(className, version = '*') {
-        return this[instanceSymbol].getProcessor(className, version);
+    static getProcessor(uri, version = '*') {
+        return this[instanceSymbol].getProcessor(uri, 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 async registerClass(ctor) {
+        return this[instanceSymbol].registerClass(ctor);
     }
     static storePackage(pkg) {
         return this[instanceSymbol].storePackage(pkg);
@@ -59,7 +68,11 @@ export class ExtensionRegistry {
     _resolver = import.meta.resolve;
     packages = new ResponsiveMap();
     components = new ResponsiveMap();
+    componentsById = new ResponsiveMap();
+    componentsByClassName = new ResponsiveMap();
     processors = new ResponsiveMap();
+    processorsById = new ResponsiveMap();
+    processorsByClassName = new ResponsiveMap();
     /**
      *
      */
@@ -69,36 +82,32 @@ export class ExtensionRegistry {
     /**
      *
      */
-    findComponent(className, version = '*') {
-        return this.components
-            .get(className)
-            ?.find(v => semver.satisfies(v.version, version || '*'));
+    findComponent(uri, version = '*') {
+        return (this.components.get(uri) || this.componentsById.get(uri))?.find(v => semver.satisfies(v.version, version || '*'));
     }
     /**
      *
      */
-    getComponent(className, version = '*') {
-        const cmp = this.findComponent(className, version);
+    getComponent(uri, version = '*') {
+        const cmp = this.findComponent(uri, version);
         if (!cmp) {
-            throw new SbError(`Component "${className}@${version}" not found in registry`);
+            throw new SbError(`Component "${uri}@${version}" not found in registry`);
         }
         return cmp;
     }
     /**
      *
      */
-    findProcessor(className, version = '*') {
-        return this.processors
-            .get(className)
-            ?.find(v => semver.satisfies(v.version, version || '*'));
+    findProcessor(uri, version = '*') {
+        return (this.processors.get(uri) || this.processorsById.get(uri))?.find(v => semver.satisfies(v.version, version || '*'));
     }
     /**
      *
      */
-    getProcessor(className, version = '*') {
-        const cmp = this.findProcessor(className, version);
+    getProcessor(uri, version = '*') {
+        const cmp = this.findProcessor(uri, version);
         if (!cmp) {
-            throw new SbError(`Processor "${className}@${version}" not found in registry`);
+            throw new SbError(`Processor "${uri}@${version}" not found in registry`);
         }
         return cmp;
     }
@@ -116,7 +125,7 @@ export class ExtensionRegistry {
             entryPoint = pathToFileURL(entryPoint).href;
         }
         const pkg = new ExtensionPackage();
-        pkg.name = pkgJson.name;
+        pkg.name = pkgJson.syncbridge?.name || pkgJson.name;
         pkg.version = pkgJson.version;
         pkg.description = pkgJson.description;
         pkg.path = pkgDir;
@@ -125,8 +134,11 @@ export class ExtensionRegistry {
         for (const [ctorName, v] of Object.entries(module)) {
             if (typeof v !== 'function')
                 continue;
-            let metadata = Reflect.getMetadata(COMPONENT_OPTIONS, v);
-            if (metadata) {
+            const classType = Reflect.getMetadata(CLASS_TYPE, v);
+            let metadata = Reflect.getMetadata(CLASS_METADATA, v);
+            if (!metadata)
+                continue;
+            if (classType === 'component') {
                 try {
                     metadata = await normalizeComponentMetadata(metadata);
                 }
@@ -140,8 +152,7 @@ export class ExtensionRegistry {
                 pkg.components = pkg.components || [];
                 pkg.components.push(new ComponentExtension(pkg, ctorName, metadata));
             }
-            metadata = Reflect.getMetadata(PROCESSOR_OPTIONS, v);
-            if (metadata) {
+            else if (classType === 'processor') {
                 try {
                     metadata = await normalizeProcessorMetadata(metadata);
                 }
@@ -159,56 +170,49 @@ export class ExtensionRegistry {
         this.storePackage(pkg);
         return pkg;
     }
-    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 = this.packages.get('internal');
-        if (!versions) {
-            versions = [];
-            this.packages.set('internal', versions);
+    async registerClass(ctor) {
+        let metadata = Reflect.getMetadata(CLASS_METADATA, ctor);
+        if (!metadata)
+            throw new TypeError(`Class "${ctor.name}" has no component metadata.`);
+        if (metadata.abstract)
+            throw new TypeError('Can not register an abstract class');
+        const classType = Reflect.getMetadata(CLASS_TYPE, ctor);
+        if (classType === 'component') {
+            metadata = await normalizeComponentMetadata(metadata);
         }
-        let pkg = versions[0];
-        if (!pkg) {
-            pkg = new ExtensionPackage();
-            pkg.name = 'internal';
-            pkg.version = '0.0.0';
-            pkg.description = 'Internal extensions';
+        else if (classType === 'processor') {
+            metadata = await normalizeProcessorMetadata(metadata);
         }
-        const cmp = new ComponentExtension(pkg, ctor.name, metadata, ctor);
-        pkg.components.push(cmp);
-        this.storePackage(pkg);
-        return cmp;
-    }
-    /**
-     *
-     */
-    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 = this.packages.get('internal');
+        else
+            /* c8 ignore next */
+            throw new TypeError(`Invalid CLASS_TYPE metadata in "${ctor.name}".`);
+        const [packageName, className] = metadata.uri.split(':');
+        /* c8 ignore next */
+        if (!(packageName && className))
+            throw new TypeError(`Invalid metadata.uri value in ${ctor.name}"`);
+        const version = metadata.version || '0.0.0';
+        let versions = this.packages.get(packageName);
         if (!versions) {
             versions = [];
-            this.packages.set('internal', versions);
+            this.packages.set(packageName, versions);
         }
         let pkg = versions[0];
         if (!pkg) {
             pkg = new ExtensionPackage();
-            pkg.name = 'internal';
-            pkg.version = '0.0.0';
-            pkg.description = 'Internal extensions';
+            pkg.name = packageName;
+            pkg.version = version;
+        }
+        let out;
+        if (classType === 'component') {
+            out = new ComponentExtension(pkg, ctor.name, metadata, ctor);
+            pkg.components.push(out);
+        }
+        else {
+            out = new ProcessorExtension(pkg, ctor.name, metadata, ctor);
+            pkg.processors.push(out);
         }
-        const prc = new ProcessorExtension(pkg, ctor.name, metadata, ctor);
-        pkg.processors.push(prc);
         this.storePackage(pkg);
-        return prc;
+        return out;
     }
     /**
      *
@@ -227,30 +231,60 @@ export class ExtensionRegistry {
         pkgVersions.sort((a, b) => a.version.localeCompare(b.version));
         if (pkg.components?.length) {
             for (const cmp of pkg.components) {
-                let versions = this.components.get(cmp.className);
-                if (!versions) {
-                    versions = [];
-                    this.components.set(cmp.className, versions);
+                if (this.processors.get(cmp.uri))
+                    throw new SbError(`Component "${cmp.uri}" is already registered as a processor.`);
+                /** Store to components */
+                let items = this.components.get(cmp.uri);
+                if (!items) {
+                    items = [];
+                    this.components.set(cmp.uri, items);
+                    this.componentsById.set(cmp.id, items);
                 }
-                i = versions.findIndex(v => v.version === cmp.version);
+                i = items.findIndex(v => v.version === cmp.version);
                 if (i >= 0)
-                    versions[i] = cmp;
+                    items[i] = cmp;
                 else
-                    versions.push(cmp);
+                    items.push(cmp);
+                /** Store to componentsByClassName */
+                items = this.componentsByClassName.get(cmp.name);
+                if (!items) {
+                    items = [];
+                    this.componentsByClassName.set(cmp.name, items);
+                }
+                i = items.findIndex(v => v.version === cmp.version);
+                if (i >= 0)
+                    items[i] = cmp;
+                else
+                    items.push(cmp);
             }
         }
         if (pkg.processors?.length) {
             for (const prc of pkg.processors) {
-                let versions = this.processors.get(prc.className);
-                if (!versions) {
-                    versions = [];
-                    this.processors.set(prc.className, versions);
+                if (this.components.get(prc.uri))
+                    throw new SbError(`Processor "${prc.uri}" is already registered as a component.`);
+                /** Store to processors */
+                let items = this.processors.get(prc.uri);
+                if (!items) {
+                    items = [];
+                    this.processors.set(prc.uri, items);
+                    this.processorsById.set(prc.id, items);
+                }
+                i = items.findIndex(v => v.version === prc.version);
+                if (i >= 0)
+                    items[i] = prc;
+                else
+                    items.push(prc);
+                /** Store to componentsByClassName */
+                items = this.processors.get(prc.name);
+                if (!items) {
+                    items = [];
+                    this.processorsByClassName.set(prc.name, items);
                 }
-                i = versions.findIndex(v => v.version === prc.version);
+                i = items.findIndex(v => v.version === prc.version);
                 if (i >= 0)
-                    versions[i] = prc;
+                    items[i] = prc;
                 else
-                    versions.push(prc);
+                    items.push(prc);
             }
         }
     }

package/utils/decode-profile.js

@@ -64,7 +64,7 @@ export function encodeProfileSilent(metadata, rawProfile, options) {
     const fn = t.generateCodec('encode', { coerce: true });
     const out = fn({
         id: rawProfile.id,
-        processorClass: rawProfile.processorClass,
+        processorUri: rawProfile.processorUri,
         displayName: rawProfile.displayName,
         group: rawProfile.group,
         description: rawProfile.description,

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

@@ -0,0 +1,5 @@
+/**
+ *
+ */
+export declare function locatePackageJson(directory: string, depth?: number): string | undefined;
+export declare function resolvePackageJson(directory: string): any | undefined;

package/{registry → utils}/locate-package-json.js

@@ -4,10 +4,10 @@ import { fileURLToPath } from 'node:url';
 /**
  *
  */
-export function locatePackageJson(directory) {
+export function locatePackageJson(directory, depth = 10) {
     if (directory.startsWith('file:'))
         directory = fileURLToPath(directory);
-    for (let i = 0; i < 3; i++) {
+    for (let i = 0; i < depth; i++) {
         const f = path.resolve(directory, 'package.json');
         if (fs.existsSync(f)) {
             return directory;
@@ -15,3 +15,10 @@ export function locatePackageJson(directory) {
         directory = path.dirname(directory);
     }
 }
+export function resolvePackageJson(directory) {
+    const pkg = locatePackageJson(directory);
+    if (!pkg)
+        return;
+    const content = fs.readFileSync(path.resolve(pkg, 'package.json'), 'utf-8');
+    return JSON.parse(content);
+}