@jumoo/processing 17.4.2

package/dist/pipeline/modal/pipeline-modal.token.d.ts

@@ -0,0 +1,39 @@
+import { ProcessingOptions } from '@jumoo/processing';
+import { UmbModalToken } from '@umbraco-cms/backoffice/modal';
+export type JumooProcessingModalData = {
+    headline: string;
+    description?: string;
+    progressLabel?: string;
+    closeLabel?: string;
+    processor: string;
+    strategy: string;
+    options: ProcessingOptions;
+    debug?: boolean;
+    width?: number;
+    height?: number;
+};
+export type JumooProcessingModalResult = {
+    success: boolean;
+};
+export type JumooProcessingModalInfo = {
+    headline: string;
+    progressLabel?: string;
+    closeLabel?: string;
+};
+export declare const JUMOO_PROCESSING_MODAL_ALIAS = "jumoo-processing-modal";
+/**
+ * @description simple process modal open as a dialog
+ */
+export declare const JUMOO_PROCESSING_DIALOG_MODAL: UmbModalToken<JumooProcessingModalData, JumooProcessingModalResult>;
+/**
+ * @description simple process modal open as a sidebar
+ */
+export declare const JUMOO_PROCESSING_SIDEBAR_MODAL: UmbModalToken<JumooProcessingModalData, JumooProcessingModalResult>;
+/**
+ * @description simple process modal open as a sidebar
+ */
+export declare const JUMOO_PROCESSING_SIDEBAR_MEDIUM_MODAL: UmbModalToken<JumooProcessingModalData, JumooProcessingModalResult>;
+/**
+ * @description simple process modal open as a sidebar
+ */
+export declare const JUMOO_PROCESSING_SIDEBAR_LARGE_MODAL: UmbModalToken<JumooProcessingModalData, JumooProcessingModalResult>;

package/dist/pipeline/modal/pipeline-modal.token.js

@@ -0,0 +1,38 @@
+import { UmbModalToken } from '@umbraco-cms/backoffice/modal';
+export const JUMOO_PROCESSING_MODAL_ALIAS = 'jumoo-processing-modal';
+/**
+ * @description simple process modal open as a dialog
+ */
+export const JUMOO_PROCESSING_DIALOG_MODAL = new UmbModalToken(JUMOO_PROCESSING_MODAL_ALIAS, {
+    modal: {
+        size: 'small',
+        type: 'dialog',
+    },
+});
+/**
+ * @description simple process modal open as a sidebar
+ */
+export const JUMOO_PROCESSING_SIDEBAR_MODAL = new UmbModalToken(JUMOO_PROCESSING_MODAL_ALIAS, {
+    modal: {
+        size: 'small',
+        type: 'sidebar',
+    },
+});
+/**
+ * @description simple process modal open as a sidebar
+ */
+export const JUMOO_PROCESSING_SIDEBAR_MEDIUM_MODAL = new UmbModalToken(JUMOO_PROCESSING_MODAL_ALIAS, {
+    modal: {
+        size: 'medium',
+        type: 'sidebar',
+    },
+});
+/**
+ * @description simple process modal open as a sidebar
+ */
+export const JUMOO_PROCESSING_SIDEBAR_LARGE_MODAL = new UmbModalToken(JUMOO_PROCESSING_MODAL_ALIAS, {
+    modal: {
+        size: 'large',
+        type: 'sidebar',
+    },
+});

package/dist/pipeline/pipeline.context.d.ts

@@ -0,0 +1,53 @@
+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 { PipelineState, ProcessingMessage, ProcessingOptions, ProcessingResults } from '@jumoo/processing';
+/**
+ * @description context for keeping pipeline status and progress as we do things.
+ */
+export declare class PipelineContext extends UmbControllerBase {
+    #private;
+    readonly pipeline: import("rxjs").Observable<string | undefined>;
+    readonly state: import("rxjs").Observable<PipelineState | undefined>;
+    readonly options: import("rxjs").Observable<ProcessingOptions | undefined>;
+    readonly results: import("rxjs").Observable<ProcessingResults | undefined>;
+    readonly message: import("rxjs").Observable<ProcessingMessage | undefined>;
+    readonly backgroundState: import("rxjs").Observable<PipelineState | undefined>;
+    constructor(host: UmbControllerHost);
+    private isMessage;
+    private isState;
+    createPipeline(processor: string, strategy: string, options: ProcessingOptions | undefined): Promise<void>;
+    loadPipeline(id: string): Promise<void>;
+    getPipeline(id: string): Promise<import("@jumoo/processing").Pipeline>;
+    fetchPipeline(id: string): Promise<import("@jumoo/processing").Pipeline>;
+    process(): Promise<import("@jumoo/processing").Pipeline | undefined>;
+    updateOptions(options: ProcessingOptions): Promise<void>;
+    setOption(value: Record<string, unknown>): Promise<void>;
+    saveOptions(): Promise<void>;
+    UpdateAndSaveOptions(options: ProcessingOptions): Promise<void>;
+    clearPipeline(): Promise<void>;
+    completePipeline(): Promise<void>;
+    getResults(): Promise<ProcessingResults | undefined>;
+    readonly trigger: import("rxjs").Observable<boolean>;
+    readonly close: import("rxjs").Observable<boolean>;
+    readonly finalized: import("rxjs").Observable<boolean>;
+    readonly valid: import("rxjs").Observable<boolean>;
+    /**
+     * sets the validity of the state used to turn on next buttons etc.
+     * @param valid is the current state valid
+     */
+    setValid(valid: boolean): void;
+    /**
+     * trigger the next action in the pipeline
+     */
+    triggerNext(): Promise<void>;
+    clearNext(): void;
+    triggerClose(): Promise<void>;
+    triggerFinalized(): void;
+    readonly pending: import("rxjs").Observable<ProcessingOptions | undefined>;
+    setPending(value: Record<string, unknown>): Promise<void>;
+    private clearPending;
+    primePending(): Promise<void>;
+}
+export default PipelineContext;
+export declare const JUMOO_PROCESSING_CONTEXT: UmbContextToken<PipelineContext, PipelineContext>;

package/dist/pipeline/pipeline.context.js

@@ -0,0 +1,260 @@
+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 __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 _PipelineContext_instances, _PipelineContext_repository, _PipelineContext_hubContext, _PipelineContext_pipeline, _PipelineContext_state, _PipelineContext_options, _PipelineContext_results, _PipelineContext_message, _PipelineContext_backgroundState, _PipelineContext_clientId, _PipelineContext_hasConnectedBefore, _PipelineContext_onClientIdChanged, _PipelineContext_isInFlight, _PipelineContext_trigger, _PipelineContext_close, _PipelineContext_finalized, _PipelineContext_valid, _PipelineContext_pending;
+import { UmbControllerBase } from '@umbraco-cms/backoffice/class-api';
+import { UmbContextToken } from '@umbraco-cms/backoffice/context-api';
+import { UmbBooleanState, UmbObjectState } from '@umbraco-cms/backoffice/observable-api';
+import { PipelineStatus, PipelineRepository, ProcessingSignalRContext, } from '@jumoo/processing';
+/**
+ * @description context for keeping pipeline status and progress as we do things.
+ */
+export class PipelineContext extends UmbControllerBase {
+    constructor(host) {
+        super(host);
+        _PipelineContext_instances.add(this);
+        _PipelineContext_repository.set(this, void 0);
+        _PipelineContext_hubContext.set(this, void 0);
+        _PipelineContext_pipeline.set(this, new UmbObjectState(undefined));
+        this.pipeline = __classPrivateFieldGet(this, _PipelineContext_pipeline, "f").asObservable();
+        _PipelineContext_state.set(this, new UmbObjectState(undefined));
+        this.state = __classPrivateFieldGet(this, _PipelineContext_state, "f").asObservable();
+        _PipelineContext_options.set(this, new UmbObjectState(undefined));
+        this.options = __classPrivateFieldGet(this, _PipelineContext_options, "f").asObservable();
+        _PipelineContext_results.set(this, new UmbObjectState(undefined));
+        this.results = __classPrivateFieldGet(this, _PipelineContext_results, "f").asObservable();
+        _PipelineContext_message.set(this, new UmbObjectState(undefined));
+        this.message = __classPrivateFieldGet(this, _PipelineContext_message, "f").asObservable();
+        _PipelineContext_backgroundState.set(this, new UmbObjectState(undefined));
+        this.backgroundState = __classPrivateFieldGet(this, _PipelineContext_backgroundState, "f").asObservable();
+        // tracks the SignalR connection id ourselves, alongside the hub context's own clientId
+        // observable, so #onClientIdChanged can tell "first connect" (nothing to reattach - there's
+        // no prior, now-dead connection) apart from "changed after already having one" (a genuine
+        // reconnect, where a pipeline in flight needs to move over to the new connection).
+        _PipelineContext_clientId.set(this, null);
+        _PipelineContext_hasConnectedBefore.set(this, false);
+        // if trigger is fired, then the element moves to the next thing.
+        _PipelineContext_trigger.set(this, new UmbBooleanState(false));
+        this.trigger = __classPrivateFieldGet(this, _PipelineContext_trigger, "f").asObservable();
+        _PipelineContext_close.set(this, new UmbBooleanState(false));
+        this.close = __classPrivateFieldGet(this, _PipelineContext_close, "f").asObservable();
+        _PipelineContext_finalized.set(this, new UmbBooleanState(false));
+        this.finalized = __classPrivateFieldGet(this, _PipelineContext_finalized, "f").asObservable();
+        _PipelineContext_valid.set(this, new UmbBooleanState(true));
+        this.valid = __classPrivateFieldGet(this, _PipelineContext_valid, "f").asObservable();
+        /**
+         * pending changes, these can be set here, but not updated until
+         * trigger next is fired. that way we can stop the refresh of things.
+         */
+        _PipelineContext_pending.set(this, new UmbObjectState(undefined));
+        this.pending = __classPrivateFieldGet(this, _PipelineContext_pending, "f").asObservable();
+        __classPrivateFieldSet(this, _PipelineContext_repository, new PipelineRepository(this), "f");
+        this.provideContext(JUMOO_PROCESSING_CONTEXT, this);
+        __classPrivateFieldSet(this, _PipelineContext_hubContext, new ProcessingSignalRContext(this), "f");
+        const token = '[redacted]';
+        __classPrivateFieldGet(this, _PipelineContext_hubContext, "f").startHub(token, ['message', 'state']);
+        this.observe(__classPrivateFieldGet(this, _PipelineContext_hubContext, "f").messagesOf('message'), (message) => {
+            if (!message?.message)
+                return;
+            if (this.isMessage(message.message)) {
+                __classPrivateFieldGet(this, _PipelineContext_message, "f").setValue(message.message);
+            }
+        });
+        this.observe(__classPrivateFieldGet(this, _PipelineContext_hubContext, "f").messagesOf('state'), (state) => {
+            if (!state?.message)
+                return;
+            if (this.isState(state.message)) {
+                __classPrivateFieldGet(this, _PipelineContext_backgroundState, "f").setValue(state.message);
+            }
+        });
+        this.observe(__classPrivateFieldGet(this, _PipelineContext_hubContext, "f").clientId, (clientId) => {
+            void __classPrivateFieldGet(this, _PipelineContext_instances, "m", _PipelineContext_onClientIdChanged).call(this, clientId);
+        });
+    }
+    isMessage(message) {
+        return message !== undefined;
+    }
+    isState(message) {
+        return message !== undefined;
+    }
+    async createPipeline(processor, strategy, options) {
+        const pipeline = await __classPrivateFieldGet(this, _PipelineContext_repository, "f").create(processor, strategy, options);
+        __classPrivateFieldGet(this, _PipelineContext_pipeline, "f").setValue(pipeline);
+    }
+    async loadPipeline(id) {
+        const pipeline = await __classPrivateFieldGet(this, _PipelineContext_repository, "f").Get(id);
+        if (!pipeline)
+            return;
+        __classPrivateFieldGet(this, _PipelineContext_pipeline, "f").setValue(pipeline.id);
+    }
+    async getPipeline(id) {
+        const pipeline = await __classPrivateFieldGet(this, _PipelineContext_repository, "f").Get(id);
+        if (pipeline?.state)
+            __classPrivateFieldGet(this, _PipelineContext_state, "f").setValue(pipeline.state);
+        if (pipeline?.options)
+            __classPrivateFieldGet(this, _PipelineContext_options, "f").setValue(pipeline.options);
+        if (pipeline?.results)
+            __classPrivateFieldGet(this, _PipelineContext_results, "f").setValue(pipeline.results);
+        return pipeline;
+    }
+    async fetchPipeline(id) {
+        const pipeline = await __classPrivateFieldGet(this, _PipelineContext_repository, "f").Get(id);
+        return pipeline;
+    }
+    async process() {
+        if (!__classPrivateFieldGet(this, _PipelineContext_pipeline, "f").value)
+            return;
+        const clientId = __classPrivateFieldGet(this, _PipelineContext_hubContext, "f")?.getClientId() ?? null;
+        const response = await __classPrivateFieldGet(this, _PipelineContext_repository, "f").process(__classPrivateFieldGet(this, _PipelineContext_pipeline, "f").value, clientId);
+        if (response?.state) {
+            __classPrivateFieldGet(this, _PipelineContext_state, "f").setValue(response.state);
+        }
+        if (response?.options) {
+            __classPrivateFieldGet(this, _PipelineContext_options, "f").setValue(response.options);
+        }
+        if (response?.results) {
+            __classPrivateFieldGet(this, _PipelineContext_results, "f").setValue(response.results);
+        }
+        return response;
+    }
+    async updateOptions(options) {
+        if (!__classPrivateFieldGet(this, _PipelineContext_pipeline, "f").value)
+            return;
+        const response = await __classPrivateFieldGet(this, _PipelineContext_repository, "f").update(__classPrivateFieldGet(this, _PipelineContext_pipeline, "f").value, options);
+        if (response?.options) {
+            console.debug('update: pipeline.options', response);
+            __classPrivateFieldGet(this, _PipelineContext_options, "f").setValue(response.options);
+        }
+    }
+    async setOption(value) {
+        __classPrivateFieldGet(this, _PipelineContext_options, "f").update(value);
+    }
+    async saveOptions() {
+        if (!__classPrivateFieldGet(this, _PipelineContext_pipeline, "f").value)
+            return;
+        const response = await __classPrivateFieldGet(this, _PipelineContext_repository, "f").update(__classPrivateFieldGet(this, _PipelineContext_pipeline, "f").value, __classPrivateFieldGet(this, _PipelineContext_options, "f").value);
+        if (response?.options) {
+            console.debug('save:pipeline.options', response);
+            __classPrivateFieldGet(this, _PipelineContext_options, "f").setValue(response.options);
+        }
+    }
+    async UpdateAndSaveOptions(options) {
+        await this.updateOptions(options);
+        await this.saveOptions();
+    }
+    async clearPipeline() {
+        if (!__classPrivateFieldGet(this, _PipelineContext_pipeline, "f").value)
+            return;
+        await __classPrivateFieldGet(this, _PipelineContext_repository, "f").clear(__classPrivateFieldGet(this, _PipelineContext_pipeline, "f").value);
+        __classPrivateFieldGet(this, _PipelineContext_pipeline, "f").setValue(undefined);
+        __classPrivateFieldGet(this, _PipelineContext_state, "f").setValue(undefined);
+        __classPrivateFieldGet(this, _PipelineContext_options, "f").setValue(undefined);
+    }
+    async completePipeline() {
+        if (!__classPrivateFieldGet(this, _PipelineContext_pipeline, "f").value)
+            return;
+        // this.#repository.clear(this.#pipeline.value);
+        // this.#repository.complete(this.#pipeline.value);
+    }
+    async getResults() {
+        if (!__classPrivateFieldGet(this, _PipelineContext_pipeline, "f").value)
+            return;
+        const results = await __classPrivateFieldGet(this, _PipelineContext_repository, "f").getResults(__classPrivateFieldGet(this, _PipelineContext_pipeline, "f").value);
+        if (results)
+            __classPrivateFieldGet(this, _PipelineContext_results, "f").setValue(results);
+        return results;
+    }
+    /**
+     * sets the validity of the state used to turn on next buttons etc.
+     * @param valid is the current state valid
+     */
+    setValid(valid) {
+        __classPrivateFieldGet(this, _PipelineContext_valid, "f").setValue(valid);
+    }
+    /**
+     * trigger the next action in the pipeline
+     */
+    async triggerNext() {
+        const pending = __classPrivateFieldGet(this, _PipelineContext_pending, "f").getValue();
+        if (pending) {
+            await this.UpdateAndSaveOptions(pending);
+        }
+        this.clearPending();
+        __classPrivateFieldGet(this, _PipelineContext_trigger, "f").setValue(true);
+    }
+    clearNext() {
+        __classPrivateFieldGet(this, _PipelineContext_trigger, "f").setValue(false);
+    }
+    async triggerClose() {
+        if (__classPrivateFieldGet(this, _PipelineContext_state, "f").value?.progress.isLastAction === true ||
+            __classPrivateFieldGet(this, _PipelineContext_state, "f").value?.backgroundState?.isBackgroundRequest !== true) {
+            await this.clearPipeline();
+        }
+        __classPrivateFieldGet(this, _PipelineContext_close, "f").setValue(true);
+    }
+    triggerFinalized() {
+        __classPrivateFieldGet(this, _PipelineContext_finalized, "f").setValue(true);
+    }
+    async setPending(value) {
+        const pending = __classPrivateFieldGet(this, _PipelineContext_pending, "f").getValue();
+        if (!pending) {
+            this.primePending();
+        }
+        __classPrivateFieldGet(this, _PipelineContext_pending, "f").update(value);
+    }
+    async clearPending() {
+        __classPrivateFieldGet(this, _PipelineContext_pending, "f").setValue(undefined);
+    }
+    async primePending() {
+        __classPrivateFieldGet(this, _PipelineContext_pending, "f").setValue(__classPrivateFieldGet(this, _PipelineContext_options, "f").value);
+    }
+}
+_PipelineContext_repository = new WeakMap(), _PipelineContext_hubContext = new WeakMap(), _PipelineContext_pipeline = new WeakMap(), _PipelineContext_state = new WeakMap(), _PipelineContext_options = new WeakMap(), _PipelineContext_results = new WeakMap(), _PipelineContext_message = new WeakMap(), _PipelineContext_backgroundState = new WeakMap(), _PipelineContext_clientId = new WeakMap(), _PipelineContext_hasConnectedBefore = new WeakMap(), _PipelineContext_trigger = new WeakMap(), _PipelineContext_close = new WeakMap(), _PipelineContext_finalized = new WeakMap(), _PipelineContext_valid = new WeakMap(), _PipelineContext_pending = new WeakMap(), _PipelineContext_instances = new WeakSet(), _PipelineContext_onClientIdChanged = 
+/**
+ * @description called whenever the SignalR connection id changes - which includes the very
+ * first connect, where there's nothing to reattach yet, and a reconnect, where a pipeline
+ * already running in the background needs to be told about the new connection so progress
+ * keeps flowing to it rather than to the dead one.
+ */
+async function _PipelineContext_onClientIdChanged(clientId) {
+    const previous = __classPrivateFieldGet(this, _PipelineContext_clientId, "f");
+    __classPrivateFieldSet(this, _PipelineContext_clientId, clientId, "f");
+    if (!__classPrivateFieldGet(this, _PipelineContext_hasConnectedBefore, "f")) {
+        // the first value we ever see (typically right after startHub's initial start())
+        // isn't a reconnect - there's no earlier connection a pipeline could be attached to.
+        if (clientId)
+            __classPrivateFieldSet(this, _PipelineContext_hasConnectedBefore, true, "f");
+        return;
+    }
+    if (clientId === previous || !clientId)
+        return;
+    if (!__classPrivateFieldGet(this, _PipelineContext_pipeline, "f").value || !__classPrivateFieldGet(this, _PipelineContext_instances, "m", _PipelineContext_isInFlight).call(this))
+        return;
+    const response = await __classPrivateFieldGet(this, _PipelineContext_repository, "f").reattach(__classPrivateFieldGet(this, _PipelineContext_pipeline, "f").value, clientId);
+    if (response?.state)
+        __classPrivateFieldGet(this, _PipelineContext_state, "f").setValue(response.state);
+    if (response?.options)
+        __classPrivateFieldGet(this, _PipelineContext_options, "f").setValue(response.options);
+    if (response?.results)
+        __classPrivateFieldGet(this, _PipelineContext_results, "f").setValue(response.results);
+}, _PipelineContext_isInFlight = function _PipelineContext_isInFlight() {
+    switch (__classPrivateFieldGet(this, _PipelineContext_state, "f").value?.status) {
+        case PipelineStatus.RUNNING:
+        case PipelineStatus.BACKGROUND:
+        case PipelineStatus.WAITING:
+        case PipelineStatus.SCHEDULED:
+            return true;
+        default:
+            return false;
+    }
+};
+export default PipelineContext;
+export const JUMOO_PROCESSING_CONTEXT = new UmbContextToken('JumooPipelineContext');

package/dist/pipeline/pipeline.element.d.ts

@@ -0,0 +1,74 @@
+import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
+import { ProcessingOptions } from '@jumoo/processing';
+/**
+ * @property {string} processor - the processor to use for the pipeline
+ * @property {string} strategy - the strategy to use for the pipeline
+ * @property {ProcessingOptions} options - the options to see the pipeline with
+ *
+ * @fires pipeline-complete - when the pipeline is complete
+ * @fires pipeline-waiting - when the pipeline is waiting for user input
+ * @fires pipeline-last-action - when the pipeline is on the last action
+ * @fires pipeline-status - the current status of the pipeline.
+ */
+export declare class JumooPipelineElement extends UmbLitElement {
+    private context?;
+    /**
+     * @description The processor to use for the pipeline
+     */
+    processor?: string;
+    /**
+     * @description The strategy to use for the pipeline
+     */
+    strategy?: string;
+    /**
+     * @description The setup options for the pipeline
+     */
+    setup: ProcessingOptions | undefined;
+    pipelineId: string | undefined;
+    /**
+     * @description - show debug information
+     */
+    debug: boolean;
+    private _pipelineId;
+    private options;
+    private state;
+    private results;
+    private message;
+    private backgroundState;
+    constructor();
+    connectedCallback(): void;
+    private process;
+    /**
+     * @description dispatches a named custom event, with the pipelineId and state,
+     * @param name name of event to file
+     */
+    private fireEvent;
+    private onBackground;
+    /**
+     * @description when the pipeline is complete
+     */
+    private onComplete;
+    /**
+     * @description when the pipeline is waiting for user input (via an element.)
+     */
+    private onWaiting;
+    /**
+     * @description when the pipeline is on its last action
+     */
+    private onLastAction;
+    render(): import("lit-html").TemplateResult<1>;
+    private renderDebug;
+    private renderStatus;
+    private renderBackground;
+    private renderComplete;
+    private renderSteps;
+    private renderElement;
+    private renderFail;
+    static styles: import("lit").CSSResult;
+}
+export default JumooPipelineElement;
+declare global {
+    interface HTMLElementTagNameMap {
+        'jumoo-pipeline': JumooPipelineElement;
+    }
+}