@syncbridge/common 0.5.10 → 0.5.12

package/classes/base-element.d.ts

@@ -28,6 +28,7 @@ export declare namespace BaseElement {
             status: ServiceStatus,
             statusMessage: string
         ];
+        'values-updated': [string[]];
     }
     interface InitArgs extends Runnable.InitArgs {
         logger?: ILogger;

package/classes/base-element.js

@@ -48,7 +48,9 @@ export class BaseElement extends Runnable {
         await Promise.all(Object.values(this.components).map(component => component.init()));
     }
     async _start(abortSignal) {
-        await Promise.all(Object.values(this.components).map(component => component.start(abortSignal)));
+        if (this.status === ServiceStatus.starting ||
+            this.status === ServiceStatus.started)
+            await Promise.all(Object.values(this.components).map(component => component.start(abortSignal)));
     }
     async _stop() {
         await Promise.all(Object.values(this.components)

package/constants.js

@@ -1,4 +1,4 @@
-export const version = '0.5.10';
+export const version = '0.5.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/decorators/define-variable.decorator.d.ts

@@ -9,6 +9,7 @@ export declare namespace DefineVariable {
         variables?: TVariable | Promise<TVariable>;
         enumValues?: TEnumValue | Promise<TEnumValue>;
         choice?: string[] | Promise<string[]>;
+        index?: number;
     }
 }
 export {};

package/decorators/define-variable.decorator.js

@@ -10,47 +10,49 @@ export function DefineVariable(options) {
         const designType = Reflect.getMetadata('design:type', target, propertyKey);
         if (designType === Array)
             options.isArray = true;
+        const base = Object.getPrototypeOf(target);
+        const baseMetadata = Reflect.hasMetadata(VARIABLE_CONTAINER, base)
+            ? deepClone(Reflect.getMetadata(VARIABLE_CONTAINER, base))
+            : {};
+        let metadata = merge(options, baseMetadata[propertyKey] || {}, {
+            deep: 'full',
+            ignoreNulls: false,
+            ignoreUndefined: false,
+            keepExisting: true,
+        });
         if (typeof options.variables === 'function') {
-            options.type = VariableType.Nested;
-            options.variables = Reflect.getMetadata(VARIABLE_CONTAINER, options.variables.prototype);
+            metadata.type = VariableType.Nested;
+            metadata.variables = Reflect.getMetadata(VARIABLE_CONTAINER, options.variables.prototype);
         }
-        if (options.enumValues && !options.type) {
-            options.type = VariableType.Enum;
+        if (metadata.enumValues && !metadata.type) {
+            metadata.type = VariableType.Enum;
         }
-        if (options.type !== VariableType.Enum)
-            delete options.enumValues;
-        if (!options.type) {
+        if (metadata.type !== VariableType.Enum)
+            delete metadata.enumValues;
+        if (!metadata.type) {
             if (designType === String)
-                options.type = VariableType.String;
+                metadata.type = VariableType.String;
             else if (designType === Boolean)
-                options.type = VariableType.Boolean;
+                metadata.type = VariableType.Boolean;
             else if (designType === Number)
-                options.type = VariableType.Number;
+                metadata.type = VariableType.Number;
             else if (typeof designType === 'function' &&
                 Reflect.hasMetadata(VARIABLE_CONTAINER, designType.prototype)) {
-                options.type = VariableType.Nested;
-                options.variables = Reflect.getMetadata(VARIABLE_CONTAINER, designType.prototype);
+                metadata.type = VariableType.Nested;
+                metadata.variables = Reflect.getMetadata(VARIABLE_CONTAINER, designType.prototype);
             }
         }
-        if (options.isArray && !options.type)
+        if (metadata.isArray && !metadata.type)
             throw new TypeError('Array variables must have type defined. ' +
                 (target.constructor.name +
                     '.' +
                     propertyKey +
                     ' is an array variable'));
-        const base = Object.getPrototypeOf(target);
-        const baseMetadata = Reflect.hasMetadata(VARIABLE_CONTAINER, base)
-            ? deepClone(Reflect.getMetadata(VARIABLE_CONTAINER, base))
-            : {};
-        let metadata = merge(baseMetadata, options, {
-            deep: 'full',
-            ignoreNulls: false,
-            ignoreUndefined: false,
-        });
         metadata = omitUndefined(metadata, 'full');
         const metadataRecord = Reflect.hasOwnMetadata(VARIABLE_CONTAINER, target)
             ? Reflect.getMetadata(VARIABLE_CONTAINER, target)
             : {};
+        merge(metadataRecord, baseMetadata);
         metadataRecord[propertyKey] = metadata;
         Reflect.defineMetadata(VARIABLE_CONTAINER, metadataRecord, target);
     };

package/models/enums/log-level.d.ts

@@ -5,6 +5,7 @@ export declare enum LogLevel {
     error = "error",
     warn = "warn",
     info = "info",
+    verbose = "verbose",
     trace = "trace",
     debug = "debug"
 }

package/models/enums/log-level.js

@@ -7,6 +7,7 @@ export var LogLevel;
     LogLevel["error"] = "error";
     LogLevel["warn"] = "warn";
     LogLevel["info"] = "info";
+    LogLevel["verbose"] = "verbose";
     LogLevel["trace"] = "trace";
     LogLevel["debug"] = "debug";
 })(LogLevel || (LogLevel = {}));

package/models/metadata/variable-metadata.d.ts

@@ -11,6 +11,7 @@ export declare class VariableMetadataRecord {
  */
 export declare class VariableMetadata {
     ignored?: boolean;
+    index?: number;
     hotPlug?: boolean;
     label?: string;
     description?: string;

package/models/metadata/variable-metadata.js

@@ -21,6 +21,12 @@ let VariableMetadata = class VariableMetadata {
     ignored;
     hotPlug;
 };
+__decorate([
+    ApiField({
+        description: 'Index of the variable. Variables with higher index will be displayed first',
+    }),
+    __metadata("design:type", Number)
+], VariableMetadata.prototype, "index", void 0);
 __decorate([
     ApiField({
         description: 'Determine if the variable can be changed while worker running',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syncbridge/common",
-  "version": "0.5.10",
+  "version": "0.5.12",
   "description": "SyncBridge Common utilities",
   "author": "Panates Inc",
   "license": "MIT",

package/processor-factory.d.ts

@@ -6,12 +6,14 @@ export declare namespace ProcessorFactory {
     const METADATA_KEY: unique symbol;
     const PROFILE_KEY: unique symbol;
     interface ProcessorOptions {
-        logger: ILogger;
+        logger?: ILogger;
         dataDirectory?: string;
     }
     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[]>;
+    function updateProcessor(processor: ProcessorBase, profile: Profile, options?: ProcessorOptions): Promise<{
+        issues: StackExecutor.Issue[];
+    }>;
 }

package/processor-factory.js

@@ -16,10 +16,17 @@ export var ProcessorFactory;
             values: profile.values || {},
             dataDirectory: options?.dataDirectory,
         });
-        const issues = await _configureProcessor(processor, profile);
+        const ctx = {
+            stackExecutor: new StackExecutor(),
+            processor,
+            profile,
+            options,
+            valueUpdates: new Map(),
+        };
+        await _configureProcessor(ctx);
         return {
             processor: processor,
-            issues,
+            issues: ctx.stackExecutor.issues,
         };
     }
     ProcessorFactory.createProcessor = createProcessor;
@@ -28,69 +35,160 @@ export var ProcessorFactory;
             processor.logger = options.logger;
         if (options?.dataDirectory)
             processor.dataDirectory = options.dataDirectory;
-        return _configureProcessor(processor, profile);
+        const ctx = {
+            stackExecutor: new StackExecutor(),
+            processor,
+            profile,
+            options,
+            valueUpdates: new Map(),
+        };
+        await _configureProcessor(ctx);
+        const signalUpdates = async (obj) => {
+            if (obj.components) {
+                for (const component of Object.values(obj.components)) {
+                    await signalUpdates(component);
+                }
+            }
+            if (ctx.valueUpdates.has(obj)) {
+                await obj.emitAsyncSafe('values-updated', ctx.valueUpdates.get(obj));
+            }
+        };
+        signalUpdates(processor);
+        return {
+            issues: ctx.stackExecutor.issues,
+        };
     }
     ProcessorFactory.updateProcessor = updateProcessor;
-    async function _configureProcessor(processor, profile) {
-        const processorMetadata = materializeMetadata(profile);
-        const stackExecutor = new StackExecutor();
-        async function configureComponents(owner, curPath, newMetadata, newProfile, oldMetadata, oldProfile) {
-            if (!newMetadata.components)
-                return;
-            // Stack: components
-            await stackExecutor.executeAsync('components', async () => {
-                for (const [key, childMetadata] of Object.entries(newMetadata.components)) {
-                    // Stack: components/componentName
-                    await stackExecutor.executeAsync(key, async () => {
-                        const oldChildMetadata = oldMetadata?.components?.[key];
-                        const oldChildProfile = oldProfile?.components?.[key];
-                        const childProfile = newProfile.components[key];
-                        const componentPath = curPath ? curPath + '/' + key : key;
-                        let componentInstance = owner.components?.[key];
-                        /** Create component only if processor is stopped */
-                        if (processor.stopped) {
-                            const compReg = ExtensionRegistry.getComponent(childMetadata.className);
-                            /** Create the component instance */
-                            const compClass = await compReg.getClass();
-                            componentInstance = new compClass({
-                                processor: processor,
-                                parent: owner,
-                                name: key,
-                                path: componentPath,
-                                values: childProfile.values || {},
-                            });
-                            owner.components = owner.components || {};
-                            owner.components[key] = componentInstance;
-                            if (childMetadata.propertyKey)
-                                owner[childMetadata.propertyKey] = componentInstance;
-                        }
-                        else if (oldMetadata?.className &&
-                            oldMetadata?.className !== newMetadata.className) {
-                            throw new Error('Can not change component class while processor running. You should stop it first.');
-                        }
-                        else {
-                            // todo update only hot-plug values
-                            componentInstance.values = childProfile.values || {};
-                        }
-                        /** Create the child logger */
-                        componentInstance.logger = owner.logger?.child({
-                            component: componentPath,
+    async function _configureProcessor(ctx) {
+        const { processor, profile } = ctx;
+        const cmpCtx = {
+            ...ctx,
+            owner: processor,
+            curPath: '',
+            newMetadata: materializeMetadata(profile),
+            newProfile: profile,
+            oldMetadata: processor[ProcessorFactory.METADATA_KEY],
+            oldProfile: processor[ProcessorFactory.PROFILE_KEY],
+        };
+        _validateComponents(cmpCtx);
+        await _configureComponents(cmpCtx);
+        processor[ProcessorFactory.METADATA_KEY] = cmpCtx.newMetadata;
+        processor[ProcessorFactory.PROFILE_KEY] = profile;
+    }
+    function _validateComponents(ctx) {
+        const { newMetadata, newProfile, oldMetadata, oldProfile, curPath, owner, stackExecutor, processor, } = ctx;
+        if (!newMetadata.components)
+            return;
+        // Stack: components
+        stackExecutor.execute('components', () => {
+            for (const [key, childMetadata] of Object.entries(newMetadata.components)) {
+                // Stack: components/componentName
+                stackExecutor.execute(key, () => {
+                    const oldChildMetadata = oldMetadata?.components?.[key];
+                    const oldChildProfile = oldProfile?.components?.[key];
+                    const childProfile = newProfile.components[key];
+                    const componentPath = curPath ? curPath + '/' + key : key;
+                    const componentInstance = owner.components?.[key];
+                    if (processor.stopped &&
+                        oldMetadata?.className &&
+                        oldMetadata?.className !== newMetadata.className)
+                        throw new Error('Can not change component class while processor running. You should stop it first.');
+                    ExtensionRegistry.getComponent(childMetadata.className);
+                    /** Validate sub components */
+                    if (childMetadata.components) {
+                        _validateComponents({
+                            ...ctx,
+                            owner: componentInstance,
+                            curPath: componentPath,
+                            newMetadata: childMetadata,
+                            newProfile: childProfile,
+                            oldMetadata: oldChildMetadata,
+                            oldProfile: oldChildProfile,
                         });
-                        if (childProfile.settings?.logs?.level) {
-                            componentInstance.logger.level =
-                                childProfile.settings?.logs?.level;
-                        }
-                        /** Initialize sub components */
-                        if (childMetadata.components) {
-                            configureComponents(componentInstance, componentPath, childMetadata, childProfile, oldChildMetadata, oldChildProfile);
-                        }
-                    });
+                    }
+                });
+            }
+        });
+    }
+    async function _configureComponents(ctx) {
+        const { newMetadata, stackExecutor } = ctx;
+        if (!newMetadata.components)
+            return;
+        // Stack: components
+        await stackExecutor.executeAsync('components', async () => {
+            for (const [key, childMetadata] of Object.entries(newMetadata.components)) {
+                // Stack: components/componentName
+                await stackExecutor.executeAsync(key, async () => {
+                    await _configureComponent(ctx, key, childMetadata);
+                });
+            }
+        });
+    }
+    async function _configureComponent(ctx, key, childMetadata) {
+        const { newMetadata, newProfile, oldMetadata, oldProfile, curPath, owner, processor, } = ctx;
+        const oldChildMetadata = oldMetadata?.components?.[key];
+        const oldChildProfile = oldProfile?.components?.[key];
+        const childProfile = newProfile.components[key];
+        const componentPath = curPath ? curPath + '/' + key : key;
+        let componentInstance = owner.components?.[key];
+        /** Create the component only if the processor stopped */
+        if (processor.stopped) {
+            const compReg = ExtensionRegistry.getComponent(childMetadata.className);
+            /** Create the component instance */
+            const compClass = await compReg.getClass();
+            componentInstance = new compClass({
+                processor: processor,
+                parent: owner,
+                name: key,
+                path: componentPath,
+                values: childProfile.values || {},
+            });
+            owner.components = owner.components || {};
+            owner.components[key] = componentInstance;
+            if (childMetadata.propertyKey)
+                owner[childMetadata.propertyKey] = componentInstance;
+        }
+        else {
+            componentInstance.values = {};
+            const patchValues = (target, valPath, newValues, newVariables, oldVariables, oldValues) => {
+                Object.assign(target, newValues);
+                const updatedValues = [];
+                for (const [varKey, varMeta] of Object.entries(newMetadata)) {
+                    const keyPath = valPath ? valPath + '.' + varKey : varKey;
+                    /** Update only hotplug variables */
+                    if (varMeta?.hotPlug !== true)
+                        continue;
+                    if (varMeta.type === 'nested') {
+                        target[varKey] = {};
+                        patchValues(target[varKey], keyPath, newValues[varKey], newVariables[varKey]?.variables || {}, oldVariables?.[varKey]?.variables, oldValues?.[varKey]);
+                        continue;
+                    }
+                    updatedValues.push(keyPath);
+                    target[varKey] = newValues[varKey];
                 }
+                if (updatedValues.length)
+                    ctx.valueUpdates.set(componentInstance, updatedValues);
+            };
+            patchValues(componentInstance.values, '', childProfile.values || {}, childMetadata.variables || {}, oldChildMetadata?.variables, oldProfile?.values);
+        }
+        /** Create the child logger */
+        componentInstance.logger = owner.logger?.child({
+            component: componentPath,
+        });
+        if (childProfile.settings?.logs?.level) {
+            componentInstance.logger.level = childProfile.settings?.logs?.level;
+        }
+        /** Initialize sub components */
+        if (childMetadata.components) {
+            await _configureComponents({
+                ...ctx,
+                owner: componentInstance,
+                curPath: componentPath,
+                newMetadata: childMetadata,
+                newProfile: childProfile,
+                oldMetadata: oldChildMetadata,
+                oldProfile: oldChildProfile,
             });
         }
-        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/helpers.js

@@ -1,11 +1,12 @@
 import { deepClone, merge } from '@jsopen/objects';
-import { ComponentMetadata, ProcessorMetadata } from '../models/index.js';
+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 = deepClone(out);
+    out = decoder({
         className: out.className,
         displayName: out.displayName,
         description: out.description,
@@ -13,35 +14,18 @@ export async function normalizeProcessorMetadata(metadata) {
         author: out.author,
         tags: out.tags,
         abstract: out.abstract,
-        variables: out.variables,
-        components: out.components,
+        variables: normalizeVariables(out.variables),
+        components: normalizeComponents(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({
+    out = deepClone(out);
+    out = decoder({
         className: out.className,
         displayName: out.displayName,
         description: out.description,
@@ -50,32 +34,44 @@ export async function normalizeComponentMetadata(metadata) {
         interfaces: out.interfaces,
         tags: out.tags,
         abstract: out.abstract,
-        variables: out.variables,
-        components: out.components,
+        variables: normalizeVariables(out.variables),
+        components: normalizeComponents(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;
 }
+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;

package/utils/metadata-utils.d.ts

@@ -1,6 +1,12 @@
 import { StackExecutor } from '../classes/stack-executor.js';
 import { ProcessorMetadata, Profile } from '../models/index.js';
+/**
+ * Materializes metadata from profile.
+ */
 export declare function materializeMetadata(profile: Profile): ProcessorMetadata;
+/**
+ *
+ */
 export declare function materializeMetadataSilent(profile: Profile): {
     metadata: ProcessorMetadata;
     issues?: StackExecutor.Issue[];

package/utils/metadata-utils.js

@@ -1,7 +1,11 @@
 import { clone, merge, omitUndefined } from '@jsopen/objects';
 import { SbError } from '../classes/sb-error.js';
 import { StackExecutor } from '../classes/stack-executor.js';
+import { VariableType, } from '../models/index.js';
 import { ExtensionRegistry } from '../registry/extension-registry.js';
+/**
+ * Materializes metadata from profile.
+ */
 export function materializeMetadata(profile) {
     const { metadata, issues } = materializeMetadataSilent(profile);
     if (issues?.length) {
@@ -16,6 +20,9 @@ export function materializeMetadata(profile) {
     }
     return metadata;
 }
+/**
+ *
+ */
 export function materializeMetadataSilent(profile) {
     const stackExecutor = new StackExecutor();
     const processorRec = ExtensionRegistry.getProcessor(profile.processorClass);
@@ -69,6 +76,7 @@ function _materializeComponents(stackExecutor, metadata, profile) {
             const reg = ExtensionRegistry.getComponent(profileComponent.className);
             materializedComponent.className = profileComponent.className;
             materializedComponent.variables = merge({}, [reg.metadata.variables || {}, metadataComponent.variables || {}], { deep: 'full' });
+            materializedComponent.variables = sortVariables(materializedComponent.variables);
             if (metadataComponent.className) {
                 if (materializedComponent.className &&
                     materializedComponent.className !== metadataComponent.className)
@@ -97,3 +105,29 @@ function _materializeComponents(stackExecutor, metadata, profile) {
     }
     return out;
 }
+function sortVariables(variables) {
+    if (!variables)
+        return;
+    const keys = Object.keys(variables);
+    const sorted = [...keys]
+        .sort((a, b) => {
+        const va = variables[a];
+        const vb = variables[b];
+        const indexA = va.index ?? Number.MAX_SAFE_INTEGER;
+        const indexB = vb.index ?? Number.MAX_SAFE_INTEGER;
+        if (indexA > indexB)
+            return 1;
+        if (indexA < indexB)
+            return -1;
+        if (va.type === VariableType.Nested && vb.type !== VariableType.Nested)
+            return 1;
+        if (vb.type === VariableType.Nested && va.type !== VariableType.Nested)
+            return -1;
+        return keys.indexOf(a) > keys.indexOf(b) ? 1 : -1;
+    })
+        .reduce((a, k) => {
+        a[k] = variables[k];
+        return a;
+    }, {});
+    return sorted;
+}