codenotch-react 1.0.54 → 1.0.56

package/dist/{auml.d.ts → components/Auml.d.ts}

@@ -14,7 +14,7 @@ export declare class Auml extends React.Component<IAumlProps, IAumlState> {
     componentWillUnmount(): void;
     progress(s: SpaRenderStatus): void;
     getLogo(): React.JSX.Element;
-    getMode(theme: boolean | undefined): "dark" | "light";
+    getMode(theme: boolean | undefined): "light" | "dark";
     retrieveInputs(): {
         [k: string]: string;
     };
@@ -26,4 +26,4 @@ export declare class Auml extends React.Component<IAumlProps, IAumlState> {
     refreshExpiredToken(): Promise<void>;
 }
 export {};
-//# sourceMappingURL=auml.d.ts.map
+//# sourceMappingURL=Auml.d.ts.map

package/dist/components/Auml.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Auml.d.ts","sourceRoot":"","sources":["../../src/components/Auml.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,OAAO,EAAE,eAAe,EAAE,MAAM,0EAA0E,CAAC;AAS3G,UAAU,UAAU;IAChB,KAAK,EAAE,MAAM,CAAC;CACjB;AAED,UAAU,UAAU;IAChB,MAAM,EAAE,OAAO,CAAC;IAChB,gBAAgB,EAAE,OAAO,CAAC;CAC7B;AAED,qBAAa,IAAK,SAAQ,KAAK,CAAC,SAAS,CAAC,UAAU,EAAE,UAAU,CAAC;IAE7D,kBAAkB,EAAE,MAAM,CAAC,OAAO,GAAG,SAAS,CAAC;gBAEnC,KAAK,EAAE,UAAU;IAQ7B,iBAAiB;IAmCjB,oBAAoB;IAQpB,QAAQ,CAAC,CAAC,EAAE,eAAe;IAO3B,OAAO;IAYP,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,SAAS;IAclC,cAAc;;;IAMd,wBAAwB,IAAI,MAAM,GAAG,IAAI;IAoCzC,2BAA2B,CAAC,kBAAkB,EAAE,MAAM,GAAG,MAAM;IAO/D,QAAQ,CAAC,EAAE,EAAE,MAAM;IAmBnB,QAAQ,CAAC,KAAK,EAAE,MAAM;IAsBtB,MAAM;IA2CA,mBAAmB;CAqC5B"}

package/dist/{auml.js → components/Auml.js}

@@ -150,12 +150,12 @@ export interface UserInfo {
             aumlManifest = appManifestObj.auml;
         }
         catch { }
-        return (react_1.default.createElement("div", { className: "app" },
+        return react_1.default.createElement("div", { className: "app" },
             react_1.default.createElement(SpaRenderWithBrowserRouter_1.SpaRenderWithBrowserRouter, { appDescription: this.props.value, tenant: tenant, serviceName: serviceName, packageVersions: packageVersions, user: user, languages: languages, onProgress: (s) => this.progress(s), input: inputs, theme: theme, manifest: aumlManifest, inspectorEnabled: this.state.inspectorEnabled, children: [] }),
             !this.state.loaded &&
                 react_1.default.createElement("div", { className: `app-loading ${this.getMode(theme)}` },
                     this.getLogo(),
-                    react_1.default.createElement("i", { className: "fas fa-circle-notch fa-spin" }))));
+                    react_1.default.createElement("i", { className: "fas fa-circle-notch fa-spin" })));
     }
     async refreshExpiredToken() {
         console.log("Token will expire soon, requesting a new one...");

package/dist/components/CodeEditor.d.ts

@@ -0,0 +1,27 @@
+import React from "react";
+interface ICodeEditorProps {
+    style?: React.CSSProperties;
+    className?: string;
+    value?: string;
+    language?: string;
+    readOnly?: boolean;
+    onChange?: (value: string) => void;
+}
+/**
+ * Light version of Monaco Editor in an iframe.
+ */
+export default class CodeEditor extends React.Component<ICodeEditorProps> {
+    private isIframeReady;
+    private onChangeTimeoutHandle;
+    refFrame: React.RefObject<HTMLIFrameElement>;
+    setValue(value: string): void;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    componentDidUpdate(prevProps: ICodeEditorProps): void;
+    private handleMessage;
+    private postToIframe;
+    private writeIframe;
+    render(): React.JSX.Element;
+}
+export {};
+//# sourceMappingURL=CodeEditor.d.ts.map

package/dist/components/CodeEditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CodeEditor.d.ts","sourceRoot":"","sources":["../../src/components/CodeEditor.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAG1B,UAAU,gBAAgB;IACtB,KAAK,CAAC,EAAE,KAAK,CAAC,aAAa,CAAC;IAC5B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACtC;AAED;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,UAAW,SAAQ,KAAK,CAAC,SAAS,CAAC,gBAAgB,CAAC;IACrE,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,qBAAqB,CAAa;IAC1C,QAAQ,qCAAwC;IAEhD,QAAQ,CAAC,KAAK,EAAE,MAAM;IAStB,iBAAiB,IAAI,IAAI;IAKzB,oBAAoB,IAAI,IAAI;IAI5B,kBAAkB,CAAC,SAAS,EAAE,gBAAgB,GAAG,IAAI;IAoBrD,OAAO,CAAC,aAAa;IAgCrB,OAAO,CAAC,YAAY;IAMpB,OAAO,CAAC,WAAW;IA4EnB,MAAM;CAeT"}

package/dist/components/CodeEditor.js

@@ -0,0 +1,170 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const __1 = require("..");
+/**
+ * Light version of Monaco Editor in an iframe.
+ */
+class CodeEditor extends react_1.default.Component {
+    constructor() {
+        super(...arguments);
+        this.isIframeReady = false;
+        this.onChangeTimeoutHandle = null;
+        this.refFrame = react_1.default.createRef();
+    }
+    setValue(value) {
+        if (this.isIframeReady) {
+            this.postToIframe({
+                type: 'update',
+                value: value,
+            });
+        }
+    }
+    componentDidMount() {
+        window.addEventListener('message', this.handleMessage);
+        this.writeIframe();
+    }
+    componentWillUnmount() {
+        window.removeEventListener('message', this.handleMessage);
+    }
+    componentDidUpdate(prevProps) {
+        const changed = (prevProps.value !== this.props.value ||
+            prevProps.language !== this.props.language ||
+            prevProps.readOnly !== this.props.readOnly);
+        if (changed && this.isIframeReady) {
+            let isDark = (0, __1.useCodenotch)().getTheme() === 'dark';
+            this.postToIframe({
+                type: 'update',
+                value: this.props.value ?? '',
+                language: this.props.language || 'plaintext',
+                readOnly: !!this.props.readOnly,
+                theme: isDark ? 'vs-dark' : 'vs'
+            });
+        }
+    }
+    handleMessage(event) {
+        const data = event.data;
+        if (!data || typeof data !== 'object')
+            return;
+        if (data.__from !== 'MonacoIframe')
+            return;
+        switch (data.type) {
+            case 'ready': {
+                this.isIframeReady = true;
+                // send initial payload
+                this.postToIframe({
+                    type: 'init',
+                    value: this.props.value ?? '',
+                    language: this.props.language || 'plaintext',
+                    readOnly: !!this.props.readOnly,
+                    theme: (0, __1.useCodenotch)().getTheme() === 'dark' ? 'vs-dark' : 'vs'
+                });
+                break;
+            }
+            case 'change': {
+                const next = String(data.value ?? '');
+                if (this.onChangeTimeoutHandle) {
+                    clearTimeout(this.onChangeTimeoutHandle);
+                }
+                this.onChangeTimeoutHandle = setTimeout(() => {
+                    this.props.onChange?.(next);
+                }, 300);
+                break;
+            }
+        }
+    }
+    ;
+    postToIframe(message) {
+        const w = this.refFrame.current?.contentWindow;
+        if (!w)
+            return;
+        w.postMessage({ __from: 'MonacoIframe', ...message }, '*');
+    }
+    writeIframe() {
+        const iframe = this.refFrame.current;
+        if (!iframe)
+            return;
+        const vsBase = 'https://cdn.jsdelivr.net/npm/monaco-editor@0.55.1/min/vs';
+        const html = `<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <style>
+      html, body, #container { height: 100%; width: 100%; margin: 0; padding: 0; overflow: hidden; }
+    </style>
+    <script>
+      (function(){
+        var vsBase = ${JSON.stringify(vsBase)};
+        // AMD loader
+        var s = document.createElement('script');
+        s.src = vsBase + '/loader.js';
+        s.onload = function(){
+          // Configure and load monaco
+          window.require.config({ paths: { vs: vsBase } });
+          window.require(['vs/editor/editor.main'], function(){
+            var editor;
+
+            function post(msg){ parent.postMessage(Object.assign({__from:'MonacoIframe'}, msg), '*'); }
+
+            function ensureEditor(){
+              if (editor) return editor;
+              editor = monaco.editor.create(document.getElementById('container'), {
+                value: '',
+                language: 'plaintext',
+                theme: 'vs',
+                automaticLayout: true,
+                minimap: { enabled: false },
+                scrollBeyondLastLine: true,
+                wordWrap: "on"
+              });
+              editor.onDidChangeModelContent(function(){
+                var v = editor.getValue();
+                post({ type: 'change', value: v });
+              });
+              return editor;
+            }
+
+            window.addEventListener('message', function(ev){
+              var data = ev.data || {}; if (data.__from !== 'MonacoIframe') return;
+              if (data.type === 'init' || data.type === 'update'){
+                var ed = ensureEditor();
+                if (typeof data.value === 'string' && ed.getValue() !== data.value){ ed.setValue(data.value); }
+                if (typeof data.language === 'string') { monaco.editor.setModelLanguage(ed.getModel(), data.language); }
+                if (typeof data.theme === 'string') { monaco.editor.setTheme(data.theme); }
+                if (typeof data.readOnly === 'boolean') { ed.updateOptions({ readOnly: data.readOnly }); }
+              }
+            });
+
+            // Signal ready after monaco is loaded
+            post({ type: 'ready' });
+          });
+        };
+        document.head.appendChild(s);
+      })();
+    </script>
+  </head>
+  <body>
+    <div id="container"></div>
+  </body>
+</html>`;
+        const doc = iframe.contentWindow?.document;
+        if (!doc)
+            return;
+        doc.open();
+        doc.write(html);
+        doc.close();
+    }
+    render() {
+        let style = this.props.style || {};
+        style.width = style.width || '100%';
+        style.height = style.height || '100%';
+        style.border = style.border || '0';
+        style.outline = style.outline || '0';
+        return react_1.default.createElement("iframe", { style: style, title: "Codenotch", ref: this.refFrame, className: this.props.className, sandbox: "allow-scripts allow-same-origin" });
+    }
+}
+exports.default = CodeEditor;

package/dist/core/ProcessUtils.d.ts

@@ -0,0 +1,9 @@
+import { IProcessCallbacks, IProcessResult } from "../models/Misc";
+/**
+ * static class mainly containing a method to start processes
+ */
+export default class ProcessUtils {
+    static startProcess(subscribeFunc: (processInstanceId: string, callbacks: IProcessCallbacks) => Promise<void>, clusterUrl: string, tenantName: string, projectName: string, processId: string, processInput: any, processInstanceId?: string, startNodeId?: string, token?: string): Promise<IProcessResult>;
+    private static launchMainProcess;
+}
+//# sourceMappingURL=ProcessUtils.d.ts.map

package/dist/core/ProcessUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProcessUtils.d.ts","sourceRoot":"","sources":["../../src/core/ProcessUtils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAEnE;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,YAAY;WAET,YAAY,CAAC,aAAa,EAAE,CAAC,iBAAiB,EAAE,MAAM,EAAE,SAAS,EAAE,iBAAiB,KAAK,OAAO,CAAC,IAAI,CAAC,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,GAAG,EAAE,iBAAiB,CAAC,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;mBAsCpS,iBAAiB;CAsCzC"}

package/dist/core/ProcessUtils.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const uuid_1 = require("uuid");
+/**
+ * static class mainly containing a method to start processes
+ */
+class ProcessUtils {
+    static async startProcess(subscribeFunc, clusterUrl, tenantName, projectName, processId, processInput, processInstanceId, startNodeId, token) {
+        let instanceId = processInstanceId ? processInstanceId : (0, uuid_1.v4)();
+        return new Promise(async (resolve, reject) => {
+            try {
+                // Another class/component is responsible for listening to processes' states and calling back when they finish
+                await subscribeFunc(instanceId, {
+                    onCallback: (callback) => {
+                        //TODO check redirect ?
+                    },
+                    onOver: (processResult) => {
+                        // The process has finished
+                        resolve(processResult);
+                    },
+                });
+                // Create a new process instance
+                await ProcessUtils.launchMainProcess(clusterUrl, tenantName, projectName, processId, processInput, instanceId, startNodeId, token);
+            }
+            catch (err) {
+                console.error(err);
+                let processResult = {
+                    isError: true,
+                    processInstanceId: instanceId,
+                    output: {},
+                    errorMessage: err.message
+                };
+                resolve(processResult);
+            }
+        });
+    }
+    static async launchMainProcess(clusterUrl, tenantName, projectName, processId, processInput, processInstanceId, startNodeId, token) {
+        console.log("launching main process");
+        let input = processInput ? processInput : {};
+        // We launch the process with an http request
+        let url = `${clusterUrl}/${projectName.toLowerCase()}/processes/${processId}/instances`;
+        let body = {
+            id: processInstanceId,
+            input: input,
+            startNode: startNodeId
+        };
+        let requestHeaders = new Headers();
+        requestHeaders.set('Content-Type', 'application/json');
+        if (token && token !== "") {
+            requestHeaders.set(`${tenantName}AccessToken`, token);
+        }
+        const response = await fetch(url, {
+            method: 'POST',
+            credentials: 'include', // forward auth cookiesbody
+            body: JSON.stringify(body),
+            headers: requestHeaders
+        });
+        if (!response.ok) {
+            // Something went wrong
+            let errorMessage = await response.text();
+            throw new Error(errorMessage);
+        }
+    }
+}
+exports.default = ProcessUtils;

package/dist/core/SignalR.d.ts

@@ -0,0 +1,30 @@
+import { IProcessCallbacks, ICodenotchSignal } from "../models/Misc";
+export declare class SignalR {
+    private _connection;
+    private _hubUrl;
+    private _accessToken;
+    private _signalCallbacks;
+    private _processCallbacks;
+    private _inactivityTimer;
+    private _unsubscribeTimers;
+    private _isConnecting;
+    private _pendingConnectionPromises;
+    private _keepAlive;
+    constructor(clusterUrl: string, serviceName: string, keepAlive: boolean, accessToken?: string);
+    connect(): Promise<void>;
+    private resolvePendingRequests;
+    private rejectPendingRequests;
+    private ensureConnected;
+    private onSignalReceived;
+    private getSignalPaths;
+    private onProcessCallbackReceived;
+    private onProcessOverReceived;
+    subscribeToProcessInstance(processInstanceId: string, callbacks: IProcessCallbacks): Promise<void>;
+    subscribeToSignal(signalId: string, callback: (signal: ICodenotchSignal) => void): Promise<() => Promise<void>>;
+    unsubscribeFromSignal(signalId: string, subscriptionId: string): Promise<void>;
+    private unsubscribeFromServerIfNoMoreSubscriptions;
+    private unsubscribeSignalServer;
+    private disconnectIfInactive;
+    disconnect(): void;
+}
+//# sourceMappingURL=SignalR.d.ts.map

package/dist/core/SignalR.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SignalR.d.ts","sourceRoot":"","sources":["../../src/core/SignalR.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAkB,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAIrF,qBAAa,OAAO;IAEhB,OAAO,CAAC,WAAW,CAA+B;IAClD,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,YAAY,CAAqB;IAIzC,OAAO,CAAC,gBAAgB,CAAwF;IAGhH,OAAO,CAAC,iBAAiB,CAAmD;IAE5E,OAAO,CAAC,gBAAgB,CAAwB;IAChD,OAAO,CAAC,kBAAkB,CAA4C;IAEtE,OAAO,CAAC,aAAa,CAAkB;IACvC,OAAO,CAAC,0BAA0B,CAAsE;IAGxG,OAAO,CAAC,UAAU,CAAU;gBAET,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,WAAW,CAAC,EAAE,MAAM;IAY9F,OAAO;IAmEb,OAAO,CAAC,sBAAsB;IAa9B,OAAO,CAAC,qBAAqB;YAaf,eAAe;IA6B7B,OAAO,CAAC,gBAAgB;IAqCxB,OAAO,CAAC,cAAc;IAsBtB,OAAO,CAAC,yBAAyB;IASjC,OAAO,CAAC,qBAAqB;IAcvB,0BAA0B,CAAC,iBAAiB,EAAE,MAAM,EAAE,SAAS,EAAE,iBAAiB;IAuBlF,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,MAAM,EAAE,gBAAgB,KAAK,IAAI,GAAG,OAAO,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IA4C/G,qBAAqB,CAAC,QAAQ,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM;IAkBpE,OAAO,CAAC,0CAA0C;YAYpC,uBAAuB;IAOrC,OAAO,CAAC,oBAAoB;IAarB,UAAU,IAAI,IAAI;CAY5B"}

package/dist/core/SignalR.js

@@ -0,0 +1,245 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignalR = void 0;
+const signalr_1 = require("@microsoft/signalr");
+const uuid_1 = require("uuid");
+class SignalR {
+    constructor(clusterUrl, serviceName, keepAlive, accessToken) {
+        this._unsubscribeTimers = {};
+        this._isConnecting = false;
+        this._pendingConnectionPromises = [];
+        this._hubUrl = `${clusterUrl}/${serviceName}/exec`;
+        this._accessToken = accessToken;
+        this._connection = null;
+        this._signalCallbacks = {};
+        this._processCallbacks = {};
+        this._inactivityTimer = null;
+        this._keepAlive = keepAlive;
+    }
+    async connect() {
+        console.log(`SignalR establishing connection...`);
+        this._isConnecting = true;
+        // Here we inject the access token if defined
+        let options = this._accessToken ? { accessTokenFactory: () => this._accessToken } : {};
+        // Skip negotiation and only use websockets
+        // This allows us to have multiple SignalR server without sticky sessions
+        // But it won't work in the rare cases where websockets are not supported
+        options.skipNegotiation = true;
+        options.transport = signalr_1.HttpTransportType.WebSockets;
+        //TODO if the server has multi instances, and the one we are connected fails, do sticky sessions prevent us from connecting to a healthy instance ?
+        this._connection = new signalr_1.HubConnectionBuilder()
+            .withUrl(this._hubUrl, options)
+            .withAutomaticReconnect([0, 1000, 3000, 5000, 10000, 30000, 60000, 90000]) // If the server is a single instance and decide to change node, it might take a little while
+            .configureLogging(signalr_1.LogLevel.Error)
+            .build();
+        this._connection.off("ReceiveSignal");
+        this._connection.off("ReceiveLog");
+        this._connection.off("ReceiveCallback");
+        this._connection.off("ReceiveProcessOver");
+        // On Signal
+        this._connection.on("ReceiveSignal", (signal) => this.onSignalReceived(signal));
+        // On log
+        this._connection.on("ReceiveLog", (log) => {
+            console.log(log);
+        });
+        // On callback received from process
+        //TODO only used to set wec content and redirect, do we still need those ?
+        this._connection.on("ReceiveCallback", (callback) => this.onProcessCallbackReceived(callback));
+        // On process completed
+        this._connection.on("ReceiveProcessOver", (processResult) => this.onProcessOverReceived(processResult));
+        this._connection.onclose((error) => console.log(`disconnected: ${error ? error.message : "no error"}`));
+        this._connection.onreconnected(() => this.resolvePendingRequests());
+        try {
+            await this._connection.start();
+            console.log(`SignalR connection established`);
+            this.resolvePendingRequests();
+            this._isConnecting = false;
+        }
+        catch (err) {
+            console.log(`SignalR connection error: ${err}`);
+            this.rejectPendingRequests(err);
+            this._isConnecting = false;
+        }
+    }
+    resolvePendingRequests() {
+        if (this._pendingConnectionPromises.length > 0) {
+            console.log(`Resolving ${this._pendingConnectionPromises.length} pending connection promises`);
+        }
+        for (let p of this._pendingConnectionPromises) {
+            p?.resolve();
+        }
+    }
+    rejectPendingRequests(error) {
+        if (this._pendingConnectionPromises.length > 0) {
+            console.log(`Rejecting ${this._pendingConnectionPromises.length} pending connection promises`);
+        }
+        for (let p of this._pendingConnectionPromises) {
+            p?.reject(error);
+        }
+    }
+    async ensureConnected() {
+        if (this._inactivityTimer) {
+            // cancel disconnection
+            clearTimeout(this._inactivityTimer);
+            this._inactivityTimer = null;
+        }
+        if (this._connection && this._connection.state === signalr_1.HubConnectionState.Connected) {
+            return Promise.resolve();
+        }
+        console.log(`SignalR not currently connected, waiting on connection...`);
+        const connectionPromise = new Promise((resolve, reject) => {
+            this._pendingConnectionPromises.push({ resolve, reject });
+        });
+        if (!this._isConnecting) {
+            this.connect();
+        }
+        // Return a promise that will resolve when the connection is established
+        return connectionPromise;
+    }
+    onSignalReceived(signal) {
+        try {
+            console.log(`Received signal '${signal.signalId}'`);
+            console.log(signal);
+            // parse the eventual data in the signal
+            if (signal.data) {
+                try {
+                    signal.data = JSON.parse(signal.data);
+                }
+                catch {
+                    // Data is not json but might still be valid
+                }
+            }
+            // If signal id contains multiple paths, trigger each one
+            var signalPaths = this.getSignalPaths(signal.signalId);
+            for (let p of signalPaths) {
+                if (this._signalCallbacks[p]) {
+                    for (let callback of Object.values(this._signalCallbacks[p])) {
+                        callback(signal);
+                    }
+                }
+            }
+        }
+        catch (ex) {
+            console.log(`An exception occured during 'ReceiveSignal' callback:`);
+            console.log(ex);
+        }
+    }
+    getSignalPaths(signalId) {
+        // Signals can be segmented using '.', each segment corresponds to a more specific subject 
+        // Subscribers can subscribe to a very specific signal or to a more general topic
+        // eg. Signal ref : invoice.update.0000-1111-2222-3333, will be received by subscribers on:
+        //  -> 'invoice'
+        //  -> 'invoice.update'
+        //  -> 'invoice.update.0000-1111-2222-3333'
+        var signalPaths = [];
+        if (!signalId || signalId === '')
+            return signalPaths;
+        var segments = signalId.split('.');
+        for (let i = 0; i < segments.length; i++) {
+            signalPaths.push(segments.slice(0, i + 1).join('.')); // "path" from index 0 to i
+        }
+        return signalPaths;
+    }
+    onProcessCallbackReceived(callback) {
+        // Trigger the corresponding callback (set in ProcessUtils before launching the process)
+        if (this._processCallbacks[callback.processInstanceId]) {
+            this._processCallbacks[callback.processInstanceId].onCallback(callback);
+        }
+    }
+    onProcessOverReceived(processResult) {
+        // Trigger the corresponding callback (set in ProcessUtils before launching the process)
+        if (this._processCallbacks[processResult.processInstanceId]) {
+            this._processCallbacks[processResult.processInstanceId].onOver(processResult);
+            // Clean it, now that the process is over we should not receive anymore callbacks
+            delete this._processCallbacks[processResult.processInstanceId];
+            this.disconnectIfInactive();
+        }
+    }
+    async subscribeToProcessInstance(processInstanceId, callbacks) {
+        if (this._processCallbacks[processInstanceId]) {
+            // Already subscribed
+            return;
+        }
+        await this.ensureConnected();
+        try {
+            await this._connection.invoke("SubscribeToInstanceEvents", processInstanceId);
+            // Setup callbacks
+            this._processCallbacks[processInstanceId] = callbacks;
+        }
+        catch (err) {
+            console.error(`Couldn't subscribe to process '${processInstanceId}', : ${err}`);
+        }
+    }
+    async subscribeToSignal(signalId, callback) {
+        console.log(`subscribeToSignal: signalId:${signalId}`);
+        if (!signalId || signalId === "")
+            return () => Promise.resolve();
+        await this.ensureConnected();
+        if (this._unsubscribeTimers[signalId]) {
+            // cancel eventual unsubscription
+            clearTimeout(this._unsubscribeTimers[signalId]);
+            delete this._unsubscribeTimers[signalId];
+        }
+        if (!this._signalCallbacks[signalId]) {
+            // Create the subscription
+            try {
+                await this._connection.invoke("SubscribeToSignal", signalId);
+                // Remember which signals we are subscribed so we don't subscribe twice
+                if (!this._signalCallbacks[signalId]) {
+                    this._signalCallbacks[signalId] = {};
+                }
+            }
+            catch (err) {
+                throw `Couldn't subscribe to signal '${signalId}', : ${err}`;
+            }
+        }
+        // Generate a new id to keep track of each subscription
+        let subscriptionId = (0, uuid_1.v4)();
+        this._signalCallbacks[signalId][subscriptionId] = callback;
+        // Return the unsubscribe function
+        return async () => await this.unsubscribeFromSignal(signalId, subscriptionId);
+    }
+    async unsubscribeFromSignal(signalId, subscriptionId) {
+        console.log(`unsubscribeFromSignal: signalId:${signalId}, subscriptionId:${subscriptionId}`);
+        if (!this._signalCallbacks[signalId]) {
+            return;
+        }
+        delete this._signalCallbacks[signalId][subscriptionId];
+        // From this point we won't send events to the component who just unsubscribed, but we are still subscribed to the signal on the server so we'll recieve new signals
+        this.unsubscribeFromServerIfNoMoreSubscriptions(signalId);
+        // If no more subscriptions, we can disconnect from the server
+        this.disconnectIfInactive();
+    }
+    unsubscribeFromServerIfNoMoreSubscriptions(signalId) {
+        if (Object.keys(this._signalCallbacks[signalId]).length === 0) {
+            delete this._signalCallbacks[signalId];
+            // No more subscriptions for this signal, we can unsubscribe from the server
+            // but in order to not send too many requests, we will wait a little bit before actually unsubscribing, the client might come back to the tab that need this signal in a few seconds
+            this._unsubscribeTimers[signalId] = setTimeout(() => this.unsubscribeSignalServer(signalId), 1 * 60 * 1000);
+        }
+    }
+    async unsubscribeSignalServer(signalId) {
+        console.log(`unsubscribeSignalServer: signalId:${signalId}`);
+        await this._connection.invoke("UnsubscribeFromSignal", signalId);
+    }
+    disconnectIfInactive() {
+        if (this._keepAlive)
+            return;
+        if (Object.keys(this._signalCallbacks).length === 0 && Object.keys(this._processCallbacks).length === 0) {
+            // No more subscriptions, disconnect from the server after a little while (5 minutes) to save resources
+            this._inactivityTimer = setTimeout(() => this.disconnect(), 5 * 60 * 1000);
+            console.log("SignalR has no more active subscriptions, will disconnect in 5 minutes...");
+        }
+    }
+    disconnect() {
+        if (this._connection) {
+            this._connection.off("ReceiveCallback");
+            this._connection.off("ReceiveProcessOver");
+            this._connection.off("ReceiveSignal");
+            this._connection.off("ReceiveLog");
+            this._connection.stop();
+            this._connection = null;
+        }
+    }
+}
+exports.SignalR = SignalR;

package/dist/index.d.ts

@@ -1,51 +1,18 @@
-export interface ICodenotchEnv {
-    clusterUrl?: string;
-    serviceName?: string;
-    tenantName?: string;
-    accessToken?: string;
-    baseUrl?: string;
-    i18n?: {
-        [language: string]: {
-            [key: string]: string;
-        };
-    };
-    currentLanguage?: string;
-    [key: string]: any;
-}
-export interface ICodenotchApi {
-    ENV: ICodenotchEnv;
-    requestSioql: (sioql: string, verbose?: boolean) => Promise<any>;
-    startProcess: (processName: string) => Promise<{
-        success: boolean;
-    }>;
-    onSignal: (signalId: string, callback: () => void) => {
-        dispose: () => void;
-    };
-    showDialog: (node: JSX.Element) => ICodenotchDialog;
-}
-export interface ICodenotchDialog {
-    id: string;
-    close: () => void;
-}
-declare const CODENOTCH_ENV: ICodenotchEnv;
-/**
- * Parse URL parameters and return them as an object
- * @returns {Object} An object containing the URL parameters as key-value pairs
- */
-export declare function parseUrlParams(): {
-    [key: string]: string;
-};
+import { ICodenotchApi, ICodenotchDialog, ICodenotchEnv } from "./models/Codenotch";
+import { Auml } from "./components/Auml";
+import CodeEditor from "./components/CodeEditor";
+declare const env: ICodenotchEnv;
 /**
  * Setup Codenotch environment from the given object
  * @param env An object containing the Codenotch environment variables as key-value pairs. This can be obtained from URL parameters or any other source.
  * @returns {void}
  */
-export declare function setupCodenotchEnv(env: any): void;
-export declare function i18n(key: string, ...args: any[]): string;
+declare function setupCodenotchEnv(env: any): void;
+declare function i18n(key: string, ...args: any[]): string;
 /**
  * Return Codenotch API
  * @returns {ICodenotchApi} Codenotch API
  */
-export declare function useCodenotch(): ICodenotchApi;
-export { CODENOTCH_ENV };
+declare function useCodenotch(): ICodenotchApi;
+export { env as CODENOTCH_ENV, i18n, useCodenotch, setupCodenotchEnv, ICodenotchEnv, ICodenotchApi, ICodenotchDialog, Auml, CodeEditor };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,aAAa;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE;QAAE,CAAC,QAAQ,EAAE,MAAM,GAAG;YAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;SAAE,CAAA;KAAE,CAAC;IACzD,eAAe,CAAC,EAAE,MAAM,CAAC;IAEzB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACtB;AAED,MAAM,WAAW,aAAa;IAC1B,GAAG,EAAE,aAAa,CAAC;IACnB,YAAY,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;IACjE,YAAY,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IACrE,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,IAAI,KAAK;QAAE,OAAO,EAAE,MAAM,IAAI,CAAA;KAAE,CAAC;IAC9E,UAAU,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,OAAO,KAAK,gBAAgB,CAAC;CACvD;AAED,MAAM,WAAW,gBAAgB;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,IAAI,CAAC;CACrB;AAED,QAAA,MAAM,aAAa,EAAE,aAAkB,CAAC;AAExC;;;GAGG;AACH,wBAAgB,cAAc,IAAI;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,CAW1D;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,GAAG,GAAG,IAAI,CA4ChD;AAED,wBAAgB,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,MAAM,CAoCxD;AAED;;;GAGG;AACH,wBAAgB,YAAY,IAAI,aAAa,CAwH5C;AAGD,OAAO,EAAE,aAAa,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAEpF,OAAO,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AACzC,OAAO,UAAU,MAAM,yBAAyB,CAAC;AAIjD,QAAA,MAAM,GAAG,EAAE,aAAkB,CAAC;AAO9B;;;;GAIG;AACH,iBAAS,iBAAiB,CAAC,GAAG,EAAE,GAAG,GAAG,IAAI,CAgDzC;AAED,iBAAS,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,MAAM,CAoCjD;AAED;;;GAGG;AACH,iBAAS,YAAY,IAAI,aAAa,CAsKrC;AAED,OAAO,EACH,GAAG,IAAI,aAAa,EACpB,IAAI,EACJ,YAAY,EACZ,iBAAiB,EACjB,aAAa,EACb,aAAa,EACb,gBAAgB,EAChB,IAAI,EACJ,UAAU,EACb,CAAC"}

package/dist/index.js

@@ -3,30 +3,24 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CODENOTCH_ENV = void 0;
-exports.parseUrlParams = parseUrlParams;
-exports.setupCodenotchEnv = setupCodenotchEnv;
+exports.CodeEditor = exports.Auml = exports.CODENOTCH_ENV = void 0;
 exports.i18n = i18n;
 exports.useCodenotch = useCodenotch;
+exports.setupCodenotchEnv = setupCodenotchEnv;
 const react_dom_1 = __importDefault(require("react-dom"));
-const CODENOTCH_ENV = {};
-exports.CODENOTCH_ENV = CODENOTCH_ENV;
-/**
- * Parse URL parameters and return them as an object
- * @returns {Object} An object containing the URL parameters as key-value pairs
- */
-function parseUrlParams() {
-    let result = {};
-    if (typeof window !== 'undefined') {
-        const params = new URL(window.location.href).searchParams;
-        params.forEach((value, key) => {
-            if (result[key] === undefined) {
-                result[key] = value;
-            }
-        });
-    }
-    return result;
-}
+const SignalR_1 = require("./core/SignalR");
+const ProcessUtils_1 = __importDefault(require("./core/ProcessUtils"));
+const uuid_1 = require("uuid");
+const Auml_1 = require("./components/Auml");
+Object.defineProperty(exports, "Auml", { enumerable: true, get: function () { return Auml_1.Auml; } });
+const CodeEditor_1 = __importDefault(require("./components/CodeEditor"));
+exports.CodeEditor = CodeEditor_1.default;
+var signalR = undefined;
+const env = {};
+exports.CODENOTCH_ENV = env;
+const MISSING_CLUSTER_URL_ERROR = "Codenotch cluster URL is not defined. Please set it in the Codenotch configuration.";
+const MISSING_SERVICE_NAME_ERROR = "Codenotch service name is not defined. Please set it in the Codenotch configuration.";
+const MISSING_TENANT_NAME_ERROR = "Codenotch tenant name is not defined. Please set it in the Codenotch configuration.";
 /**
  * Setup Codenotch environment from the given object
  * @param env An object containing the Codenotch environment variables as key-value pairs. This can be obtained from URL parameters or any other source.
@@ -56,37 +50,40 @@ function setupCodenotchEnv(env) {
                     console.warn(`Codenotch environment variable ${key} is not a valid JSON string. Using raw value.`);
                 }
             }
-            CODENOTCH_ENV.i18n = CODENOTCH_ENV.i18n ?? {};
-            CODENOTCH_ENV.i18n[language] = CODENOTCH_ENV.i18n[language] ?? {};
-            CODENOTCH_ENV.i18n[language][keyName] = keyValue;
+            env.i18n = env.i18n ?? {};
+            env.i18n[language] = env.i18n[language] ?? {};
+            env.i18n[language][keyName] = keyValue;
         }
         else {
-            CODENOTCH_ENV[key] = env[key];
+            env[key] = env[key];
             console.log(`Codenotch environment variable ${key} set to ${env[key]}`);
         }
     });
-    if (CODENOTCH_ENV.currentLanguage === undefined) {
+    if (env.language === undefined) {
         // If current language is not defined, we set it to the first language found in i18n
         if (i18nLanguages.size > 0) {
-            CODENOTCH_ENV.currentLanguage = Array.from(i18nLanguages)[0];
-            console.log(`Codenotch current language set to ${CODENOTCH_ENV.currentLanguage}`);
+            env.language = Array.from(i18nLanguages)[0];
+            console.log(`Codenotch current language set to ${env.language}`);
         }
     }
+    if (env.clusterUrl && env.serviceName) {
+        signalR = new SignalR_1.SignalR(env.clusterUrl, env.serviceName, false, env.accessToken);
+    }
 }
 function i18n(key, ...args) {
     try {
-        if (CODENOTCH_ENV.i18n === undefined || Object.keys(CODENOTCH_ENV.i18n).length === 0) {
+        if (env.i18n === undefined || Object.keys(env.i18n).length === 0) {
             console.warn("Codenotch i18n is not defined. Please set it in the Codenotch configuration.");
             return key;
         }
-        let language = CODENOTCH_ENV.currentLanguage ?? "en";
-        let isLanguageExists = CODENOTCH_ENV.i18n[language] !== undefined;
+        let language = env.language ?? "en";
+        let isLanguageExists = env.i18n[language] !== undefined;
         if (isLanguageExists === false) {
-            let fallbackLanguage = Object.keys(CODENOTCH_ENV.i18n)[0];
+            let fallbackLanguage = Object.keys(env.i18n)[0];
             console.warn(`Codenotch i18n language ${language} is not defined. Falling back to ${fallbackLanguage}. Please set the correct language in the Codenotch configuration.`);
             language = fallbackLanguage;
         }
-        let dico = CODENOTCH_ENV.i18n[language];
+        let dico = env.i18n[language];
         let value = dico[key];
         if (typeof value !== "string") {
             console.warn(`Codenotch i18n key ${key} is not defined for language ${language}. Please set it in the Codenotch configuration.`);
@@ -111,53 +108,76 @@ function i18n(key, ...args) {
  */
 function useCodenotch() {
     return {
-        ENV: CODENOTCH_ENV,
-        requestSioql: async (sioql, verbose) => {
-            if (CODENOTCH_ENV.clusterUrl === undefined) {
-                throw new Error("Codenotch cluster URL is not defined. Please set it in the Codenotch configuration.");
-            }
-            if (CODENOTCH_ENV.serviceName === undefined) {
-                throw new Error("Codenotch service name is not defined. Please set it in the Codenotch configuration.");
-            }
-            let url = `${CODENOTCH_ENV.clusterUrl}/${CODENOTCH_ENV.serviceName}/sioql`;
-            if (verbose) {
-                url += "?v=true";
+        env: env,
+        uuid: () => (0, uuid_1.v4)(),
+        getProjectFileUrl: (relativePath) => {
+            if (env.clusterUrl === undefined)
+                throw new Error(MISSING_CLUSTER_URL_ERROR);
+            if (env.serviceName === undefined)
+                throw new Error(MISSING_SERVICE_NAME_ERROR);
+            relativePath = relativePath.replace(/\\/g, "/");
+            if (relativePath.startsWith("/"))
+                relativePath = relativePath.substring(1);
+            let url = `${env.clusterUrl}/${env.serviceName}/project/file?name=""&path=${encodeURIComponent(relativePath)}`;
+            return url;
+        },
+        getProjectFile: async (relativePath) => {
+            let url = useCodenotch().getProjectFileUrl(relativePath);
+            let resp = await fetch(url);
+            if (resp.status.toString().startsWith('2') === false) {
+                throw new Error(`Failed to fetch file content: ${resp.status} ${resp.statusText}`);
             }
+            let content = await resp.text();
+            return content;
+        },
+        requestSioql: async (sioql, verbose) => {
+            if (env.clusterUrl === undefined)
+                throw new Error(MISSING_CLUSTER_URL_ERROR);
+            if (env.serviceName === undefined)
+                throw new Error(MISSING_SERVICE_NAME_ERROR);
             const request = {
                 method: 'POST',
                 mode: 'cors',
                 credentials: 'same-origin',
-                headers: {
-                    'Content-Type': 'application/json'
-                }
+                headers: { 'Content-Type': 'application/json' },
+                body: `"${sioql.replace(/\"/g, '\\\"')}"`
             };
-            if (CODENOTCH_ENV.accessToken && CODENOTCH_ENV.accessToken !== "") {
-                if (CODENOTCH_ENV.tenantName === undefined) {
-                    throw new Error("Codenotch tenant name is not defined. Please set it in the Codenotch configuration.");
-                }
+            if (`${env.accessToken ?? ''}`.trim() !== "") {
+                if (env.tenantName === undefined)
+                    throw new Error(MISSING_TENANT_NAME_ERROR);
                 request.headers = {
-                    ...request.headers,
-                    [`${CODENOTCH_ENV.tenantName}AccessToken`]: CODENOTCH_ENV.accessToken
+                    ...request.headers, [`${env.tenantName}AccessToken`]: env.accessToken
                 };
             }
-            request.body = `"${sioql.replace(/\"/g, '\\\"')}"`;
-            const response = await fetch(url, request);
+            const response = await fetch(`${env.clusterUrl}/${env.serviceName}/sioql${verbose ? "?v=true" : ""}`, request);
             if (!response.ok) {
                 const error = await response.text();
                 throw new Error(error);
             }
             return await response.json();
         },
-        startProcess: async (processName) => {
-            return { success: true };
+        startProcess: async (processName, inputs, startNodeId) => {
+            if (env.clusterUrl === undefined)
+                throw new Error(MISSING_CLUSTER_URL_ERROR);
+            if (env.serviceName === undefined)
+                throw new Error(MISSING_SERVICE_NAME_ERROR);
+            if (env.tenantName === undefined)
+                throw new Error(MISSING_TENANT_NAME_ERROR);
+            if (signalR === undefined)
+                throw new Error("SignalR not available. Cannot start process.");
+            return ProcessUtils_1.default.startProcess((processInstanceId, callbacks) => signalR.subscribeToProcessInstance(processInstanceId, callbacks), env.clusterUrl, env.tenantName, env.serviceName, processName, inputs, undefined, startNodeId ?? 'start', env.accessToken);
         },
-        onSignal: (signalId, callback) => {
-            console.log(`Listening to signal ${signalId}`);
-            return {
-                dispose: () => {
-                    console.log(`Stopped listening to signal ${signalId}`);
-                }
-            };
+        getUrlParams: () => {
+            let result = {};
+            if (typeof window !== 'undefined') {
+                const params = new URL(window.location.href).searchParams;
+                params.forEach((value, key) => {
+                    if (result[key] === undefined) {
+                        result[key] = value;
+                    }
+                });
+            }
+            return result;
         },
         showDialog: (node) => {
             let dialogId = "codenotch-dialog-" + Math.random().toString(36).substring(2, 9);
@@ -210,6 +230,36 @@ function useCodenotch() {
                 dialogElement.showModal();
             });
             return result;
+        },
+        listenSignal: async (signalId, callback) => {
+            if (!signalR) {
+                throw new Error("SignalR not available. Cannot listen to signal.");
+            }
+            let unsubscribeFunc = await signalR.subscribeToSignal(signalId, callback);
+            return {
+                dispose: () => {
+                    unsubscribeFunc();
+                }
+            };
+        },
+        setTheme: (theme) => {
+            if (env.theme === theme)
+                return;
+            if (env.theme)
+                document.documentElement.classList.remove(env.theme);
+            env.theme = theme;
+            document.documentElement.classList.add(theme);
+        },
+        setLanguage: (lang) => {
+            if (env.language === lang)
+                return;
+            env.language = lang;
+        },
+        getLanguage: () => {
+            return env.language;
+        },
+        getTheme: () => {
+            return env.theme;
         }
     };
 }

package/dist/models/Codenotch.d.ts

@@ -0,0 +1,38 @@
+import { ICodenotchSignal, IDisposable, IProcessResult } from "./Misc";
+export interface ICodenotchEnv {
+    appName?: string;
+    clusterUrl?: string;
+    serviceName?: string;
+    tenantName?: string;
+    accessToken?: string;
+    baseUrl?: string;
+    i18n?: {
+        [language: string]: {
+            [key: string]: string;
+        };
+    };
+    language?: string;
+    theme?: 'light' | 'dark';
+}
+export interface ICodenotchApi {
+    readonly env: ICodenotchEnv;
+    readonly requestSioql: (sioql: string, verbose?: boolean) => Promise<any>;
+    readonly startProcess: (processName: string, inputs: any, startNodeId?: string) => Promise<IProcessResult>;
+    readonly showDialog: (node: JSX.Element) => ICodenotchDialog;
+    readonly getProjectFile: (relativePath: string) => Promise<string | undefined>;
+    readonly getProjectFileUrl: (relativePath: string) => string;
+    readonly listenSignal: (signalId: string, callback: (data: ICodenotchSignal) => void) => Promise<IDisposable>;
+    readonly setTheme: (theme: 'light' | 'dark') => void;
+    readonly getTheme: () => 'light' | 'dark' | undefined;
+    readonly setLanguage: (lang: string) => void;
+    readonly getLanguage: () => string | undefined;
+    readonly getUrlParams: () => {
+        [key: string]: string;
+    };
+    readonly uuid: () => string;
+}
+export interface ICodenotchDialog {
+    id: string;
+    close: () => void;
+}
+//# sourceMappingURL=Codenotch.d.ts.map

package/dist/models/Codenotch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Codenotch.d.ts","sourceRoot":"","sources":["../../src/models/Codenotch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAC;AAEvE,MAAM,WAAW,aAAa;IAC1B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE;QAAE,CAAC,QAAQ,EAAE,MAAM,GAAG;YAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;SAAE,CAAA;KAAE,CAAC;IACzD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,aAAa;IAC1B,QAAQ,CAAC,GAAG,EAAE,aAAa,CAAC;IAE5B,QAAQ,CAAC,YAAY,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;IAC1E,QAAQ,CAAC,YAAY,EAAE,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,WAAW,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,cAAc,CAAC,CAAC;IAC3G,QAAQ,CAAC,UAAU,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,OAAO,KAAK,gBAAgB,CAAC;IAC7D,QAAQ,CAAC,cAAc,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IAC/E,QAAQ,CAAC,iBAAiB,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,MAAM,CAAC;IAC7D,QAAQ,CAAC,YAAY,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE,gBAAgB,KAAK,IAAI,KAAK,OAAO,CAAC,WAAW,CAAC,CAAC;IAC9G,QAAQ,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,KAAK,IAAI,CAAC;IACrD,QAAQ,CAAC,QAAQ,EAAE,MAAM,OAAO,GAAG,MAAM,GAAG,SAAS,CAAC;IACtD,QAAQ,CAAC,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC7C,QAAQ,CAAC,WAAW,EAAE,MAAM,MAAM,GAAG,SAAS,CAAC;IAC/C,QAAQ,CAAC,YAAY,EAAE,MAAM;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;IACvD,QAAQ,CAAC,IAAI,EAAE,MAAM,MAAM,CAAC;CAC/B;AAED,MAAM,WAAW,gBAAgB;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,IAAI,CAAC;CACrB"}

package/dist/models/Codenotch.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/Misc.d.ts

@@ -0,0 +1,18 @@
+export interface IProcessCallbacks {
+    onOver: (processResult: IProcessResult) => void;
+    onCallback: (callback: any) => void;
+}
+export interface IProcessResult {
+    processInstanceId: string;
+    output: any;
+    isError: boolean;
+    errorMessage: string;
+}
+export interface ICodenotchSignal {
+    signalId: string;
+    data: any;
+}
+export interface IDisposable {
+    dispose: () => void;
+}
+//# sourceMappingURL=Misc.d.ts.map

package/dist/models/Misc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Misc.d.ts","sourceRoot":"","sources":["../../src/models/Misc.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,iBAAiB;IAE9B,MAAM,EAAE,CAAC,aAAa,EAAE,cAAc,KAAK,IAAI,CAAC;IAChD,UAAU,EAAC,CAAE,QAAQ,EAAE,GAAG,KAAK,IAAI,CAAA;CACtC;AAED,MAAM,WAAW,cAAc;IAE3B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,MAAM,EAAE,GAAG,CAAC;IACZ,OAAO,EAAE,OAAO,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,gBAAgB;IAE7B,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,GAAG,CAAC;CACb;AAED,MAAM,WAAW,WAAW;IACxB,OAAO,EAAE,MAAM,IAAI,CAAC;CACvB"}

package/dist/models/Misc.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "codenotch-react",
-    "version": "1.0.54",
+    "version": "1.0.56",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
     "author": "Codenotch SA",
@@ -14,13 +14,16 @@
         "dist/**/*"
     ],
     "dependencies": {
+        "@echino/echino.ui.core": "^0.13.128",
         "@echino/echino.ui.framework": "1.1.61",
-        "@echino/echino.ui.core": "^0.13.128"
+        "@microsoft/signalr": "^5.0.6",
+        "uuid": "^8.2.0"
     },
     "devDependencies": {
         "@types/node": "^25.3.2",
         "@types/react": "^16.14.69",
         "@types/react-dom": "^16.9.25",
+        "@types/uuid": "8.0.0",
         "react-dom": "^16.14.0",
         "typescript": "^5.9.3"
     },

package/dist/auml.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"auml.d.ts","sourceRoot":"","sources":["../src/auml.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,OAAO,EAAE,eAAe,EAAE,MAAM,0EAA0E,CAAC;AAS3G,UAAU,UAAU;IAChB,KAAK,EAAE,MAAM,CAAC;CACjB;AACD,UAAU,UAAU;IAChB,MAAM,EAAE,OAAO,CAAC;IAChB,gBAAgB,EAAE,OAAO,CAAC;CAC7B;AAED,qBAAa,IAAK,SAAQ,KAAK,CAAC,SAAS,CAAC,UAAU,EAAE,UAAU,CAAC;IAE7D,kBAAkB,EAAE,MAAM,CAAC,OAAO,GAAG,SAAS,CAAC;gBAEnC,KAAK,EAAE,UAAU;IAQ7B,iBAAiB;IAmCjB,oBAAoB;IAQpB,QAAQ,CAAC,CAAC,EAAE,eAAe;IAO3B,OAAO;IAYP,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,SAAS;IAclC,cAAc;;;IAMd,wBAAwB,IAAI,MAAM,GAAG,IAAI;IAoCzC,2BAA2B,CAAC,kBAAkB,EAAE,MAAM,GAAG,MAAM;IAO/D,QAAQ,CAAC,EAAE,EAAE,MAAM;IAmBnB,QAAQ,CAAC,KAAK,EAAE,MAAM;IAsBtB,MAAM;IAiDA,mBAAmB;CAqC5B"}