@jumoo/processing 18.3.2 → 18.3.4

package/dist/lang/files/en.d.ts

@@ -24,6 +24,8 @@ declare const _default: {
         messageWaiting: string;
         headlineScheduled: string;
         messageScheduled: string;
+        checked: string;
+        tryAgain: string;
         status: string;
         startedBy: string;
         queued: string;
@@ -38,6 +40,11 @@ declare const _default: {
         stateCompleted: string;
         stateFailed: string;
         stateCancelled: string;
+        stalled: string;
+        clear: string;
+        clearHeadline: string;
+        clearConfirm: string;
+        clearConfirmLabel: string;
     };
     jumooProcBackground: {
         completed: string;

package/dist/lang/files/en.js

@@ -15,15 +15,17 @@ export default {
     },
     jumooProcConflict: {
         headline: 'Already in progress',
-        message: 'Another process is already in progress for this target. Wait for it to finish, or cancel it, then try again.',
+        message: 'Another process is already in progress for this target. Try again once it has finished.',
         headlineRunning: 'Already running',
-        messageRunning: 'Another process is already running for this target. Wait for it to finish, or cancel it, then try again.',
+        messageRunning: 'Another process is already running for this target. Try again once it has finished.',
         headlineQueued: 'Already queued',
-        messageQueued: 'Another process for this target is queued and will start shortly. Wait for it to finish, or cancel it, then try again.',
+        messageQueued: 'Another process for this target is queued and will start shortly. Try again once it has finished.',
         headlineWaiting: 'Waiting to continue',
-        messageWaiting: 'Another process for this target is paused and waiting to continue. Finish or cancel it, then try again.',
+        messageWaiting: 'Another process for this target is paused, waiting for whoever started it to continue. Try again once it has been finished or cancelled.',
         headlineScheduled: 'Already scheduled',
-        messageScheduled: 'Another process for this target is scheduled. Cancel it, or wait for it to run, then try again.',
+        messageScheduled: 'Another process for this target is scheduled. Try again once it has run.',
+        checked: 'Checked',
+        tryAgain: 'Try again',
         status: 'Status',
         startedBy: 'Started by',
         queued: 'Queued',
@@ -38,6 +40,11 @@ export default {
         stateCompleted: 'Completed',
         stateFailed: 'Failed',
         stateCancelled: 'Cancelled',
+        stalled: "It hasn't moved for a while, so it has probably stopped (a closed browser, or an error). You can clear it and start again.",
+        clear: 'Clear it',
+        clearHeadline: 'Clear the other process?',
+        clearConfirm: 'This removes the other process so this one can start. If it is still working, it stops part way through.',
+        clearConfirmLabel: 'Clear and start',
     },
     jumooProcBackground: {
         completed: 'This process has completed in the background',

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

@@ -22,6 +22,12 @@ export declare class PipelineContext extends UmbControllerBase {
     private isMessage;
     private isState;
     createPipeline(processor: string, strategy: string, options: ProcessingOptions | undefined): Promise<void>;
+    /**
+     * @description clears the pipeline holding the key, so a create can be tried again. For a
+     * holder that has stopped moving - the server only lets go of a browser-driven run once it
+     * has been idle for the concurrency key idle timeout.
+     */
+    clearConflictHolder(): Promise<void>;
     loadPipeline(id: string): Promise<void>;
     getPipeline(id: string): Promise<import("@jumoo/processing").Pipeline>;
     fetchPipeline(id: string): Promise<import("@jumoo/processing").Pipeline>;

package/dist/pipeline/pipeline.context.js

@@ -92,14 +92,27 @@ export class PipelineContext extends UmbControllerBase {
         return message !== undefined;
     }
     async createPipeline(processor, strategy, options) {
-        __classPrivateFieldGet(this, _PipelineContext_conflict, "f").setValue(undefined);
+        // a retry keeps the current conflict showing until there's a new answer.
         const { data, error } = await __classPrivateFieldGet(this, _PipelineContext_repository, "f").tryCreate(processor, strategy, options);
         if (error) {
             await __classPrivateFieldGet(this, _PipelineContext_instances, "m", _PipelineContext_setConflict).call(this, error);
             return;
         }
+        __classPrivateFieldGet(this, _PipelineContext_conflict, "f").setValue(undefined);
         __classPrivateFieldGet(this, _PipelineContext_pipeline, "f").setValue(data);
     }
+    /**
+     * @description clears the pipeline holding the key, so a create can be tried again. For a
+     * holder that has stopped moving - the server only lets go of a browser-driven run once it
+     * has been idle for the concurrency key idle timeout.
+     */
+    async clearConflictHolder() {
+        const conflict = __classPrivateFieldGet(this, _PipelineContext_conflict, "f").value;
+        if (!conflict)
+            return;
+        await __classPrivateFieldGet(this, _PipelineContext_repository, "f").clear(conflict.runningPipelineId);
+        __classPrivateFieldGet(this, _PipelineContext_conflict, "f").setValue(undefined);
+    }
     async loadPipeline(id) {
         const pipeline = await __classPrivateFieldGet(this, _PipelineContext_repository, "f").Get(id);
         if (!pipeline)
@@ -285,10 +298,8 @@ async function _PipelineContext_setConflict(error) {
     const conflict = getPipelineConflict(error);
     if (!conflict)
         return false;
-    __classPrivateFieldGet(this, _PipelineContext_conflict, "f").setValue(conflict);
     const holder = await __classPrivateFieldGet(this, _PipelineContext_repository, "f").getRunStatus(conflict.runningPipelineId);
-    if (holder)
-        __classPrivateFieldGet(this, _PipelineContext_conflict, "f").setValue({ ...conflict, holder });
+    __classPrivateFieldGet(this, _PipelineContext_conflict, "f").setValue(holder ? { ...conflict, holder } : conflict);
     return true;
 };
 export default PipelineContext;

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

@@ -13,6 +13,7 @@ import { ProcessingOptions } from '@jumoo/processing';
  * process is already running for the same target (detail is the PipelineConflict).
  */
 export declare class JumooPipelineElement extends UmbLitElement {
+    #private;
     private context?;
     /**
      * @description The processor to use for the pipeline
@@ -38,6 +39,12 @@ export declare class JumooPipelineElement extends UmbLitElement {
     private message;
     private backgroundState;
     private conflict;
+    /**
+     * @description when the conflict was last checked. The panel doesn't update by itself, so it
+     * shows how old its answer is.
+     */
+    private conflictCheckedAt;
+    private retrying;
     constructor();
     connectedCallback(): void;
     private process;
@@ -61,6 +68,20 @@ export declare class JumooPipelineElement extends UmbLitElement {
     private onLastAction;
     render(): import("lit-html").TemplateResult<1>;
     private renderConflict;
+    /**
+     * @description only a conflict from creating this pipeline can be tried again from here -
+     * one from an existing pipeline has nothing to recreate.
+     * @returns true when the panel should offer to try again.
+     */
+    private canRetry;
+    /**
+     * @description a running holder that has stopped moving can be cleared, but only when the
+     * conflict came from creating this pipeline - that's the one we know how to try again.
+     * The holder is only there when the user can see it (its owner, or an admin).
+     * @param holder the holder's status.
+     * @returns true when the panel should offer to clear it.
+     */
+    private canClear;
     /**
      * @description the time worth showing for the holder: when it was queued, when it last
      * moved, how long it has been paused, or when it is due.

package/dist/pipeline/pipeline.element.js

@@ -4,8 +4,15 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+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 _JumooPipelineElement_instances, _JumooPipelineElement_onRetryConflict, _JumooPipelineElement_onClearConflict;
 import { css, customElement, html, nothing, property, state, } from '@umbraco-cms/backoffice/external/lit';
 import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
+import { umbConfirmModal } from '@umbraco-cms/backoffice/modal';
 import { PipelineStatus, JUMOO_PROCESSING_CONTEXT, } from '@jumoo/processing';
 import { PipelineRunState } from '../api/index.js';
 /**
@@ -25,6 +32,12 @@ function conflictSuffix(status) {
             return '';
     }
 }
+/**
+ * @description how long a running holder goes without moving before the conflict panel offers
+ * to clear it. A browser-driven run saves after every step, so one this quiet has most likely
+ * lost its browser.
+ */
+const CLEAR_AFTER_IDLE_MS = 5 * 60 * 1000;
 /**
  * @property {string} processor - the processor to use for the pipeline
  * @property {string} strategy - the strategy to use for the pipeline
@@ -40,10 +53,12 @@ function conflictSuffix(status) {
 let JumooPipelineElement = class JumooPipelineElement extends UmbLitElement {
     constructor() {
         super();
+        _JumooPipelineElement_instances.add(this);
         /**
          * @description - show debug information
          */
         this.debug = false;
+        this.retrying = false;
         this.consumeContext(JUMOO_PROCESSING_CONTEXT, (context) => {
             if (!context)
                 return;
@@ -96,6 +111,7 @@ let JumooPipelineElement = class JumooPipelineElement extends UmbLitElement {
             this.observe(this.context.conflict, (conflict) => {
                 const isNew = conflict && !this.conflict;
                 this.conflict = conflict;
+                this.conflictCheckedAt = conflict ? new Date() : undefined;
                 if (isNew) {
                     this.dispatchEvent(new CustomEvent('pipeline-conflict', {
                         bubbles: true,
@@ -209,11 +225,69 @@ let JumooPipelineElement = class JumooPipelineElement extends UmbLitElement {
 												>
 											</dt>
 											<dd>${Math.round(holder.progress.percentage)}%</dd>`
+                : nothing}
+							${this.conflictCheckedAt
+                ? html `<dt>
+												<umb-localize key="jumooProcConflict_checked"
+													>Checked</umb-localize
+												>
+											</dt>
+											<dd>
+												${this.localize.date(this.conflictCheckedAt, {
+                    timeStyle: 'medium',
+                })}
+											</dd>`
                 : nothing}
 						</dl>`
+            : nothing}
+			${holder && this.canClear(holder)
+            ? html `<p>${this.localize.term('jumooProcConflict_stalled')}</p>`
+            : nothing}
+			${this.canRetry()
+            ? html `<div class="actions">
+							<uui-button
+								look="secondary"
+								label=${this.localize.term('jumooProcConflict_tryAgain')}
+								.state=${this.retrying ? 'waiting' : undefined}
+								?disabled=${this.retrying}
+								@click=${__classPrivateFieldGet(this, _JumooPipelineElement_instances, "m", _JumooPipelineElement_onRetryConflict)}></uui-button>
+							${holder && this.canClear(holder)
+                ? html `<uui-button
+											look="primary"
+											color="warning"
+											label=${this.localize.term('jumooProcConflict_clear')}
+											?disabled=${this.retrying}
+											@click=${__classPrivateFieldGet(this, _JumooPipelineElement_instances, "m", _JumooPipelineElement_onClearConflict)}></uui-button>`
+                : nothing}
+						</div>`
             : nothing}
 		</div>`;
     }
+    /**
+     * @description only a conflict from creating this pipeline can be tried again from here -
+     * one from an existing pipeline has nothing to recreate.
+     * @returns true when the panel should offer to try again.
+     */
+    canRetry() {
+        return !this._pipelineId && !!this.processor && !!this.strategy;
+    }
+    /**
+     * @description a running holder that has stopped moving can be cleared, but only when the
+     * conflict came from creating this pipeline - that's the one we know how to try again.
+     * The holder is only there when the user can see it (its owner, or an admin).
+     * @param holder the holder's status.
+     * @returns true when the panel should offer to clear it.
+     */
+    canClear(holder) {
+        if (!this.canRetry())
+            return false;
+        if (holder.status !== PipelineRunState.RUNNING)
+            return false;
+        const lastActivity = holder.modified ?? holder.created;
+        if (!lastActivity)
+            return false;
+        return Date.now() - new Date(lastActivity).getTime() > CLEAR_AFTER_IDLE_MS;
+    }
     /**
      * @description the time worth showing for the holder: when it was queued, when it last
      * moved, how long it has been paused, or when it is due.
@@ -307,6 +381,43 @@ let JumooPipelineElement = class JumooPipelineElement extends UmbLitElement {
 		`;
     }
 };
+_JumooPipelineElement_instances = new WeakSet();
+_JumooPipelineElement_onRetryConflict = 
+/**
+ * @description tries the create again: starts if the other process has gone, otherwise the
+ * panel redraws with its latest status (which may now offer to clear it).
+ */
+async function _JumooPipelineElement_onRetryConflict() {
+    if (!this.processor || !this.strategy)
+        return;
+    this.retrying = true;
+    try {
+        await this.context?.createPipeline(this.processor, this.strategy, this.setup);
+    }
+    finally {
+        this.retrying = false;
+    }
+    // an unchanged answer doesn't reach the conflict observer, so stamp it here too.
+    if (this.conflict)
+        this.conflictCheckedAt = new Date();
+};
+_JumooPipelineElement_onClearConflict = async function _JumooPipelineElement_onClearConflict() {
+    try {
+        await umbConfirmModal(this, {
+            headline: this.localize.term('jumooProcConflict_clearHeadline'),
+            content: this.localize.term('jumooProcConflict_clearConfirm'),
+            color: 'danger',
+            confirmLabel: this.localize.term('jumooProcConflict_clearConfirmLabel'),
+        });
+    }
+    catch {
+        return; // closed the dialog.
+    }
+    if (!this.processor || !this.strategy)
+        return;
+    await this.context?.clearConflictHolder();
+    await this.context?.createPipeline(this.processor, this.strategy, this.setup);
+};
 JumooPipelineElement.styles = css `
 		.wrapper,
 		umb-extension-slot {
@@ -346,6 +457,11 @@ JumooPipelineElement.styles = css `
 		.conflict dd {
 			margin: 0;
 		}
+
+		.conflict .actions {
+			display: flex;
+			gap: var(--uui-size-space-3);
+		}
 	`;
 __decorate([
     property({ type: String })
@@ -383,6 +499,12 @@ __decorate([
 __decorate([
     state()
 ], JumooPipelineElement.prototype, "conflict", void 0);
+__decorate([
+    state()
+], JumooPipelineElement.prototype, "conflictCheckedAt", void 0);
+__decorate([
+    state()
+], JumooPipelineElement.prototype, "retrying", void 0);
 JumooPipelineElement = __decorate([
     customElement('jumoo-pipeline')
 ], JumooPipelineElement);

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@jumoo/processing",
 	"licence": "custom",
-	"version": "18.3.2",
+	"version": "18.3.4",
 	"type": "module",
 	"description": "Jumoo processing library",
 	"exports": {
@@ -43,8 +43,8 @@
 		"@umbraco-cms/backoffice": "18.0.1",
 		"chalk": "^6.0.1",
 		"cross-env": "^10.1.0",
-		"eslint": "^10.13.0",
-		"globals": "^17.13.0",
+		"eslint": "^10.14.0",
+		"globals": "^17.14.0",
 		"node-fetch": "^3.3.2",
 		"prettier": "^3.9.10",
 		"typescript": "^6.0.3",