@jumoo/processing 17.4.2

package/dist/signalr/index.js

@@ -0,0 +1,2 @@
+export * from './types.js';
+export * from './signalr.context.js';

package/dist/signalr/signalr.context.d.ts

@@ -0,0 +1,24 @@
+import { UmbControllerBase } from '@umbraco-cms/backoffice/class-api';
+import { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
+import { UmbContextToken } from '@umbraco-cms/backoffice/context-api';
+import { ProcessingHubMessage } from '@jumoo/processing';
+export type ProcessingConnectionState = 'connecting' | 'connected' | 'reconnecting' | 'disconnected';
+export declare class ProcessingSignalRContext extends UmbControllerBase {
+    #private;
+    constructor(host: UmbControllerHost);
+    readonly message: import("rxjs").Observable<ProcessingHubMessage[]>;
+    readonly clientId: import("rxjs").Observable<string | null>;
+    readonly connectionState: import("rxjs").Observable<ProcessingConnectionState>;
+    startHub(token: string, methods: string[]): void;
+    hostConnected(): void;
+    hostDisconnected(): void;
+    messagesOf(method: string): import("rxjs").Observable<ProcessingHubMessage | undefined>;
+    /**
+     * @description the current SignalR connection id, kept in sync across reconnects.
+     * @deprecated kept for compatibility - prefer observing {@link clientId}, which carries the
+     * same value and updates whenever the connection id changes (e.g. after a reconnect).
+     */
+    getClientId(): string | null;
+}
+export default ProcessingSignalRContext;
+export declare const JUMOO_PROCESSING_SIGNALR_CONTEXT: UmbContextToken<ProcessingSignalRContext, ProcessingSignalRContext>;

package/dist/signalr/signalr.context.js

@@ -0,0 +1,99 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _ProcessingSignalRContext_instances, _ProcessingSignalRContext_connection, _ProcessingSignalRContext_messages, _ProcessingSignalRContext_clientId, _ProcessingSignalRContext_connectionState, _ProcessingSignalRContext_setupConnection;
+import { UmbControllerBase } from '@umbraco-cms/backoffice/class-api';
+import { UmbArrayState, UmbObjectState } from '@umbraco-cms/backoffice/observable-api';
+import { UmbContextToken } from '@umbraco-cms/backoffice/context-api';
+import * as signalR from '@jumoo/processing/external/signalr';
+const JUMOO_PROCESSING_HUB_PATH = '/umbraco/processinghub';
+export class ProcessingSignalRContext extends UmbControllerBase {
+    constructor(host) {
+        super(host);
+        _ProcessingSignalRContext_instances.add(this);
+        _ProcessingSignalRContext_connection.set(this, void 0);
+        _ProcessingSignalRContext_messages.set(this, new UmbArrayState([], (x) => x.method));
+        this.message = __classPrivateFieldGet(this, _ProcessingSignalRContext_messages, "f").asObservable();
+        _ProcessingSignalRContext_clientId.set(this, new UmbObjectState(null));
+        this.clientId = __classPrivateFieldGet(this, _ProcessingSignalRContext_clientId, "f").asObservable();
+        _ProcessingSignalRContext_connectionState.set(this, new UmbObjectState('connecting'));
+        this.connectionState = __classPrivateFieldGet(this, _ProcessingSignalRContext_connectionState, "f").asObservable();
+        this.provideContext(JUMOO_PROCESSING_SIGNALR_CONTEXT, this);
+    }
+    startHub(token, methods) {
+        __classPrivateFieldGet(this, _ProcessingSignalRContext_instances, "m", _ProcessingSignalRContext_setupConnection).call(this, JUMOO_PROCESSING_HUB_PATH, token, methods);
+    }
+    hostConnected() {
+        super.hostConnected();
+    }
+    hostDisconnected() {
+        super.hostDisconnected();
+        __classPrivateFieldGet(this, _ProcessingSignalRContext_connection, "f")?.stop().then(() => {
+            console.debug('signalr connection stopped');
+        });
+        __classPrivateFieldSet(this, _ProcessingSignalRContext_connection, undefined, "f");
+    }
+    messagesOf(method) {
+        return __classPrivateFieldGet(this, _ProcessingSignalRContext_messages, "f").asObservablePart((message) => message.find((x) => x.method === method));
+    }
+    /**
+     * @description the current SignalR connection id, kept in sync across reconnects.
+     * @deprecated kept for compatibility - prefer observing {@link clientId}, which carries the
+     * same value and updates whenever the connection id changes (e.g. after a reconnect).
+     */
+    getClientId() {
+        return __classPrivateFieldGet(this, _ProcessingSignalRContext_connection, "f")?.connectionId ?? null;
+    }
+}
+_ProcessingSignalRContext_connection = new WeakMap(), _ProcessingSignalRContext_messages = new WeakMap(), _ProcessingSignalRContext_clientId = new WeakMap(), _ProcessingSignalRContext_connectionState = new WeakMap(), _ProcessingSignalRContext_instances = new WeakSet(), _ProcessingSignalRContext_setupConnection = function _ProcessingSignalRContext_setupConnection(url, token, methods) {
+    __classPrivateFieldSet(this, _ProcessingSignalRContext_connection, new signalR.HubConnectionBuilder()
+        .withUrl(url, { accessTokenFactory: () => token })
+        .withAutomaticReconnect([0, 2000, 10000, 30000])
+        .configureLogging(signalR.LogLevel.None)
+        .build(), "f");
+    for (let i = 0; i < methods.length; i++) {
+        __classPrivateFieldGet(this, _ProcessingSignalRContext_connection, "f").on(methods[i], (message) => {
+            console.debug('message received:', methods[i], message);
+            __classPrivateFieldGet(this, _ProcessingSignalRContext_messages, "f").appendOne({
+                method: methods[i],
+                message: message,
+            });
+        });
+    }
+    // the connection id changes on every successful reconnect - that's the entire point of
+    // observing it here rather than reading getClientId() once. onreconnecting/onclose don't
+    // hand us a fresh id (there isn't one yet/any more), so we only update clientId itself in
+    // onreconnected and after the initial start() below.
+    __classPrivateFieldGet(this, _ProcessingSignalRContext_connection, "f").onreconnecting(() => {
+        console.debug('signalr reconnecting');
+        __classPrivateFieldGet(this, _ProcessingSignalRContext_connectionState, "f").setValue('reconnecting');
+    });
+    __classPrivateFieldGet(this, _ProcessingSignalRContext_connection, "f").onreconnected((connectionId) => {
+        console.debug('signalr reconnected', connectionId);
+        __classPrivateFieldGet(this, _ProcessingSignalRContext_connectionState, "f").setValue('connected');
+        __classPrivateFieldGet(this, _ProcessingSignalRContext_clientId, "f").setValue(connectionId ?? __classPrivateFieldGet(this, _ProcessingSignalRContext_connection, "f")?.connectionId ?? null);
+    });
+    __classPrivateFieldGet(this, _ProcessingSignalRContext_connection, "f").onclose(() => {
+        // automatic reconnect gives up once the retry-delay array above is exhausted (or the
+        // server rejected the reconnect outright) - surface that as 'disconnected' rather
+        // than leaving the last-known state showing, which would look like nothing is wrong.
+        console.debug('signalr connection closed');
+        __classPrivateFieldGet(this, _ProcessingSignalRContext_connectionState, "f").setValue('disconnected');
+        __classPrivateFieldGet(this, _ProcessingSignalRContext_clientId, "f").setValue(null);
+    });
+    __classPrivateFieldGet(this, _ProcessingSignalRContext_connection, "f").start().then(() => {
+        console.debug('signalr connection started');
+        __classPrivateFieldGet(this, _ProcessingSignalRContext_connectionState, "f").setValue('connected');
+        __classPrivateFieldGet(this, _ProcessingSignalRContext_clientId, "f").setValue(__classPrivateFieldGet(this, _ProcessingSignalRContext_connection, "f")?.connectionId ?? null);
+    });
+};
+export default ProcessingSignalRContext;
+export const JUMOO_PROCESSING_SIGNALR_CONTEXT = new UmbContextToken('JumooProcessingSignalRContext');

package/dist/signalr/types.d.ts

@@ -0,0 +1,12 @@
+import { PipelineState } from '../api';
+export interface ProcessingHubMessage {
+    method: string;
+    message: ProcessingMessage | PipelineState;
+}
+export interface ProcessingMessage {
+    title: string;
+    message?: string;
+    progress: number;
+    completed: boolean;
+    error: boolean;
+}

package/dist/signalr/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,51 @@
+{
+	"name": "@jumoo/processing",
+	"licence": "custom",
+	"version": "17.4.2",
+	"type": "module",
+	"description": "Jumoo processing library",
+	"exports": {
+		".": "./dist/index.js",
+		"./pipeline": "./dist/pipeline/index.js",
+		"./signalr": "./dist/signalr/index.js",
+		"./api": "./dist/api/index.js"
+	},
+	"files": [
+		"./dist/**/*"
+	],
+	"author": {
+		"name": "Jumoo",
+		"email": "info@jumoo.co.uk",
+		"url": "https://jumoo.co.uk"
+	},
+	"publishConfig": {},
+	"scripts": {
+		"client:build": "tsc --project ./tsconfig.dist.json",
+		"client:pack": "npm pack --pack-destination ./pack",
+		"client:publish": "npm publish -tag next",
+		"client:make": "npm run client:build && npm run client:pack && npm run client:publish",
+		"client:link": "npm link",
+		"generate": "openapi-ts",
+		"lint": "eslint .",
+		"lint:fix": "eslint . --fix",
+		"format:fix": "npm run format -- --write",
+		"format": "prettier \"src/**/*.ts\" --check",
+		"build": "tsc && vite build",
+		"watch": "vite build --watch",
+		"make": "npm run build && npm run client:make"
+	},
+	"devDependencies": {
+		"@eslint/js": "^10.0.1",
+		"@hey-api/openapi-ts": "^0.95.0",
+		"@microsoft/signalr": "^10.0.0",
+		"@umbraco-cms/backoffice": "^17.3.0",
+		"eslint": "^10.2.0",
+		"globals": "^17.8.0",
+		"lit": "^3.3.2",
+		"prettier": "^3.8.2",
+		"typescript": "^6.0.2",
+		"typescript-eslint": "^8.65.0",
+		"vite": "^8.0.8",
+		"vite-plugin-dts": "^4.5.4"
+	}
+}