@syncbridge/common 0.5.10 → 0.5.11

package/constants.js

@@ -1,4 +1,4 @@
-export const version = '0.5.10';
+export const version = '0.5.11';
 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/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.11",
   "description": "SyncBridge Common utilities",
   "author": "Panates Inc",
   "license": "MIT",

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;
+}