@syncbridge/common 0.5.8 → 0.5.10

package/classes/component-base.js

@@ -10,3 +10,5 @@ export class ComponentBase extends BaseElement {
         this.path = init.path;
     }
 }
+const COMPONENT_BASE_TOKEN = Symbol.for(ComponentBase.name);
+ComponentBase.prototype[COMPONENT_BASE_TOKEN] = true;

package/classes/processor-base.js

@@ -6,3 +6,5 @@ export class ProcessorBase extends BaseElement {
         this.dataDirectory = init.dataDirectory;
     }
 }
+const PROCESSOR_BASE_TOKEN = Symbol.for(ProcessorBase.name);
+ProcessorBase.prototype[PROCESSOR_BASE_TOKEN] = true;

package/classes/runnable.js

@@ -226,3 +226,5 @@ export class Runnable extends AsyncEventEmitter {
         }
     }
 }
+const RUNNABLE_TOKEN = Symbol.for(Runnable.name);
+Runnable.prototype[RUNNABLE_TOKEN] = true;

package/constants.js

@@ -1,4 +1,4 @@
-export const version = '0.5.8';
+export const version = '0.5.10';
 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/decorators/use-variables.decorator.js

@@ -8,11 +8,10 @@ export function UseVariables(variablesClass) {
             throw new TypeError('Property key must be "values"');
         variablesClass =
             variablesClass || Reflect.getMetadata('design:type', target, propertyKey);
-        if (!(typeof variablesClass === 'function' &&
-            Reflect.hasMetadata(VARIABLE_CONTAINER, variablesClass.prototype))) {
-            throw new TypeError('Variables class must be decorated with @DefineVariable');
+        if (!(typeof variablesClass === 'function')) {
+            throw new TypeError('type of "variables" must be a class');
         }
-        const metadata = Reflect.getMetadata(VARIABLE_CONTAINER, variablesClass.prototype);
+        const metadata = Reflect.getMetadata(VARIABLE_CONTAINER, variablesClass.prototype) || {};
         defineMergeMetadata(target.constructor, OWN_ELEMENT_METADATA, {
             variables: metadata,
         });

package/interfaces/logger.interface.d.ts

@@ -8,7 +8,7 @@ export interface ILogger {
     debug: LeveledLogMethod;
     level: string;
     child(options: Object): ILogger;
-    close(): void;
+    close(): void | Promise<void>;
 }
 export interface LeveledLogMethod {
     (message: string, ...meta: any[]): ILogger;

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@syncbridge/common",
-  "version": "0.5.8",
+  "version": "0.5.10",
   "description": "SyncBridge Common utilities",
   "author": "Panates Inc",
   "license": "MIT",
   "dependencies": {
-    "@jsopen/objects": "^2.0.2",
+    "@jsopen/objects": "^2.1.1",
     "node-events-async": "^1.5.0",
     "reflect-metadata": "^0.2.2",
-    "semver": "^7.7.3",
+    "semver": "^7.7.4",
     "ts-gems": "^3.11.3",
     "valgen": "^5.19.4"
   },

package/processor-factory.d.ts

@@ -1,4 +1,5 @@
 import { ProcessorBase } from './classes/processor-base.js';
+import { StackExecutor } from './classes/stack-executor.js';
 import { ILogger } from './interfaces/index.js';
 import { Profile } from './models/index.js';
 export declare namespace ProcessorFactory {
@@ -8,6 +9,9 @@ export declare namespace ProcessorFactory {
         logger: ILogger;
         dataDirectory?: string;
     }
-    function createProcessor<T extends ProcessorBase>(profile: Profile, options?: ProcessorOptions): Promise<T>;
-    function updateProcessor(processor: ProcessorBase, profile: Profile, options?: ProcessorOptions): Promise<void>;
+    function createProcessor<T extends ProcessorBase>(profile: Profile, options?: ProcessorOptions): Promise<{
+        processor: T;
+        issues: StackExecutor.Issue[];
+    }>;
+    function updateProcessor(processor: ProcessorBase, profile: Profile, options?: ProcessorOptions): Promise<StackExecutor.Issue[]>;
 }

package/processor-factory.js

@@ -16,8 +16,11 @@ export var ProcessorFactory;
             values: profile.values || {},
             dataDirectory: options?.dataDirectory,
         });
-        await _configureProcessor(processor, profile);
-        return processor;
+        const issues = await _configureProcessor(processor, profile);
+        return {
+            processor: processor,
+            issues,
+        };
     }
     ProcessorFactory.createProcessor = createProcessor;
     async function updateProcessor(processor, profile, options) {
@@ -88,5 +91,6 @@ export var ProcessorFactory;
         await configureComponents(processor, '', processorMetadata, profile, processor[ProcessorFactory.METADATA_KEY], processor[ProcessorFactory.PROFILE_KEY]);
         processor[ProcessorFactory.METADATA_KEY] = processorMetadata;
         processor[ProcessorFactory.PROFILE_KEY] = profile;
+        return stackExecutor.issues;
     }
 })(ProcessorFactory || (ProcessorFactory = {}));

package/registry/extension-package.d.ts

@@ -12,8 +12,8 @@ export declare class ExtensionPackage {
     version: string;
     description: string;
     entryPoint: string;
-    components: ExtensionPackageComponent[];
-    processors: ExtensionPackageProcessor[];
+    components: ComponentExtension[];
+    processors: ProcessorExtension[];
     errors: Error[];
     sortVersions(): void;
     /**
@@ -27,7 +27,7 @@ export declare class ExtensionPackage {
 /**
  *
  */
-export declare class ExtensionPackageComponent {
+export declare class ComponentExtension {
     readonly pkg: ExtensionPackage;
     readonly exportName: string;
     readonly metadata: ComponentMetadata;
@@ -41,7 +41,7 @@ export declare class ExtensionPackageComponent {
 /**
  *
  */
-export declare class ExtensionPackageProcessor {
+export declare class ProcessorExtension {
     readonly pkg: ExtensionPackage;
     readonly exportName: string;
     readonly metadata: ProcessorMetadata;

package/registry/extension-package.js

@@ -3,34 +3,10 @@ import fs from 'node:fs';
 import path from 'node:path';
 import process from 'node:process';
 import { fileURLToPath, pathToFileURL } from 'node:url';
-import { ComponentBase } from '../classes/component-base.js';
-import { ProcessorBase } from '../classes/processor-base.js';
+import { updateErrorMessage } from '@jsopen/objects';
 import { COMPONENT_OPTIONS, PROCESSOR_OPTIONS } from '../constants.js';
-import { ComponentMetadata, ProcessorMetadata } from '../models/index.js';
-import { initializeModelsDocument } from '../models-document.js';
-import { resolvePromisesDeep } from '../utils/resolve-promises.js';
-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;
-}
+import { isComponentBase, isProcessorBase } from '../utils/type-guartds.js';
+import { normalizeComponentMetadata, normalizeProcessorMetadata, } from './helpers.js';
 /**
  *
  */
@@ -48,7 +24,6 @@ export class ExtensionPackage {
      * @static
      */
     static async fromDirectory(directory) {
-        const compMetadataTypeDecoder = await getCompMetadataTypeDecoder();
         let filename = path.join(directory, 'package.json');
         if (!fs.existsSync(filename))
             throw new TypeError(`Directory "${directory}" does not contain package.json`);
@@ -76,16 +51,17 @@ export class ExtensionPackage {
                     continue;
                 }
                 try {
-                    metadata = compMetadataTypeDecoder(metadata);
+                    metadata = await normalizeComponentMetadata(metadata);
                 }
                 catch (e) {
-                    out.errors.push(new Error(`Component (${ctorName}) metadata validation error. ` + e.message));
+                    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 ExtensionPackageComponent(out, ctorName, metadata));
+                out.components.push(new ComponentExtension(out, ctorName, metadata));
             }
         }
         if (pkgJson.syncbridge.processors) {
@@ -103,24 +79,23 @@ export class ExtensionPackage {
                     continue;
                 }
                 try {
-                    metadata = compMetadataTypeDecoder(metadata);
+                    metadata = await normalizeProcessorMetadata(metadata);
                 }
                 catch (e) {
-                    out.errors.push(new Error(`Processor (${ctorName}) metadata validation error. ` + e.message));
+                    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 ExtensionPackageProcessor(out, ctorName, metadata));
+                out.processors.push(new ProcessorExtension(out, ctorName, metadata));
             }
         }
         out.sortVersions();
         return out;
     }
     static async fromNodePackage(specifier, resolver) {
-        const compMetadataTypeDecoder = await getCompMetadataTypeDecoder();
-        const procMetadataTypeDecoder = await getProcMetadataTypeDecoder();
         // const resolver = createRequire(parentPath || import.meta.url).resolve;
         let entryPoint = (resolver || import.meta.resolve)(specifier);
         const pkgJson = locatePkgJson(path.dirname(entryPoint));
@@ -141,33 +116,33 @@ export class ExtensionPackage {
                 continue;
             let metadata = Reflect.getMetadata(COMPONENT_OPTIONS, v);
             if (metadata) {
-                metadata = await resolvePromisesDeep(metadata);
                 try {
-                    metadata = compMetadataTypeDecoder(metadata);
+                    metadata = await normalizeComponentMetadata(metadata);
                 }
                 catch (e) {
-                    out.errors.push(new Error(`Component (${ctorName}) metadata validation error. ` + e.message));
+                    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 ExtensionPackageComponent(out, ctorName, metadata));
+                out.components.push(new ComponentExtension(out, ctorName, metadata));
             }
             metadata = Reflect.getMetadata(PROCESSOR_OPTIONS, v);
             if (metadata) {
-                metadata = await resolvePromisesDeep(metadata);
                 try {
-                    metadata = procMetadataTypeDecoder(metadata);
+                    metadata = await normalizeProcessorMetadata(metadata);
                 }
                 catch (e) {
-                    out.errors.push(new Error(`Processor (${ctorName}) metadata validation error. ` + e.message));
+                    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 ExtensionPackageProcessor(out, ctorName, metadata));
+                out.processors.push(new ProcessorExtension(out, ctorName, metadata));
             }
         }
         out.sortVersions();
@@ -177,7 +152,7 @@ export class ExtensionPackage {
 /**
  *
  */
-export class ExtensionPackageComponent {
+export class ComponentExtension {
     pkg;
     exportName;
     metadata;
@@ -206,7 +181,7 @@ export class ExtensionPackageComponent {
             throw new TypeError(`Exported component "${this.exportName}" not found in package "${this.pkg.name}"`);
         if (typeof ctor !== 'function')
             throw new TypeError(`Exported component "${this.exportName}" is not a class`);
-        if (!(ctor.prototype instanceof ComponentBase))
+        if (!isComponentBase(ctor.prototype))
             throw new TypeError(`Exported component "${this.exportName}" does not extends ComponentBase`);
         this._ctor = ctor;
         return this._ctor;
@@ -215,7 +190,7 @@ export class ExtensionPackageComponent {
 /**
  *
  */
-export class ExtensionPackageProcessor {
+export class ProcessorExtension {
     pkg;
     exportName;
     metadata;
@@ -244,7 +219,7 @@ export class ExtensionPackageProcessor {
             throw new TypeError(`Exported processor "${this.exportName}" not found in package "${this.pkg.name}"`);
         if (typeof ctor !== 'function')
             throw new TypeError(`Exported processor "${this.exportName}" is not a class`);
-        if (!(ctor.prototype instanceof ProcessorBase))
+        if (!isProcessorBase(ctor.prototype))
             throw new TypeError(`Exported processor "${this.exportName}" does not extends ProcessorBase`);
         this._ctor = ctor;
         return this._ctor;

package/registry/extension-registry.d.ts

@@ -1,27 +1,27 @@
 import { URL } from 'node:url';
 import { Type } from 'ts-gems';
-import { ExtensionPackage, ExtensionPackageComponent, ExtensionPackageProcessor } from './extension-package.js';
+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, ExtensionPackageComponent[]>;
-    const processors: Map<string, ExtensionPackageProcessor[]>;
+    const components: Map<string, ComponentExtension[]>;
+    const processors: Map<string, ProcessorExtension[]>;
     /**
      *
      */
-    function findComponent(className: string, version?: string): ExtensionPackageComponent | undefined;
+    function findComponent(className: string, version?: string): ComponentExtension | undefined;
     /**
      *
      */
-    function getComponent(className: string, version?: string): ExtensionPackageComponent;
+    function getComponent(className: string, version?: string): ComponentExtension;
     /**
      *
      */
-    function findProcessor(className: string, version?: string): ExtensionPackageProcessor | undefined;
+    function findProcessor(className: string, version?: string): ProcessorExtension | undefined;
     /**
      *
      */
-    function getProcessor(className: string, version?: string): ExtensionPackageProcessor;
+    function getProcessor(className: string, version?: string): ProcessorExtension;
     /**
      *
      */
@@ -34,6 +34,6 @@ export declare namespace ExtensionRegistry {
      *
      */
     function registerNodePackage(specifier: string): Promise<ExtensionPackage>;
-    function registerComponent(ctor: Type): Promise<ExtensionPackageComponent | undefined>;
-    function registerProcessor(ctor: Type): Promise<ExtensionPackageProcessor | undefined>;
+    function registerComponent(ctor: Type): Promise<ComponentExtension | undefined>;
+    function registerProcessor(ctor: Type): Promise<ProcessorExtension | undefined>;
 }

package/registry/extension-registry.js

@@ -1,8 +1,7 @@
-import { deepClone } from '@jsopen/objects';
 import semver from 'semver';
 import { COMPONENT_OPTIONS, PROCESSOR_OPTIONS } from '../constants.js';
-import { resolvePromisesDeep } from '../utils/resolve-promises.js';
-import { ExtensionPackage, ExtensionPackageComponent, ExtensionPackageProcessor, } from './extension-package.js';
+import { ComponentExtension, ExtensionPackage, ProcessorExtension, } from './extension-package.js';
+import { normalizeComponentMetadata, normalizeProcessorMetadata, } from './helpers.js';
 export var ExtensionRegistry;
 (function (ExtensionRegistry) {
     let _resolver;
@@ -79,38 +78,7 @@ export var ExtensionRegistry;
             throw new TypeError(`Class "${ctor.name}" has no component metadata.`);
         if (_metadata.abstract)
             return;
-        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;
-                }
-            }
-        }
+        const metadata = await normalizeComponentMetadata(_metadata);
         let versions = ExtensionRegistry.packages.get('internal');
         if (!versions) {
             versions = [];
@@ -123,7 +91,7 @@ export var ExtensionRegistry;
             pkg.version = '0.0.0';
             pkg.description = 'Internal extensions';
         }
-        const cmp = new ExtensionPackageComponent(pkg, ctor.name, metadata, ctor);
+        const cmp = new ComponentExtension(pkg, ctor.name, metadata, ctor);
         pkg.components.push(cmp);
         storePackage(pkg);
         return cmp;
@@ -135,37 +103,7 @@ export var ExtensionRegistry;
             throw new TypeError(`Class "${ctor.name}" has no processor metadata.`);
         if (_metadata.abstract)
             return;
-        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;
-                }
-            }
-        }
+        const metadata = await normalizeProcessorMetadata(_metadata);
         let versions = ExtensionRegistry.packages.get('internal');
         if (!versions) {
             versions = [];
@@ -178,7 +116,7 @@ export var ExtensionRegistry;
             pkg.version = '0.0.0';
             pkg.description = 'Internal extensions';
         }
-        const prc = new ExtensionPackageProcessor(pkg, ctor.name, metadata, ctor);
+        const prc = new ProcessorExtension(pkg, ctor.name, metadata, ctor);
         pkg.processors.push(prc);
         storePackage(pkg);
         return prc;

package/registry/helpers.d.ts

@@ -0,0 +1,3 @@
+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/helpers.js

@@ -0,0 +1,102 @@
+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({
+        className: out.className,
+        displayName: out.displayName,
+        description: out.description,
+        iconUrl: out.iconUrl,
+        author: out.author,
+        tags: out.tags,
+        abstract: out.abstract,
+        variables: out.variables,
+        components: out.components,
+        ...out,
+    });
+    if (out.variables) {
+        /** Convert object enumValues to arrays */
+        for (const v of Object.values(out.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;
+            }
+        }
+    }
+    out = decoder(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({
+        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: out.variables,
+        components: out.components,
+        ...out,
+    });
+    if (out.variables) {
+        /** Convert object enumValues to arrays */
+        for (const v of Object.values(out.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;
+            }
+        }
+    }
+    out = decoder(out);
+    merge(out, metadata, { keepExisting: true, deep: 'full' });
+    return out;
+}
+// ************************************************************************
+// ************************************************************************
+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/utils/type-guartds.d.ts

@@ -0,0 +1,6 @@
+import { ComponentBase } from '../classes/component-base.js';
+import { ProcessorBase } from '../classes/processor-base.js';
+import { Runnable } from '../classes/runnable.js';
+export declare function isRunnable(proto: any): proto is Runnable;
+export declare function isProcessorBase(proto: any): proto is ProcessorBase;
+export declare function isComponentBase(proto: any): proto is ComponentBase;

package/utils/type-guartds.js

@@ -0,0 +1,15 @@
+import { ComponentBase } from '../classes/component-base.js';
+import { ProcessorBase } from '../classes/processor-base.js';
+import { Runnable } from '../classes/runnable.js';
+const RUNNABLE_TOKEN = Symbol.for(Runnable.name);
+const PROCESSOR_BASE_TOKEN = Symbol.for(ProcessorBase.name);
+const COMPONENT_BASE_TOKEN = Symbol.for(ComponentBase.name);
+export function isRunnable(proto) {
+    return !!proto[RUNNABLE_TOKEN];
+}
+export function isProcessorBase(proto) {
+    return !!proto[PROCESSOR_BASE_TOKEN];
+}
+export function isComponentBase(proto) {
+    return !!proto[COMPONENT_BASE_TOKEN];
+}