@jumoo/usync-expansions 0.0.0-stage → 17.6.0

package/dist/restore/index.js

@@ -0,0 +1,7 @@
+import './components';
+export * from './constants.js';
+export * from './restore.context.js';
+export * from './restore.repository.js';
+export * from './workspace/restore.workspace.context.js';
+export * from './workspace/restore.workspace.element.js';
+export * from './workspace/restore.workspace-view.element.js';

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

@@ -0,0 +1,23 @@
+declare const _default: {
+    uSync: {
+        IUser: string;
+        IUserGroup: string;
+        IMember: string;
+        IMemberGroup: string;
+    };
+    uSyncRestore: {
+        title: string;
+        intro: string;
+        scan: string;
+        restoreLatest: string;
+        create: string;
+        createIntro: string;
+        createSummary: string;
+        restorePoints: string;
+        restoreTitle: string;
+        restoreIntro: string;
+        restoreCheck: string;
+        restoreInfo: string;
+    };
+};
+export default _default;

package/dist/restore/lang/en.js

@@ -0,0 +1,33 @@
+export default {
+    uSync: {
+        IUser: 'Users',
+        IUserGroup: 'User groups',
+        IMember: 'Members',
+        IMemberGroup: 'Member groups',
+    },
+    uSyncRestore: {
+        title: 'Restore points',
+        intro: `<p>
+			Restore points can be created manually, or as part of a process such as a push or pull from
+			another site
+		</p>
+		<p>
+			By default only the last 10 restore points are kept, you can restore from any restore point, but you migth 
+			well loose your current content, setting or files as part of the process.
+		</p>`,
+        scan: 'Scan restore folder',
+        restoreLatest: 'Restore from latest',
+        create: 'Create a restore point',
+        createIntro: 'Type a description to help you identify the restore point.<br/>The current date and time are added automatically',
+        createSummary: 'Your restore point has been created.',
+        restorePoints: 'Restore points',
+        restoreTitle: 'Restore Umbraco settings and content',
+        restoreIntro: `
+			<p>A restore can help fix problems the might be causing your site to not work show the right content</p>
+			<p>A restore will reset all the settings, content and (if included media), back to the way it was at the specified point in time.</p>
+			<p style="color: var(--uui-color-danger)">You will loose any changes that you have made this this restore point, so you should be sure you want to restore.</p>
+			`,
+        restoreCheck: 'Check restore',
+        restoreInfo: 'Restore to this point?',
+    },
+};

package/dist/restore/lang/manifest.d.ts

@@ -0,0 +1 @@
+export declare const manifests: UmbExtensionManifest[];

package/dist/restore/lang/manifest.js

@@ -0,0 +1,11 @@
+const localizations = [
+    {
+        type: 'localization',
+        alias: 'usync-restore-enus',
+        name: 'uSync Restore English (US)',
+        weight: 0,
+        meta: { culture: 'en' },
+        js: () => import('./en'),
+    },
+];
+export const manifests = [...localizations];

package/dist/restore/manifest.d.ts

@@ -0,0 +1 @@
+export declare const manifests: import("@umbraco-cms/backoffice/extension-api").ManifestBase[];

package/dist/restore/manifest.js

@@ -0,0 +1,63 @@
+import { uSyncRestore } from '@jumoo/usync-expansions';
+import { manifests as stepManifests } from './steps/manifest';
+import { manifests as localizationManifests } from './lang/manifest';
+const workspaceAlias = uSyncRestore.workspace;
+const restoreMenuItem = {
+    type: 'usync-menuItem',
+    alias: 'usync.restore.menu.item',
+    name: 'restore',
+    weight: 10,
+    meta: {
+        label: 'Restore',
+        icon: uSyncRestore.icon,
+        entityType: uSyncRestore.element,
+        menus: ['usync.menu'],
+    },
+};
+const restoreWorkspaceContext = {
+    type: 'workspaceContext',
+    alias: uSyncRestore.context,
+    name: 'uSync Restore',
+    js: () => import('./workspace/restore.workspace.context'),
+    conditions: [
+        {
+            alias: 'Umb.Condition.WorkspaceAlias',
+            match: workspaceAlias,
+        },
+    ],
+};
+const restoreWorkspace = {
+    type: 'workspace',
+    alias: workspaceAlias,
+    name: 'uSync Restore',
+    js: () => import('./workspace/restore.workspace.element'),
+    meta: {
+        entityType: uSyncRestore.element,
+    },
+};
+const restoreWorkspaceView = {
+    type: 'workspaceView',
+    alias: 'usync.restore.workspace.view',
+    name: 'uSync Restore points view',
+    js: () => import('./workspace/restore.workspace-view.element'),
+    weight: 100,
+    meta: {
+        label: 'Restore points',
+        pathname: 'restore-points',
+        icon: uSyncRestore.icon,
+    },
+    conditions: [
+        {
+            alias: 'Umb.Condition.WorkspaceAlias',
+            match: workspaceAlias,
+        },
+    ],
+};
+export const manifests = [
+    restoreMenuItem,
+    restoreWorkspaceContext,
+    restoreWorkspace,
+    restoreWorkspaceView,
+    ...stepManifests,
+    ...localizationManifests,
+];

package/dist/restore/restore.context.d.ts

@@ -0,0 +1,10 @@
+import { UmbControllerBase } from '@umbraco-cms/backoffice/class-api';
+import { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
+import { UmbContextToken } from '@umbraco-cms/backoffice/context-api';
+export declare class SyncRestoreContext extends UmbControllerBase {
+    #private;
+    constructor(host: UmbControllerHost);
+    getRestorePoint(key: string): Promise<import("@jumoo/usync-expansions").RestorePoint>;
+}
+export default SyncRestoreContext;
+export declare const USYNC_RESTORE_CONTEXT: UmbContextToken<SyncRestoreContext, SyncRestoreContext>;

package/dist/restore/restore.context.js

@@ -0,0 +1,29 @@
+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 _SyncRestoreContext_respository;
+import { UmbControllerBase } from '@umbraco-cms/backoffice/class-api';
+import { SyncRestoreRepository } from '@jumoo/usync-expansions';
+import { UmbContextToken } from '@umbraco-cms/backoffice/context-api';
+export class SyncRestoreContext extends UmbControllerBase {
+    constructor(host) {
+        super(host);
+        _SyncRestoreContext_respository.set(this, void 0);
+        __classPrivateFieldSet(this, _SyncRestoreContext_respository, new SyncRestoreRepository(this), "f");
+        this.provideContext(USYNC_RESTORE_CONTEXT, this);
+    }
+    async getRestorePoint(key) {
+        return await __classPrivateFieldGet(this, _SyncRestoreContext_respository, "f").get(key);
+    }
+}
+_SyncRestoreContext_respository = new WeakMap();
+export default SyncRestoreContext;
+export const USYNC_RESTORE_CONTEXT = new UmbContextToken('usync-restore-context');

package/dist/restore/restore.repository.d.ts

@@ -0,0 +1,15 @@
+import { UmbControllerBase } from '@umbraco-cms/backoffice/class-api';
+import { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
+export declare class SyncRestoreRepository extends UmbControllerBase {
+    #private;
+    constructor(host: UmbControllerHost);
+    clean(): Promise<unknown>;
+    remove(id: string): Promise<unknown>;
+    getAll(): Promise<import("..").RestorePoint[]>;
+    get(key: string): Promise<import("..").RestorePoint>;
+    getReport(id: string): Promise<import("..").USyncAction[]>;
+    scan(): Promise<{
+        [key: string]: number;
+    }>;
+}
+export default SyncRestoreRepository;

package/dist/restore/restore.repository.js

@@ -0,0 +1,43 @@
+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 _SyncRestoreRepository_host;
+import { UmbControllerBase } from '@umbraco-cms/backoffice/class-api';
+import { tryExecute } from '@umbraco-cms/backoffice/resources';
+import { RestoreService } from '../api';
+export class SyncRestoreRepository extends UmbControllerBase {
+    constructor(host) {
+        super(host);
+        _SyncRestoreRepository_host.set(this, void 0);
+        __classPrivateFieldSet(this, _SyncRestoreRepository_host, host, "f");
+    }
+    async clean() {
+        return (await tryExecute(__classPrivateFieldGet(this, _SyncRestoreRepository_host, "f"), RestoreService.clean())).data;
+    }
+    async remove(id) {
+        return (await tryExecute(__classPrivateFieldGet(this, _SyncRestoreRepository_host, "f"), RestoreService.remove({ query: { id } }))).data;
+    }
+    async getAll() {
+        return (await tryExecute(__classPrivateFieldGet(this, _SyncRestoreRepository_host, "f"), RestoreService.getAll())).data;
+    }
+    async get(key) {
+        return (await tryExecute(__classPrivateFieldGet(this, _SyncRestoreRepository_host, "f"), RestoreService.getRestorePoint({ query: { key } }))).data;
+    }
+    async getReport(id) {
+        return (await tryExecute(__classPrivateFieldGet(this, _SyncRestoreRepository_host, "f"), RestoreService.getReport({ query: { id } })))
+            .data;
+    }
+    async scan() {
+        return (await tryExecute(__classPrivateFieldGet(this, _SyncRestoreRepository_host, "f"), RestoreService.scan())).data;
+    }
+}
+_SyncRestoreRepository_host = new WeakMap();
+export default SyncRestoreRepository;

package/dist/restore/steps/manifest.d.ts

@@ -0,0 +1 @@
+export declare const manifests: UmbExtensionManifest[];

package/dist/restore/steps/manifest.js

@@ -0,0 +1,36 @@
+import { uSyncRestore } from '@jumoo/usync-expansions';
+const restoreStepManifests = [
+    {
+        type: 'jumoo-process-step',
+        alias: uSyncRestore.steps.restoreCreateStep,
+        name: 'Create restore point step',
+        weight: 100,
+        js: () => import('./restore-create-element'),
+        elementName: uSyncRestore.steps.restoreCreateStep,
+    },
+    {
+        type: 'jumoo-process-step',
+        alias: uSyncRestore.steps.restoreCreateComplete,
+        name: 'Restore complete',
+        weight: 200,
+        js: () => import('./restore-create-complete'),
+        elementName: uSyncRestore.steps.restoreCreateComplete,
+    },
+    {
+        type: 'jumoo-process-step',
+        alias: uSyncRestore.steps.restoreReportConfigStep,
+        name: 'Restore step',
+        weight: 300,
+        js: () => import('./restore-report-config-element'),
+        elementName: uSyncRestore.steps.restoreReportConfigStep,
+    },
+    {
+        type: 'jumoo-process-step',
+        alias: uSyncRestore.steps.restoreReportStep,
+        name: 'Restore report',
+        weight: 400,
+        js: () => import('./restore-report-element'),
+        elementName: uSyncRestore.steps.restoreReportStep,
+    },
+];
+export const manifests = [...restoreStepManifests];

package/dist/restore/steps/restore-create-complete.d.ts

@@ -0,0 +1,6 @@
+import { ProcessStepElement, ProcessStepElementBase } from '@jumoo/processing';
+export declare class uSyncRestoreCreateCompleteElement extends ProcessStepElementBase implements ProcessStepElement {
+    constructor();
+    render(): import("lit-html").TemplateResult<1>;
+}
+export default uSyncRestoreCreateCompleteElement;

package/dist/restore/steps/restore-create-complete.js

@@ -0,0 +1,33 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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;
+};
+import { ProcessStepElementBase, } from '@jumoo/processing';
+import { customElement, html } from '@umbraco-cms/backoffice/external/lit';
+import { uSyncRestore } from '@jumoo/usync-expansions';
+let uSyncRestoreCreateCompleteElement = class uSyncRestoreCreateCompleteElement extends ProcessStepElementBase {
+    constructor() {
+        super();
+    }
+    render() {
+        const results = this.results;
+        const options = this.options;
+        return html `<uui-box>
+			<p>
+				Restore point created:
+				<strong>${options.title}</strong>
+			</p>
+
+			<umb-localize key="uSyncRestore_createComplete"></umb-localize>
+
+			<p>Contains ${results.results['changes'] ?? 'unknown'} items</p>
+		</uui-box>`;
+    }
+};
+uSyncRestoreCreateCompleteElement = __decorate([
+    customElement(uSyncRestore.steps.restoreCreateComplete)
+], uSyncRestoreCreateCompleteElement);
+export { uSyncRestoreCreateCompleteElement };
+export default uSyncRestoreCreateCompleteElement;

package/dist/restore/steps/restore-create-element.d.ts

@@ -0,0 +1,9 @@
+import { ProcessStepElement, ProcessStepElementBase } from '@jumoo/processing';
+export declare class uSyncRestoreCreateElement extends ProcessStepElementBase implements ProcessStepElement {
+    #private;
+    constructor();
+    render(): import("lit-html").TemplateResult<1>;
+    renderName(): import("lit-html").TemplateResult<1>;
+    static styles: import("lit").CSSResult;
+}
+export default uSyncRestoreCreateElement;

package/dist/restore/steps/restore-create-element.js

@@ -0,0 +1,97 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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 __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 _uSyncRestoreCreateElement_instances, _uSyncRestoreCreateElement_pipelineContext, _uSyncRestoreCreateElement_onNameChange, _uSyncRestoreCreateElement_onIncludeMedia;
+import { JUMOO_PROCESSING_CONTEXT, ProcessStepElementBase, } from '@jumoo/processing';
+import { css, customElement, html } from '@umbraco-cms/backoffice/external/lit';
+import { uSyncRestore } from '@jumoo/usync-expansions';
+let uSyncRestoreCreateElement = class uSyncRestoreCreateElement extends ProcessStepElementBase {
+    constructor() {
+        super();
+        _uSyncRestoreCreateElement_instances.add(this);
+        _uSyncRestoreCreateElement_pipelineContext.set(this, void 0);
+        this.consumeContext(JUMOO_PROCESSING_CONTEXT, (context) => {
+            __classPrivateFieldSet(this, _uSyncRestoreCreateElement_pipelineContext, context, "f");
+        });
+    }
+    render() {
+        return html `
+			<umb-localize key="uSyncRestore_createIntro"></umb-localize>
+
+			${this.renderName()}
+		`;
+    }
+    renderName() {
+        const options = this.options;
+        return html `<umb-property-layout
+				label="Name"
+				description="Give your restore point a name"
+				orientation="vertical">
+				<div slot="editor">
+					<uui-input
+						type="text"
+						label="Name"
+						.value=${options.title}
+						@change=${__classPrivateFieldGet(this, _uSyncRestoreCreateElement_instances, "m", _uSyncRestoreCreateElement_onNameChange)}></uui-input>
+				</div>
+			</umb-property-layout>
+
+			<usync-property-layout
+				label="Include Media"
+				description="Include media files in the restore point">
+				<div slot="editor">
+					<uui-checkbox
+						label="Include Media"
+						.checked=${options.includeMedia}
+						@change=${__classPrivateFieldGet(this, _uSyncRestoreCreateElement_instances, "m", _uSyncRestoreCreateElement_onIncludeMedia)}>
+					</uui-checkbox>
+				</div>
+			</usync-property-layout>`;
+    }
+};
+_uSyncRestoreCreateElement_pipelineContext = new WeakMap();
+_uSyncRestoreCreateElement_instances = new WeakSet();
+_uSyncRestoreCreateElement_onNameChange = function _uSyncRestoreCreateElement_onNameChange(e) {
+    if (!this.options)
+        return;
+    const element = e.target;
+    if (!element)
+        return;
+    __classPrivateFieldGet(this, _uSyncRestoreCreateElement_pipelineContext, "f")?.setPending({
+        title: element.value,
+    });
+};
+_uSyncRestoreCreateElement_onIncludeMedia = function _uSyncRestoreCreateElement_onIncludeMedia(e) {
+    if (!this.options)
+        return;
+    const element = e.target;
+    if (!element)
+        return;
+    __classPrivateFieldGet(this, _uSyncRestoreCreateElement_pipelineContext, "f")?.setPending({
+        includeMedia: element.checked,
+    });
+};
+uSyncRestoreCreateElement.styles = css `
+		uui-input {
+			width: 100%;
+		}
+	`;
+uSyncRestoreCreateElement = __decorate([
+    customElement(uSyncRestore.steps.restoreCreateStep)
+], uSyncRestoreCreateElement);
+export { uSyncRestoreCreateElement };
+export default uSyncRestoreCreateElement;

package/dist/restore/steps/restore-report-config-element.d.ts

@@ -0,0 +1,14 @@
+import { ProcessStepElement, ProcessStepElementBase } from '@jumoo/processing';
+import { nothing } from '@umbraco-cms/backoffice/external/lit';
+import { RestorePoint } from '@jumoo/usync-expansions';
+export declare class uSyncRestoreReportConfigElement extends ProcessStepElementBase implements ProcessStepElement {
+    #private;
+    key?: string;
+    restorePoint: RestorePoint | undefined;
+    constructor();
+    connectedCallback(): void;
+    renderRestorePointInfo(): typeof nothing | import("lit-html").TemplateResult<1>;
+    render(): import("lit-html").TemplateResult<1>;
+    static styles: import("lit").CSSResult;
+}
+export default uSyncRestoreReportConfigElement;

package/dist/restore/steps/restore-report-config-element.js

@@ -0,0 +1,105 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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 __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 _uSyncRestoreReportConfigElement_context;
+import { ProcessStepElementBase } from '@jumoo/processing';
+import { TimeOptions, uSyncRestore } from '@jumoo/usync-expansions';
+import { css, customElement, html, nothing, state, } from '@umbraco-cms/backoffice/external/lit';
+import { SyncRestoreContext } from '@jumoo/usync-expansions';
+let uSyncRestoreReportConfigElement = class uSyncRestoreReportConfigElement extends ProcessStepElementBase {
+    constructor() {
+        super();
+        _uSyncRestoreReportConfigElement_context.set(this, void 0);
+        __classPrivateFieldSet(this, _uSyncRestoreReportConfigElement_context, new SyncRestoreContext(this), "f");
+    }
+    connectedCallback() {
+        super.connectedCallback();
+        const options = this.options;
+        if (!options)
+            return;
+        this.key = options.key;
+        __classPrivateFieldGet(this, _uSyncRestoreReportConfigElement_context, "f").getRestorePoint(options.key).then((restorePoint) => {
+            console.log('restorePoint', restorePoint);
+            this.restorePoint = restorePoint;
+        });
+    }
+    renderRestorePointInfo() {
+        if (!this.restorePoint)
+            return nothing;
+        return html `
+			<uui-box .headline=${this.localize.term('uSyncRestore_restoreInfo')}>
+				<table>
+					<tr>
+						<th>Name :</th>
+						<td>${this.restorePoint.name}</td>
+					</tr>
+					<tr>
+						<th>Created :</th>
+						<td>${this.localize.date(this.restorePoint.created, TimeOptions)}</td>
+					</tr>
+					<tr>
+						<th>Source Site :</th>
+						<td>${this.restorePoint.machineName}</td>
+					</tr>
+					<tr>
+						<th>Source :</th>
+						<td>${this.restorePoint.action}</td>
+					</tr>
+					<tr>
+						<th>User:</th>
+						<td>${this.restorePoint.user}</td>
+					</tr>
+				</table>
+			</uui-box>
+		`;
+    }
+    render() {
+        return html `<div class="wrapper">
+			<uui-box>
+				<umb-localize key="uSyncRestore_restoreIntro"></umb-localize>
+			</uui-box>
+			${this.renderRestorePointInfo()}
+		</div>`;
+    }
+};
+_uSyncRestoreReportConfigElement_context = new WeakMap();
+uSyncRestoreReportConfigElement.styles = css `
+		.wrapper {
+			display: flex;
+			flex-direction: column;
+			gap: var(--uui-size-space-4);
+		}
+
+		.red {
+			color: red;
+		}
+
+		table th {
+			text-align: right;
+		}
+	`;
+__decorate([
+    state()
+], uSyncRestoreReportConfigElement.prototype, "key", void 0);
+__decorate([
+    state()
+], uSyncRestoreReportConfigElement.prototype, "restorePoint", void 0);
+uSyncRestoreReportConfigElement = __decorate([
+    customElement(uSyncRestore.steps.restoreReportConfigStep)
+], uSyncRestoreReportConfigElement);
+export { uSyncRestoreReportConfigElement };
+export default uSyncRestoreReportConfigElement;

package/dist/restore/steps/restore-report-element.d.ts

@@ -0,0 +1,6 @@
+import { ProcessStepElement, ProcessStepElementBase } from '@jumoo/processing';
+export declare class uSyncRestoreReportElement extends ProcessStepElementBase implements ProcessStepElement {
+    connectedCallback(): void;
+    render(): import("lit-html").TemplateResult<1>;
+}
+export default uSyncRestoreReportElement;

package/dist/restore/steps/restore-report-element.js

@@ -0,0 +1,39 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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;
+};
+import { ProcessStepElementBase } from '@jumoo/processing';
+import { uSyncRestore } from '@jumoo/usync-expansions';
+import { customElement, html } from '@umbraco-cms/backoffice/external/lit';
+let uSyncRestoreReportElement = class uSyncRestoreReportElement extends ProcessStepElementBase {
+    connectedCallback() {
+        super.connectedCallback();
+        const changes = this.results?.results['changes'] ?? 0;
+        console.log('changes', changes);
+        this.dispatchEvent(new CustomEvent('pipeline-valid', {
+            bubbles: true,
+            composed: true,
+            detail: {
+                valid: changes != 0,
+            },
+        }));
+        this.dispatchEvent(new CustomEvent('pipeline-modal-update', {
+            bubbles: true,
+            composed: true,
+            detail: {
+                progressLabel: 'Restore',
+            },
+        }));
+    }
+    render() {
+        const actions = this.results?.results['actions'];
+        return html `<usync-results .results=${actions}></usync-results>`;
+    }
+};
+uSyncRestoreReportElement = __decorate([
+    customElement(uSyncRestore.steps.restoreReportStep)
+], uSyncRestoreReportElement);
+export { uSyncRestoreReportElement };
+export default uSyncRestoreReportElement;

package/dist/restore/workspace/restore.workspace-view.element.d.ts

@@ -0,0 +1,24 @@
+import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
+import { nothing } from '@umbraco-cms/backoffice/external/lit';
+import { RestorePoint } from '@jumoo/usync-expansions';
+import '../components/restore-point-table.element';
+/**
+ *  the body of the restore points workspace.
+ *
+ *  lives in a workspace view, not the workspace editor's default slot
+ *  (deprecated in Umbraco 17.8, removed in 21).
+ */
+export declare class uSyncRestoreWorkspaceViewElement extends UmbLitElement {
+    #private;
+    restorePoints?: RestorePoint[];
+    constructor();
+    render(): import("lit-html").TemplateResult<1>;
+    renderTable(): typeof nothing | import("lit-html").TemplateResult<1>;
+    static styles: import("lit").CSSResult;
+}
+export default uSyncRestoreWorkspaceViewElement;
+declare global {
+    interface HTMLElementTagNameMap {
+        'usync-restore-workspace-view': uSyncRestoreWorkspaceViewElement;
+    }
+}