@node-projects/web-component-designer-visualization-addons 0.1.57 → 0.1.59

package/dist/components/SimpleScriptEditor.js

@@ -104,7 +104,7 @@ export class SimpleScriptEditor extends BaseCustomWebComponentConstructorAppend
             if (!property.specialAllreadyAdded) {
                 //@ts-ignore
                 property.specialAllreadyAdded = true;
-                if (typeof currentValue === 'object' && currentValue !== null) {
+                if ((typeof currentValue === 'object' && currentValue !== null) || property.format === 'complex') {
                     let rB = document.createElement('button');
                     rB.style.height = 'calc(100% - 6px)';
                     rB.style.position = 'relative';
@@ -121,7 +121,8 @@ export class SimpleScriptEditor extends BaseCustomWebComponentConstructorAppend
                     let d = document.createElement('div');
                     d.style.display = 'flex';
                     let sp = document.createElement('span');
-                    sp.innerText = 'complex: ' + JSON.stringify(currentValue);
+                    if (currentValue)
+                        sp.innerText = 'complex: ' + JSON.stringify(currentValue);
                     sp.style.overflow = 'hidden';
                     sp.style.whiteSpace = 'nowrap';
                     sp.style.textOverflow = 'ellipsis';

package/dist/interfaces/VisualizationHandler.d.ts

@@ -19,6 +19,8 @@ export interface VisualizationHandler {
     unsubscribeState(id: string, cb: StateChangeHandler, info: any): void;
     getHistoricData(id: string, config: any): any;
     getObject(id: string): Promise<Signal>;
+    writeSignalsInGroup?(group: string): Promise<void>;
+    clearSignalsInGroup?(group: string): Promise<void>;
     getAllNames(type: string): any;
     getSignalInformation(signal: Signal): SignalInformation;
 }

package/dist/scripting/ScriptCommands.d.ts

@@ -1,4 +1,8 @@
-export declare type ScriptCommands = OpenScreen | OpenUrl | OpenDialog | CloseDialog | ToggleSignalValue | SetSignalValue | IncrementSignalValue | DecrementSignalValue | SetBitInSignal | ClearBitInSignal | ToggleBitInSignal | Console | CalculateSignalValue | Javascript | SetElementProperty | Delay | SwitchLanguage | Login | Logout;
+export declare type ScriptCommands = Comment | OpenScreen | OpenUrl | OpenDialog | CloseDialog | ToggleSignalValue | SetSignalValue | IncrementSignalValue | DecrementSignalValue | SetBitInSignal | ClearBitInSignal | ToggleBitInSignal | Console | CalculateSignalValue | Javascript | SetElementProperty | Delay | SwitchLanguage | Login | Logout | SubscribeSignal | UnsubscribeSignal | WriteSignalsInGroup | ClearSiganlsInGroup | Condition | Exit | Label | RunScript | Goto;
+export interface Comment {
+    type: 'Comment';
+    comment: string;
+}
 export interface OpenScreen {
     type: 'OpenScreen';
     /**
@@ -190,3 +194,75 @@ export interface Login {
      */
     password: string;
 }
+export interface SubscribeSignal {
+    type: 'SubscribeSignal';
+    /**
+     * Name of the signal
+     * @TJS-format signal
+     */
+    signal: string;
+    oneTime: boolean;
+}
+export interface UnsubscribeSignal {
+    type: 'UnsubscribeSignal';
+    /**
+     * Name of the signal
+     * @TJS-format signal
+     */
+    signal: string;
+}
+export interface WriteSignalsInGroup {
+    type: 'WriteSignalsInGroup';
+    /**
+    * Name of the Group
+    */
+    group: string;
+}
+export interface ClearSiganlsInGroup {
+    type: 'ClearSiganlsInGroup';
+    /**
+    * Name of the Group
+    */
+    group: string;
+}
+export interface Condition {
+    type: 'Condition';
+    /**
+    * Name of the value1
+    * @TJS-format complex
+    */
+    value1: any;
+    value2?: any;
+    comparisonType: '==null' | '!=null' | '==true' | '==false' | '==' | '!=' | '>' | '<' | '>=' | '<=';
+    /**
+    * Name of the label to jumpe to when condition is true
+    */
+    trueGotoLabel?: string;
+    trueScriptName?: string;
+    trueScriptType?: string;
+    falseGotoLabel?: string;
+    falseScriptName?: string;
+    falseScriptType?: string;
+}
+export interface Exit {
+    type: 'Exit';
+}
+export interface Label {
+    type: 'Label';
+    label: string;
+}
+export interface Goto {
+    type: 'Goto';
+    label: string;
+}
+export interface RunScript {
+    type: 'RunScript';
+    /**
+    * Name of the Script
+    */
+    name: 'string';
+    /**
+    * Type of the Script
+    */
+    scriptType: 'string';
+}

package/dist/scripting/ScriptSystem.d.ts

@@ -11,8 +11,10 @@ export type contextType = {
 };
 export declare class ScriptSystem {
     _visualizationHandler: VisualizationHandler;
+    _subscriptionCallback: () => void;
     constructor(visualizationHandler: VisualizationHandler);
     execute(scriptCommands: ScriptCommands[], outerContext: contextType): Promise<void>;
+    runExternalScript(name: string, type: string): Promise<void>;
     runScriptCommand<T extends ScriptCommands>(command: T, context: contextType): Promise<void>;
     getTargetFromTargetSelector(context: contextType, targetSelectorTarget: 'currentScreen' | 'parentScreen' | 'currentElement' | 'parentElement', targetSelector: string): Iterable<Element>;
     getValue<T>(value: string | number | boolean | IScriptMultiplexValue, outerContext: contextType): Promise<any>;

package/dist/scripting/ScriptSystem.js

@@ -4,16 +4,96 @@ import { parseBindingString } from "../helpers/BindingsHelper.js";
 import Long from 'long';
 export class ScriptSystem {
     _visualizationHandler;
+    _subscriptionCallback = () => { };
     constructor(visualizationHandler) {
         this._visualizationHandler = visualizationHandler;
     }
     async execute(scriptCommands, outerContext) {
-        for (let c of scriptCommands) {
-            this.runScriptCommand(c, outerContext);
+        for (let i = 0; i < scriptCommands.length; i++) {
+            let c = scriptCommands[i];
+            if (c.type == "Exit") {
+                break;
+            }
+            else if (c.type == "Goto") {
+                const label = await this.getValue(c.label, outerContext);
+                i = scriptCommands.findIndex(x => x.type == "Label" && x.label == label);
+                if (i < 0)
+                    break;
+            }
+            else if (c.type == "Condition") {
+                const value1 = await this.getValue(c.value1, outerContext);
+                const value2 = await this.getValue(c.value2, outerContext);
+                const comparisonType = await this.getValue(c.comparisonType, outerContext);
+                let res = false;
+                switch (comparisonType) {
+                    case '==null':
+                        res = value1 == null;
+                        break;
+                    case '!=null':
+                        res = value1 != null;
+                        break;
+                    case '==true':
+                        res = value1 == true;
+                        break;
+                    case '==false':
+                        res = value1 == false;
+                        break;
+                    case '==':
+                        res = value1 == value2;
+                        break;
+                    case '!=':
+                        res = value1 != value2;
+                        break;
+                    case '>':
+                        res = value1 > value2;
+                        break;
+                    case '<':
+                        res = value1 < value2;
+                        break;
+                    case '>=':
+                        res = value1 >= value2;
+                        break;
+                    case '<=':
+                        res = value1 <= value2;
+                        break;
+                }
+                if (res) {
+                    await this.runExternalScript(await this.getValue(c.trueScriptName, outerContext), await this.getValue(c.trueScriptType, outerContext));
+                    const trueGotoLabel = await this.getValue(c.trueGotoLabel, outerContext);
+                    if (trueGotoLabel) {
+                        i = scriptCommands.findIndex(x => x.type == "Label" && x.label == trueGotoLabel);
+                        if (i < 0)
+                            break;
+                    }
+                }
+                else {
+                    await this.runExternalScript(await this.getValue(c.falseScriptName, outerContext), await this.getValue(c.falseScriptType, outerContext));
+                    const falseGotoLabel = await this.getValue(c.falseGotoLabel, outerContext);
+                    if (falseGotoLabel) {
+                        i = scriptCommands.findIndex(x => x.type == "Label" && x.label == falseGotoLabel);
+                        if (i < 0)
+                            break;
+                    }
+                }
+            }
+            else
+                this.runScriptCommand(c, outerContext);
         }
     }
+    async runExternalScript(name, type) {
+        //TODO...
+    }
     async runScriptCommand(command, context) {
         switch (command.type) {
+            case 'Comment':
+            case 'Label':
+            case 'Condition':
+            case 'Goto':
+            case 'Exit':
+                {
+                    //Do nothing on this commands
+                    break;
+                }
             case 'OpenUrl': {
                 window.open(await this.getValue(command.url, context), command.target);
                 break;
@@ -123,6 +203,40 @@ export class ScriptSystem {
                 }
                 break;
             }
+            case 'SubscribeSignal': {
+                const signal = await this.getValue(command.signal, context);
+                const oneTime = await this.getValue(command.oneTime, context);
+                if (oneTime) {
+                    let cb = () => {
+                        this._visualizationHandler.unsubscribeState(signal, cb, null);
+                    };
+                    this._visualizationHandler.subscribeState(signal, cb);
+                }
+                else
+                    this._visualizationHandler.subscribeState(signal, this._subscriptionCallback);
+                break;
+            }
+            case 'UnsubscribeSignal': {
+                const signal = await this.getValue(command.signal, context);
+                this._visualizationHandler.unsubscribeState(signal, this._subscriptionCallback, null);
+                break;
+            }
+            case 'WriteSignalsInGroup': {
+                const group = await this.getValue(command.group, context);
+                this._visualizationHandler.writeSignalsInGroup(group);
+                break;
+            }
+            case 'ClearSiganlsInGroup': {
+                const group = await this.getValue(command.group, context);
+                this._visualizationHandler.clearSignalsInGroup(group);
+                break;
+            }
+            case 'RunScript': {
+                const name = await this.getValue(command.name, context);
+                const scriptType = await this.getValue(command.scriptType, context);
+                this.runExternalScript(name, scriptType);
+                break;
+            }
         }
     }
     getTargetFromTargetSelector(context, targetSelectorTarget, targetSelector) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "description": "web-component-designer addon for visualizations",
   "name": "@node-projects/web-component-designer-visualization-addons",
-  "version": "0.1.57",
+  "version": "0.1.59",
   "type": "module",
   "main": "./dist/index.js",
   "author": "jochen.kuehner@gmx.de",