@syncbridge/common 0.4.7 → 0.5.2

package/registry.js

@@ -1,205 +0,0 @@
-import * as fs from 'node:fs';
-import path from 'node:path';
-import process from 'node:process';
-import { fileURLToPath, pathToFileURL } from 'node:url';
-import { deepClone, isPlainObject } from '@jsopen/objects';
-import { COMPONENT_OPTIONS, PROCESSOR_OPTIONS } from './constants.js';
-import { isExtensionPackage } from './utils/make-extension-package.js';
-export var ExtensionRegistry;
-(function (ExtensionRegistry) {
-    let _resolver = import.meta.resolve;
-    ExtensionRegistry.packages = new Map();
-    ExtensionRegistry.components = new Map();
-    ExtensionRegistry.processors = new Map();
-    function setResolver(resolver) {
-        _resolver = resolver;
-    }
-    ExtensionRegistry.setResolver = setResolver;
-    function getProcessor(className) {
-        const rec = ExtensionRegistry.processors.get(className);
-        if (!rec) {
-            throw new Error(`Processor "${className}" not found in registry`);
-        }
-        return rec;
-    }
-    ExtensionRegistry.getProcessor = getProcessor;
-    function getComponent(className) {
-        const rec = ExtensionRegistry.components.get(className);
-        if (!rec) {
-            throw new Error(`Component "${className}" not found in registry`);
-        }
-        return rec;
-    }
-    ExtensionRegistry.getComponent = getComponent;
-    async function registerPackage(...specifiers) {
-        const errors = [];
-        await Promise.all(specifiers.map(specifier => _registerPackage(specifier).catch(err => {
-            errors.push(`\n    ${specifier}: ${err.message}`);
-        })));
-        if (errors.length) {
-            console.error(`Failed to register extensions:${errors}`);
-        }
-    }
-    ExtensionRegistry.registerPackage = registerPackage;
-    async function _registerPackage(specifier, options) {
-        let packagePath = fileURLToPath(_resolver(specifier));
-        const json = locatePkgJson(path.dirname(packagePath));
-        if (!json) {
-            if (options?.ignoreInvalid)
-                return;
-            throw new TypeError(`Can't locate package.json file for "${specifier}"`);
-        }
-        if (path.isAbsolute(packagePath) && process.platform === 'win32') {
-            packagePath = pathToFileURL(packagePath).href;
-        }
-        const pkg = (await import(packagePath)).default;
-        if (!isExtensionPackage(pkg)) {
-            if (options?.ignoreInvalid)
-                return;
-            throw new TypeError(`"${specifier}" do not export ExtensionPackage interface`);
-        }
-        // ignore if already registered
-        if (ExtensionRegistry.packages.get(json.name))
-            return;
-        // Register dependencies
-        if (pkg.dependencies) {
-            for (const dep of pkg.dependencies)
-                await _registerPackage(dep, { ignoreInvalid: true });
-        }
-        const packageRec = Object.freeze({
-            name: json.name,
-            version: json.version,
-            description: json.description,
-        });
-        ExtensionRegistry.packages.set(packageRec.name, packageRec);
-        if (Array.isArray(pkg.components)) {
-            for (const ctor of pkg.components) {
-                await registerComponent(ctor, packageRec.name);
-            }
-        }
-        if (Array.isArray(pkg.processors)) {
-            for (const ctor of pkg.processors) {
-                await registerProcessor(ctor, packageRec.name);
-            }
-        }
-    }
-    async function registerComponent(ctor, packageName) {
-        const _metadata = Reflect.getMetadata(COMPONENT_OPTIONS, ctor);
-        if (!_metadata)
-            throw new TypeError(`Class "${ctor.name}" has no component metadata.`);
-        if (_metadata.abstract)
-            return;
-        let componentRec = ExtensionRegistry.components.get(_metadata.className);
-        if (componentRec)
-            throw new TypeError(`Component "${_metadata.className}" already registered by "${componentRec.package}" package`);
-        let metadata = await resolvePromisesDeep(_metadata);
-        metadata = 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,
-        });
-        if (metadata.variables) {
-            /** Convert object enumValues to arrays */
-            for (const v of Object.values(metadata.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 => !(typeof v === 'number' && !keys.includes(String(v))),
-                    }, []);
-                    v.enumValues = values;
-                }
-            }
-        }
-        componentRec = {
-            package: packageName,
-            ctor,
-            metadata,
-        };
-        ExtensionRegistry.components.set(metadata.className, componentRec);
-    }
-    ExtensionRegistry.registerComponent = registerComponent;
-    async function registerProcessor(ctor, packageName) {
-        const _metadata = Reflect.getMetadata(PROCESSOR_OPTIONS, ctor);
-        if (!_metadata)
-            throw new TypeError(`Class "${ctor.name}" has no processor metadata.`);
-        if (_metadata.abstract)
-            return;
-        let processorRec = ExtensionRegistry.processors.get(_metadata.className);
-        if (processorRec)
-            throw new TypeError(`Processor "${_metadata.className}" already registered by "${processorRec.package}" package`);
-        let metadata = await resolvePromisesDeep(_metadata);
-        metadata = 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,
-        });
-        if (metadata.variables) {
-            /** Convert object enumValues to arrays */
-            for (const v of Object.values(metadata.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 => !(typeof v === 'number' && !keys.includes(String(v))),
-                    }, []);
-                    v.enumValues = values;
-                }
-            }
-        }
-        processorRec = {
-            package: packageName,
-            ctor,
-            metadata,
-        };
-        ExtensionRegistry.processors.set(metadata.className, processorRec);
-    }
-    ExtensionRegistry.registerProcessor = registerProcessor;
-})(ExtensionRegistry || (ExtensionRegistry = {}));
-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);
-    }
-}
-async function resolvePromisesDeep(obj) {
-    obj = await obj;
-    if (obj && isPlainObject(obj)) {
-        for (const k of Object.keys(obj)) {
-            obj[k] = await resolvePromisesDeep(obj[k]);
-        }
-    }
-    return obj;
-}

package/utils/make-extension-package.d.ts

@@ -1,3 +0,0 @@
-import { IExtensionPackage } from '../interfaces/index.js';
-export declare function makeExtensionPackage(pkg: IExtensionPackage): IExtensionPackage;
-export declare function isExtensionPackage(pkg: IExtensionPackage): pkg is IExtensionPackage;

package/utils/make-extension-package.js

@@ -1,13 +0,0 @@
-const marker = Symbol('marker');
-export function makeExtensionPackage(pkg) {
-    Object.defineProperty(pkg, marker, {
-        configurable: false,
-        writable: false,
-        enumerable: false,
-        value: 1,
-    });
-    return pkg;
-}
-export function isExtensionPackage(pkg) {
-    return pkg && typeof pkg === 'object' && pkg[marker] === 1;
-}