@openremote/or-rules 1.8.0-snapshot.20250723203453 → 1.8.0-snapshot.20250725120000

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

@@ -1 +1,19 @@
-export{FlowEditor}from"./components/flow-editor";export{NodePanel}from"./components/node-panel";export{EditorWorkspace}from"./components/editor-workspace";export{TopBar}from"./components/top-bar";export{NodeMenuItem}from"./components/node-menu-item";export{SelectableElement}from"./components/selectable-element";export{FlowNode}from"./components/flow-node";export{FlowNodeSocket}from"./components/flow-node-socket";export{ConnectionLine}from"./components/connection-line";export{ConnectionContainer}from"./components/connection-container";export{SelectionBox}from"./components/selection-box";export{ContextMenu}from"./components/context-menu";export{InternalPicker}from"./components/internal-picker";export{PopupModal}from"./components/popup-modal";export{RuleBrowser}from"./components/rule-browser";export{WritableDropdown}from"./components/writable-dropdown";export{ConfirmationDialog}from"./components/confirmation-dialog";export{NotificationDialog}from"./components/notification-dialog";
+export { FlowEditor } from "./components/flow-editor";
+export { NodePanel } from "./components/node-panel";
+export { EditorWorkspace } from "./components/editor-workspace";
+export { TopBar } from "./components/top-bar";
+export { NodeMenuItem } from "./components/node-menu-item";
+export { SelectableElement } from "./components/selectable-element";
+export { FlowNode } from "./components/flow-node";
+export { FlowNodeSocket } from "./components/flow-node-socket";
+export { ConnectionLine } from "./components/connection-line";
+export { ConnectionContainer } from "./components/connection-container";
+export { SelectionBox } from "./components/selection-box";
+export { ContextMenu } from "./components/context-menu";
+export { InternalPicker } from "./components/internal-picker";
+export { PopupModal } from "./components/popup-modal";
+export { RuleBrowser } from "./components/rule-browser";
+export { WritableDropdown } from "./components/writable-dropdown";
+export { ConfirmationDialog } from "./components/confirmation-dialog";
+export { NotificationDialog } from "./components/notification-dialog";
+//# sourceMappingURL=flow-viewer.js.map

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

@@ -1 +1,2 @@
-export{};
+export {};
+//# sourceMappingURL=camera.js.map

package/lib/flow-viewer/models/context-menu-button.js

@@ -1 +1,2 @@
-export{};
+export {};
+//# sourceMappingURL=context-menu-button.js.map

package/lib/flow-viewer/models/light-node-collection.js

@@ -1 +1,2 @@
-export{};
+export {};
+//# sourceMappingURL=light-node-collection.js.map

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}from"./identity.assigner";export class CopyMachine{static copy(t){const e={};e.inputs=(t.inputs||[]).map((t=>({name:t.name,type:t.type}))),e.internals=t.internals||[],e.name=t.name,e.displayCharacter=t.displayCharacter,e.outputs=(t.outputs||[]).map((t=>({name:t.name,type:t.type}))),e.type=t.type,e.position={x:0,y:0},e.size={x:0,y:0};const n=JSON.parse(JSON.stringify(e));return n.id=IdentityAssigner.generateIdentity(),n.inputs.forEach((t=>{t.nodeId=n.id,t.id=IdentityAssigner.generateIdentity()})),n.outputs.forEach((t=>{t.nodeId=n.id,t.id=IdentityAssigner.generateIdentity()})),n}}
+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 ShortID from"shortid";export class IdentityAssigner{static generateIdentity(){return ShortID.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){const o=e.find((e=>e.id===t));return o||console.warn(`Node with ID ${t} not found`),o}static getSocketFromID(t,e){for(const o of e){for(const e of o.inputs)if(e.id===t)return e;for(const e of o.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 new Error("Collection has to exist");if(!t.nodes)throw new Error("Collection has to have existing nodes");if(!t.connections)throw new Error("Collection has to have existing connections");const o=this.getNodeFromID(e,t.nodes);if(!o)throw new Error("Node has to exist");if(!o.inputs)throw new Error("Node has to have existing inputs");if(!o.outputs)throw new Error("Node has to have existing outputs");let r=[],n=[];for(const e of o.inputs)n=n.concat(t.connections.filter((t=>t.to===e.id)).map((e=>this.getNodeFromID(this.getSocketFromID(e.from,t.nodes).nodeId,t.nodes))));for(const e of n){r.push(e);const o=this.backtrackFrom(t,e.id);r=r.concat(o)}return r}static validate(t){if(!t)return!1;if(!t.nodes)return!1;if(!t.connections)return!1;const e=t.nodes.filter((t=>"OUTPUT"===t.type));if(0===e.length)return!1;for(const o of e){const e=this.backtrackFrom(t,o.id);if(0===e.length)return!1;if(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,o){return t*(1-o)+e*o}static lerp(t,e,o){return{x:this.lerpNumber(t.x,e.x,o),y:this.lerpNumber(t.y,e.y,o)}}}
+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}from"../node-structure";import{input}from"../components/flow-editor";import{FlowNode,ConnectionLine}from"../flow-viewer";export class CopyPasteManager{get isFull(){return!this.clipboard}putInClipboard(o,t){this.copyOrigin=t,this.clipboard=o}getFromClipboard(o){const t=this.cloneIsolated(this.clipboard,0),e=o.x-this.copyOrigin.x,n=o.y-this.copyOrigin.y;return t.nodes.forEach((o=>{o.position.x+=e,o.position.y+=n})),t}cloneIsolated(o,t=50){const e={},n=JSON.parse(JSON.stringify(o));return n.nodes.forEach((o=>{const n=IdentityAssigner.generateIdentity();e[o.id]=n,o.position.x+=t,o.position.y+=t,o.id=n,o.inputs.forEach((o=>{const t=IdentityAssigner.generateIdentity();e[o.id]=t,o.id=t,o.nodeId=n})),o.outputs.forEach((o=>{const t=IdentityAssigner.generateIdentity();e[o.id]=t,o.id=t,o.nodeId=n}))})),n.connections.forEach((o=>{o.from=e[o.from],o.to=e[o.to]})),n}copy(o,t){const e=input.selected.filter((o=>o instanceof FlowNode&&o.selected)),n=input.selected.filter((o=>o instanceof ConnectionLine&&o.selected));this.putInClipboard({nodes:e.map((o=>o.node)),connections:n.map((o=>o.connection))},{x:o,y:t})}}
+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 manager from"@openremote/core";import{project,modal}from"../components/flow-editor";export class Exporter{flowToJson(e){return JSON.stringify(e)}jsonToFlow(e){return JSON.parse(e)}collectionToRuleset(e,o){return{lang:"FLOW",name:e.name,type:o,rules:this.flowToJson(e)}}rulesetToCollection(e){return this.jsonToFlow(e.rules)}exportAsNew(e){const o=this.flowToJson(e),t=manager.rest.api.RulesResource,n={lang:"FLOW",name:e.name,type:"global",rules:o};t.createGlobalRuleset(n).then((o=>{200===o.status?(project.setCurrentProject(o.data,e.name,e.description),console.log("Successfully saved new ruleset")):(console.log("Something went wrong while saving NEW ruleset\nHTTP status "+o.status),modal.notification("Failure",`Something went wrong while saving ${n.name}`))})).catch((e=>{console.log("Something went wrong while saving NEW ruleset\nHTTP status "+e),modal.notification("Failure",`Something went wrong while saving ${n.name}`)}))}exportAsExisting(e,o){const t=this.flowToJson(o),n=manager.rest.api.RulesResource;n.getGlobalRuleset(project.existingFlowRuleId).then((e=>{const s=e.data;s.rules=t,n.updateGlobalRuleset(s.id,s).then((e=>{204===e.status?(project.unsavedState=!1,console.log("Successfully saved ruleset")):(console.log("Something went wrong while saving EXISTING ruleset\n"+e.status),modal.notification("Failure",`Something went wrong while saving ${o.name}`))}))})).catch((e=>{console.log("Something went wrong while saving EXISTING ruleset\n"+e),modal.notification("Failure",`Something went wrong while saving ${o.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.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { EventEmitter } from "events";
 import { SelectableElement } from "../components/selectable-element";
 export declare class Input extends EventEmitter {

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

@@ -1 +1,80 @@
-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=>{this.keysCurrentlyHeld.includes(e.key)||this.keysCurrentlyHeld.push(e.key)},this.onkeyup=e=>{const 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=[]})),project.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){const t=this.selected.indexOf(e);-1!==t?(this.emit("deselected",e),e.selected||this.selected.splice(t,1)):console.warn("Attempt to deselect nonexistent node")}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.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { Node } from "@openremote/model";
 import { EventEmitter } from "events";
 export declare class Integration extends EventEmitter {

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(r,i){function s(t){try{c(o.next(t))}catch(t){i(t)}}function a(t){try{c(o.throw(t))}catch(t){i(t)}}function c(t){var e;t.done?r(t.value):(e=t.value,e instanceof n?e:new n((function(t){t(e)}))).then(s,a)}c((o=o.apply(t,e||[])).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 t=(yield rest.api.FlowResource.getAllNodeDefinitions()).data;for(const e of t)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}from"lit";import{i18next}from"@openremote/or-translate";export class ModalService{confirmation(e,t=i18next.t("flowEditor","Flow editor"),i=i18next.t("areYouSure","Are you sure?")){this.element.content=html`<confirmation-dialog 
-        .question = "${i}"
-        @agreed="${()=>{e&&e(),this.element.close()}}"
-        @disagreed="${this.element.close}"
-        ></confirmation-dialog>`,this.element.header=t,this.element.open()}notification(e,t,i=i18next.t("ok","OK")){this.element.content=html`<notification-dialog 
-        .message = "${t}"
-        @closed = "${this.element.close}"
-        ></notification-dialog>`,this.element.header=e,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

package/lib/flow-viewer/services/project.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { Node, NodeCollection, NodeConnection, NodeSocket } from "@openremote/model";
 import { EventEmitter } from "events";
 import { EditorWorkspace } from "../components/editor-workspace";