@openremote/or-rules 1.8.0-snapshot.20250725074716 → 1.8.0-snapshot.20250725120001

package/lib/flow-viewer/models/status.js

@@ -1 +1,8 @@
-export var Status;!function(a){a[a.Idle=0]="Idle",a[a.Loading=1]="Loading",a[a.Success=2]="Success",a[a.Failure=3]="Failure"}(Status||(Status={}));
+export var Status;
+(function (Status) {
+    Status[Status["Idle"] = 0] = "Idle";
+    Status[Status["Loading"] = 1] = "Loading";
+    Status[Status["Success"] = 2] = "Success";
+    Status[Status["Failure"] = 3] = "Failure";
+})(Status || (Status = {}));
+//# sourceMappingURL=status.js.map

package/lib/flow-viewer/node-structure/copy.machine.js

@@ -1 +1,34 @@
-import{IdentityAssigner as e}from"./identity.assigner";export class CopyMachine{static copy(t){let n={};n.inputs=(t.inputs||[]).map(e=>({name:e.name,type:e.type})),n.internals=t.internals||[],n.name=t.name,n.displayCharacter=t.displayCharacter,n.outputs=(t.outputs||[]).map(e=>({name:e.name,type:e.type})),n.type=t.type,n.position={x:0,y:0},n.size={x:0,y:0};let a=JSON.parse(JSON.stringify(n));return a.id=e.generateIdentity(),a.inputs.forEach(t=>{t.nodeId=a.id,t.id=e.generateIdentity()}),a.outputs.forEach(t=>{t.nodeId=a.id,t.id=e.generateIdentity()}),a}}
+import { IdentityAssigner } from "./identity.assigner";
+export class CopyMachine {
+    static copy(node) {
+        const minimalNode = {};
+        minimalNode.inputs = (node.inputs || []).map((i) => {
+            return {
+                name: i.name, type: i.type
+            };
+        });
+        minimalNode.internals = node.internals || [];
+        minimalNode.name = node.name;
+        minimalNode.displayCharacter = node.displayCharacter;
+        minimalNode.outputs = (node.outputs || []).map((i) => {
+            return {
+                name: i.name, type: i.type
+            };
+        });
+        minimalNode.type = node.type;
+        minimalNode.position = { x: 0, y: 0 };
+        minimalNode.size = { x: 0, y: 0 };
+        const clone = JSON.parse(JSON.stringify(minimalNode));
+        clone.id = IdentityAssigner.generateIdentity();
+        clone.inputs.forEach((socket) => {
+            socket.nodeId = clone.id;
+            socket.id = IdentityAssigner.generateIdentity();
+        });
+        clone.outputs.forEach((socket) => {
+            socket.nodeId = clone.id;
+            socket.id = IdentityAssigner.generateIdentity();
+        });
+        return clone;
+    }
+}
+//# sourceMappingURL=copy.machine.js.map

package/lib/flow-viewer/node-structure/identity.assigner.js

@@ -1 +1,10 @@
-import t from"shortid";export class IdentityAssigner{static generateIdentity(){return t.generate()}static getSocketElementIdentity(t){return t.id}}
+import ShortID from "shortid";
+export class IdentityAssigner {
+    static generateIdentity() {
+        return ShortID.generate();
+    }
+    static getSocketElementIdentity(socket) {
+        return socket.id;
+    }
+}
+//# sourceMappingURL=identity.assigner.js.map

package/lib/flow-viewer/node-structure/identity.dom.link.js

@@ -1 +1,4 @@
-export class IdentityDomLink{}IdentityDomLink.map={};
+export class IdentityDomLink {
+}
+IdentityDomLink.map = {};
+//# sourceMappingURL=identity.dom.link.js.map

package/lib/flow-viewer/node-structure/index.js

@@ -1 +1,5 @@
-export{NodeUtilities}from"./utils";export{IdentityAssigner}from"./identity.assigner";export{IdentityDomLink}from"./identity.dom.link";export{CopyMachine}from"./copy.machine";
+export { NodeUtilities } from "./utils";
+export { IdentityAssigner } from "./identity.assigner";
+export { IdentityDomLink } from "./identity.dom.link";
+export { CopyMachine } from "./copy.machine";
+//# sourceMappingURL=index.js.map

package/lib/flow-viewer/node-structure/socket.type.matcher.js

@@ -1 +1,50 @@
-export class SocketTypeMatcher{static match(e,t){return"ANY"===e||"ANY"===t||SocketTypeMatcher.matches.find(t=>t.type===e).matches.includes(t)}}SocketTypeMatcher.matches=[{type:"NUMBER",matches:["NUMBER","STRING","NUMBER_ARRAY"]},{type:"STRING",matches:["STRING"]},{type:"TRIGGER",matches:["TRIGGER"]},{type:"BOOLEAN",matches:["BOOLEAN","STRING"]},{type:"COLOR",matches:["COLOR","STRING"]},{type:"NUMBER_ARRAY",matches:["NUMBER"]}];
+export class SocketTypeMatcher {
+    static match(a, b) {
+        return a === "ANY" /* NodeDataType.ANY */ ||
+            b === "ANY" /* NodeDataType.ANY */ ||
+            SocketTypeMatcher.matches.find((t) => t.type === a).matches.includes(b);
+    }
+}
+SocketTypeMatcher.matches = [
+    {
+        type: "NUMBER" /* NodeDataType.NUMBER */,
+        matches: [
+            "NUMBER" /* NodeDataType.NUMBER */,
+            "STRING" /* NodeDataType.STRING */,
+            "NUMBER_ARRAY" /* NodeDataType.NUMBER_ARRAY */
+        ]
+    },
+    {
+        type: "STRING" /* NodeDataType.STRING */,
+        matches: [
+            "STRING" /* NodeDataType.STRING */,
+        ]
+    },
+    {
+        type: "TRIGGER" /* NodeDataType.TRIGGER */,
+        matches: [
+            "TRIGGER" /* NodeDataType.TRIGGER */,
+        ]
+    },
+    {
+        type: "BOOLEAN" /* NodeDataType.BOOLEAN */,
+        matches: [
+            "BOOLEAN" /* NodeDataType.BOOLEAN */,
+            "STRING" /* NodeDataType.STRING */,
+        ]
+    },
+    {
+        type: "COLOR" /* NodeDataType.COLOR */,
+        matches: [
+            "COLOR" /* NodeDataType.COLOR */,
+            "STRING" /* NodeDataType.STRING */,
+        ]
+    },
+    {
+        type: "NUMBER_ARRAY" /* NodeDataType.NUMBER_ARRAY */,
+        matches: [
+            "NUMBER" /* NodeDataType.NUMBER */
+        ]
+    }
+];
+//# sourceMappingURL=socket.type.matcher.js.map

package/lib/flow-viewer/node-structure/utils.js

@@ -1 +1,109 @@
-export class NodeUtilities{static getNodeFromID(t,e){let r=e.find(e=>e.id===t);return r||console.warn(`Node with ID ${t} not found`),r}static getSocketFromID(t,e){for(let r of e){for(let e of r.inputs)if(e.id===t)return e;for(let e of r.outputs)if(e.id===t)return e}}static convertValueTypeToSocketType(t){switch(t.jsonType){case"boolean":return"BOOLEAN";case"number":case"bigint":return"NUMBER";case"string":return"STRING";default:return"ANY"}}static backtrackFrom(t,e){if(!t)throw Error("Collection has to exist");if(!t.nodes)throw Error("Collection has to have existing nodes");if(!t.connections)throw Error("Collection has to have existing connections");let r=this.getNodeFromID(e,t.nodes);if(!r)throw Error("Node has to exist");if(!r.inputs)throw Error("Node has to have existing inputs");if(!r.outputs)throw Error("Node has to have existing outputs");let o=[],i=[];for(let e of r.inputs)i=i.concat(t.connections.filter(t=>t.to===e.id).map(e=>this.getNodeFromID(this.getSocketFromID(e.from,t.nodes).nodeId,t.nodes)));for(let e of i){o.push(e);let r=this.backtrackFrom(t,e.id);o=o.concat(r)}return o}static validate(t){if(!t||!t.nodes||!t.connections)return!1;let e=t.nodes.filter(t=>"OUTPUT"===t.type);if(0===e.length)return!1;for(let r of e){let e=this.backtrackFrom(t,r.id);if(0===e.length||0===e.filter(t=>"INPUT"===t.type).length)return!1}return!0}static add(t,e){return{x:t.x+e.x,y:t.y+e.y}}static subtract(t,e){return{x:t.x-e.x,y:t.y-e.y}}static multiply(t,e){return{x:t.x*e,y:t.y*e}}static lerpNumber(t,e,r){return t*(1-r)+e*r}static lerp(t,e,r){return{x:this.lerpNumber(t.x,e.x,r),y:this.lerpNumber(t.y,e.y,r)}}}
+export class NodeUtilities {
+    static getNodeFromID(id, nodes) {
+        const node = nodes.find((n) => n.id === id);
+        if (!node) {
+            console.warn(`Node with ID ${id} not found`);
+        }
+        return node;
+    }
+    static getSocketFromID(id, nodes) {
+        for (const node of nodes) {
+            for (const input of node.inputs) {
+                if (input.id === id) {
+                    return input;
+                }
+            }
+            for (const output of node.outputs) {
+                if (output.id === id) {
+                    return output;
+                }
+            }
+        }
+    }
+    static convertValueTypeToSocketType(value) {
+        switch (value.jsonType) {
+            case "boolean": return "BOOLEAN" /* NodeDataType.BOOLEAN */;
+            case "number":
+            case "bigint": return "NUMBER" /* NodeDataType.NUMBER */;
+            case "string": return "STRING" /* NodeDataType.STRING */;
+            default: return "ANY" /* NodeDataType.ANY */;
+        }
+    }
+    static backtrackFrom(collection, nodeId) {
+        if (!collection) {
+            throw new Error("Collection has to exist");
+        }
+        if (!collection.nodes) {
+            throw new Error("Collection has to have existing nodes");
+        }
+        if (!collection.connections) {
+            throw new Error("Collection has to have existing connections");
+        }
+        const node = this.getNodeFromID(nodeId, collection.nodes);
+        if (!node) {
+            throw new Error("Node has to exist");
+        }
+        if (!node.inputs) {
+            throw new Error("Node has to have existing inputs");
+        }
+        if (!node.outputs) {
+            throw new Error("Node has to have existing outputs");
+        }
+        let total = [];
+        let children = [];
+        for (const s of node.inputs) {
+            children = children.concat(collection.connections.
+                filter((c) => c.to === s.id).
+                map((c) => this.getNodeFromID(this.getSocketFromID(c.from, collection.nodes).nodeId, collection.nodes)));
+        }
+        for (const child of children) {
+            total.push(child);
+            const result = this.backtrackFrom(collection, child.id);
+            total = total.concat(result);
+        }
+        return total;
+    }
+    static validate(collection) {
+        if (!collection) {
+            return false;
+        }
+        if (!collection.nodes) {
+            return false;
+        }
+        if (!collection.connections) {
+            return false;
+        }
+        const outputNodes = collection.nodes.filter((n) => n.type === "OUTPUT" /* NodeType.OUTPUT */);
+        if (outputNodes.length === 0) {
+            return false;
+        }
+        for (const output of outputNodes) {
+            const tree = this.backtrackFrom(collection, output.id);
+            if (tree.length === 0) {
+                return false;
+            }
+            if (tree.filter((n) => n.type === "INPUT" /* NodeType.INPUT */).length === 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+    static add(a, b) {
+        return { x: a.x + b.x, y: a.y + b.y };
+    }
+    static subtract(a, b) {
+        return { x: a.x - b.x, y: a.y - b.y };
+    }
+    static multiply(a, b) {
+        return { x: a.x * b, y: a.y * b };
+    }
+    static lerpNumber(x, y, t) {
+        return x * (1 - t) + y * t;
+    }
+    static lerp(a, b, t) {
+        const x = this.lerpNumber(a.x, b.x, t);
+        const y = this.lerpNumber(a.y, b.y, t);
+        return { x, y };
+    }
+}
+//# sourceMappingURL=utils.js.map

package/lib/flow-viewer/services/copy-paste-manager.js

@@ -1 +1,59 @@
-import{IdentityAssigner as e}from"../node-structure";import{input as t}from"../components/flow-editor";import{FlowNode as o,ConnectionLine as i}from"../flow-viewer";export class CopyPasteManager{get isFull(){return!this.clipboard}putInClipboard(e,t){this.copyOrigin=t,this.clipboard=e}getFromClipboard(e){let t=this.cloneIsolated(this.clipboard,0),o={x:e.x-this.copyOrigin.x,y:e.y-this.copyOrigin.y};return t.nodes.forEach(e=>{e.position.x+=o.x,e.position.y+=o.y}),t}cloneIsolated(t,o=50){let i={},n=JSON.parse(JSON.stringify(t));return n.nodes.forEach(t=>{let n=e.generateIdentity();i[t.id]=n,t.position.x+=o,t.position.y+=o,t.id=n,t.inputs.forEach(t=>{let o=e.generateIdentity();i[t.id]=o,t.id=o,t.nodeId=n}),t.outputs.forEach(t=>{let o=e.generateIdentity();i[t.id]=o,t.id=o,t.nodeId=n})}),n.connections.forEach(e=>{e.from=i[e.from],e.to=i[e.to]}),n}copy(e,n){let r=t.selected.filter(e=>e instanceof o&&e.selected),s=t.selected.filter(e=>e instanceof i&&e.selected);this.putInClipboard({nodes:r.map(e=>e.node),connections:s.map(e=>e.connection)},{x:e,y:n})}}
+import { IdentityAssigner } from "../node-structure";
+import { input } from "../components/flow-editor";
+import { FlowNode, ConnectionLine } from "../flow-viewer";
+export class CopyPasteManager {
+    get isFull() { return !!!this.clipboard; }
+    putInClipboard(obj, origin) {
+        this.copyOrigin = origin;
+        this.clipboard = obj;
+    }
+    getFromClipboard(newOrigin) {
+        const clone = this.cloneIsolated(this.clipboard, 0);
+        const offset = {
+            x: newOrigin.x - this.copyOrigin.x,
+            y: newOrigin.y - this.copyOrigin.y,
+        };
+        clone.nodes.forEach((node) => {
+            node.position.x += offset.x;
+            node.position.y += offset.y;
+        });
+        return clone;
+    }
+    cloneIsolated(obj, positionOffset = 50) {
+        const remapped = {};
+        const clone = JSON.parse(JSON.stringify(obj));
+        clone.nodes.forEach((node) => {
+            const newNodeID = IdentityAssigner.generateIdentity();
+            remapped[node.id] = newNodeID;
+            node.position.x += positionOffset;
+            node.position.y += positionOffset;
+            node.id = newNodeID;
+            node.inputs.forEach((inputSocket) => {
+                const newSocketID = IdentityAssigner.generateIdentity();
+                remapped[inputSocket.id] = newSocketID;
+                inputSocket.id = newSocketID;
+                inputSocket.nodeId = newNodeID;
+            });
+            node.outputs.forEach((outputSocket) => {
+                const newSocketID = IdentityAssigner.generateIdentity();
+                remapped[outputSocket.id] = newSocketID;
+                outputSocket.id = newSocketID;
+                outputSocket.nodeId = newNodeID;
+            });
+        });
+        clone.connections.forEach((connection) => {
+            connection.from = remapped[connection.from];
+            connection.to = remapped[connection.to];
+        });
+        return clone;
+    }
+    copy(x, y) {
+        const selectedNodes = input.selected.filter((s) => s instanceof FlowNode && s.selected);
+        const selectedConnections = input.selected.filter((s) => s instanceof ConnectionLine && s.selected);
+        this.putInClipboard({
+            nodes: selectedNodes.map((n) => n.node),
+            connections: selectedConnections.map((c) => c.connection)
+        }, { x, y });
+    }
+}
+//# sourceMappingURL=copy-paste-manager.js.map

package/lib/flow-viewer/services/exporter.js

@@ -1 +1,67 @@
-import e from"@openremote/core";import{project as t,modal as o}from"../components/flow-editor";export class Exporter{flowToJson(e){return JSON.stringify(e)}jsonToFlow(e){return JSON.parse(e)}collectionToRuleset(e,t){return{lang:"FLOW",name:e.name,type:t,rules:this.flowToJson(e)}}rulesetToCollection(e){return this.jsonToFlow(e.rules)}exportAsNew(n){let s=this.flowToJson(n),l=e.rest.api.RulesResource,i={lang:"FLOW",name:n.name,type:"global",rules:s};l.createGlobalRuleset(i).then(e=>{200===e.status?(t.setCurrentProject(e.data,n.name,n.description),console.log("Successfully saved new ruleset")):(console.log("Something went wrong while saving NEW ruleset\nHTTP status "+e.status),o.notification("Failure",`Something went wrong while saving ${i.name}`))}).catch(e=>{console.log("Something went wrong while saving NEW ruleset\nHTTP status "+e),o.notification("Failure",`Something went wrong while saving ${i.name}`)})}exportAsExisting(n,s){let l=this.flowToJson(s),i=e.rest.api.RulesResource;i.getGlobalRuleset(t.existingFlowRuleId).then(e=>{let n=e.data;n.rules=l,i.updateGlobalRuleset(n.id,n).then(e=>{204===e.status?(t.unsavedState=!1,console.log("Successfully saved ruleset")):(console.log("Something went wrong while saving EXISTING ruleset\n"+e.status),o.notification("Failure",`Something went wrong while saving ${s.name}`))})}).catch(e=>{console.log("Something went wrong while saving EXISTING ruleset\n"+e),o.notification("Failure",`Something went wrong while saving ${s.name}`)})}}
+import manager from "@openremote/core";
+import { project, modal } from "../components/flow-editor";
+export class Exporter {
+    flowToJson(collection) {
+        return JSON.stringify(collection);
+    }
+    jsonToFlow(json) {
+        return JSON.parse(json);
+    }
+    collectionToRuleset(collection, type) {
+        const ruleset = {
+            lang: "FLOW" /* RulesetLang.FLOW */,
+            name: collection.name,
+            type,
+            rules: this.flowToJson(collection),
+        };
+        return ruleset;
+    }
+    rulesetToCollection(ruleset) {
+        return this.jsonToFlow(ruleset.rules);
+    }
+    exportAsNew(collection) {
+        const json = this.flowToJson(collection);
+        const ruleApi = manager.rest.api.RulesResource;
+        const rs = {
+            lang: "FLOW" /* RulesetLang.FLOW */,
+            name: collection.name,
+            type: "global",
+            rules: json
+        };
+        ruleApi.createGlobalRuleset(rs).then((e) => {
+            if (e.status === 200) {
+                project.setCurrentProject(e.data, collection.name, collection.description);
+                console.log("Successfully saved new ruleset");
+            }
+            else {
+                console.log("Something went wrong while saving NEW ruleset\nHTTP status " + e.status);
+                modal.notification("Failure", `Something went wrong while saving ${rs.name}`);
+            }
+        }).catch((e) => {
+            console.log("Something went wrong while saving NEW ruleset\nHTTP status " + e);
+            modal.notification("Failure", `Something went wrong while saving ${rs.name}`);
+        });
+    }
+    exportAsExisting(id, collection) {
+        const json = this.flowToJson(collection);
+        const ruleApi = manager.rest.api.RulesResource;
+        ruleApi.getGlobalRuleset(project.existingFlowRuleId).then((response) => {
+            const existing = response.data;
+            existing.rules = json;
+            ruleApi.updateGlobalRuleset(existing.id, existing).then((e) => {
+                if (e.status === 204) {
+                    project.unsavedState = false;
+                    console.log("Successfully saved ruleset");
+                }
+                else {
+                    console.log("Something went wrong while saving EXISTING ruleset\n" + e.status);
+                    modal.notification("Failure", `Something went wrong while saving ${collection.name}`);
+                }
+            });
+        }).catch((e) => {
+            console.log("Something went wrong while saving EXISTING ruleset\n" + e);
+            modal.notification("Failure", `Something went wrong while saving ${collection.name}`);
+        });
+    }
+}
+//# sourceMappingURL=exporter.js.map

package/lib/flow-viewer/services/input.js

@@ -1 +1,80 @@
-import{EventEmitter as e}from"events";import{project as t}from"../components/flow-editor";export class Input extends e{constructor(){super(),this.selected=[],this.selectables=[],this.keysCurrentlyHeld=[],this.onkeydown=e=>{this.keysCurrentlyHeld.includes(e.key)||this.keysCurrentlyHeld.push(e.key)},this.onkeyup=e=>{let t=this.keysCurrentlyHeld.indexOf(e.key);-1!==t&&this.keysCurrentlyHeld.splice(t,1)},window.addEventListener("keydown",this.onkeydown),window.addEventListener("keyup",this.onkeyup),window.addEventListener("blur",()=>{this.clearSelection(),this.keysCurrentlyHeld=[]}),t.addListener("cleared",()=>{this.clearSelection()}),this.setMaxListeners(1024)}select(e,t=!1){this.multiSelectedEnabled||t||this.clearSelection(),!this.selected.includes(e)&&(this.emit("selected",e),e.selected&&this.selected.push(e))}deselect(e){let t=this.selected.indexOf(e);if(-1===t)return void console.warn("Attempt to deselect nonexistent node");this.emit("deselected",e),e.selected||this.selected.splice(t,1)}handleSelection(e,t=!1){!this.multiSelectedEnabled&&this.selected.length>1?this.select(e):this.selected.includes(e)&&!t?this.deselect(e):this.select(e)}clearSelection(e=!1){(!this.multiSelectedEnabled||e)&&(this.selected.forEach(e=>this.emit("deselected",e)),this.selected=[],this.emit("selectioncleared"))}isHeld(e){return this.keysCurrentlyHeld.includes(e)}get multiSelectedEnabled(){return this.isHeld("Shift")||this.isHeld("Control")}}
+import { EventEmitter } from "events";
+import { project } from "../components/flow-editor";
+export class Input extends EventEmitter {
+    constructor() {
+        super();
+        this.selected = [];
+        this.selectables = [];
+        this.keysCurrentlyHeld = [];
+        this.onkeydown = (e) => {
+            if (this.keysCurrentlyHeld.includes(e.key)) {
+                return;
+            }
+            this.keysCurrentlyHeld.push(e.key);
+        };
+        this.onkeyup = (e) => {
+            const index = this.keysCurrentlyHeld.indexOf(e.key);
+            if (index === -1) {
+                return;
+            }
+            this.keysCurrentlyHeld.splice(index, 1);
+        };
+        window.addEventListener("keydown", this.onkeydown);
+        window.addEventListener("keyup", this.onkeyup);
+        window.addEventListener("blur", () => {
+            this.clearSelection();
+            this.keysCurrentlyHeld = [];
+        });
+        project.addListener("cleared", () => { this.clearSelection(); });
+        this.setMaxListeners(1024);
+    }
+    select(element, forceMultipleSelection = false) {
+        if (!this.multiSelectedEnabled && !forceMultipleSelection) {
+            this.clearSelection();
+        }
+        if (this.selected.includes(element)) {
+            return;
+        }
+        this.emit("selected", element);
+        if (element.selected) {
+            this.selected.push(element);
+        }
+    }
+    deselect(element) {
+        const index = this.selected.indexOf(element);
+        if (index === -1) {
+            console.warn("Attempt to deselect nonexistent node");
+            return;
+        }
+        this.emit("deselected", element);
+        if (!element.selected) {
+            this.selected.splice(index, 1);
+        }
+    }
+    handleSelection(element, neverDeselect = false) {
+        if (!this.multiSelectedEnabled && this.selected.length > 1) {
+            this.select(element);
+        }
+        else if (this.selected.includes(element) && !neverDeselect) {
+            this.deselect(element);
+        }
+        else {
+            this.select(element);
+        }
+    }
+    clearSelection(ignoreMultiselect = false) {
+        if (this.multiSelectedEnabled && !ignoreMultiselect) {
+            return;
+        }
+        this.selected.forEach((e) => this.emit("deselected", e));
+        this.selected = [];
+        this.emit("selectioncleared");
+    }
+    isHeld(key) {
+        return this.keysCurrentlyHeld.includes(key);
+    }
+    get multiSelectedEnabled() {
+        return this.isHeld("Shift") || this.isHeld("Control");
+    }
+}
+//# sourceMappingURL=input.js.map

package/lib/flow-viewer/services/integration.js

@@ -1 +1,27 @@
-var __awaiter=this&&this.__awaiter||function(t,e,n,o){return new(n||(n=Promise))(function(i,r){function s(t){try{c(o.next(t))}catch(t){r(t)}}function a(t){try{c(o.throw(t))}catch(t){r(t)}}function c(t){var e;t.done?i(t.value):((e=t.value)instanceof n?e:new n(function(t){t(e)})).then(s,a)}c((o=o.apply(t,e||[])).next())})};import t from"@openremote/rest";import{EventEmitter as e}from"events";export class Integration extends e{constructor(){super(...arguments),this.nodes=[]}refreshNodes(){return __awaiter(this,void 0,void 0,function*(){for(let e of(this.nodes=[],(yield t.api.FlowResource.getAllNodeDefinitions()).data))this.nodes.push(e)})}}
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import rest from "@openremote/rest";
+import { EventEmitter } from "events";
+export class Integration extends EventEmitter {
+    constructor() {
+        super(...arguments);
+        this.nodes = [];
+    }
+    refreshNodes() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.nodes = [];
+            const allNodes = (yield rest.api.FlowResource.getAllNodeDefinitions()).data;
+            for (const n of allNodes) {
+                this.nodes.push(n);
+            }
+        });
+    }
+}
+//# sourceMappingURL=integration.js.map

package/lib/flow-viewer/services/modal.js

@@ -1,8 +1,29 @@
-import{html as e}from"lit";import{i18next as t}from"@openremote/or-translate";export class ModalService{confirmation(o,i=t.t("flowEditor","Flow editor"),n=t.t("areYouSure","Are you sure?")){this.element.content=e`<confirmation-dialog 
-        .question = "${n}"
-        @agreed="${()=>{o&&o(),this.element.close()}}"
-        @disagreed="${this.element.close}"
-        ></confirmation-dialog>`,this.element.header=i,this.element.open()}notification(o,i,n=t.t("ok","OK")){this.element.content=e`<notification-dialog 
-        .message = "${i}"
-        @closed = "${this.element.close}"
-        ></notification-dialog>`,this.element.header=o,this.element.open()}anything(e,t){this.element.content=t,this.element.header=e,this.element.open()}}
+import { html } from "lit";
+import { i18next } from "@openremote/or-translate";
+export class ModalService {
+    confirmation(agreeCallback, header = i18next.t("flowEditor", "Flow editor"), question = i18next.t("areYouSure", "Are you sure?")) {
+        this.element.content = html `<confirmation-dialog 
+        .question = "${question}"
+        @agreed="${() => { if (agreeCallback) {
+            agreeCallback();
+        } this.element.close(); }}"
+        @disagreed="${this.element.close}"
+        ></confirmation-dialog>`;
+        this.element.header = header;
+        this.element.open();
+    }
+    notification(header, message, buttonText = i18next.t("ok", "OK")) {
+        this.element.content = html `<notification-dialog 
+        .message = "${message}"
+        @closed = "${this.element.close}"
+        ></notification-dialog>`;
+        this.element.header = header;
+        this.element.open();
+    }
+    anything(header, content) {
+        this.element.content = content;
+        this.element.header = header;
+        this.element.open();
+    }
+}
+//# sourceMappingURL=modal.js.map