@jumoo/usync-expansions 0.0.0-stage → 17.6.0

package/dist/licence/licence.element.js

@@ -0,0 +1,270 @@
+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 _uSyncLicenceViewElement_instances, _uSyncLicenceViewElement_licenceContext, _uSyncLicenceViewElement_saveLicence, _uSyncLicenceViewElement_updateDomains, _uSyncLicenceViewElement_updateKey, _uSyncLicenceViewElement_clearLicence;
+import { UmbElementMixin } from '@umbraco-cms/backoffice/element-api';
+import { LitElement, css, customElement, html, nothing, state, when, } from '@umbraco-cms/backoffice/external/lit';
+import { USYNC_LICENCE_CONTEXT_TOKEN, } from '@jumoo/usync-expansions';
+import { UmbTextStyles } from '@umbraco-cms/backoffice/style';
+import { UMB_CONFIRM_MODAL, UMB_MODAL_MANAGER_CONTEXT, } from '@umbraco-cms/backoffice/modal';
+let uSyncLicenceViewElement = class uSyncLicenceViewElement extends UmbElementMixin(LitElement) {
+    constructor() {
+        super();
+        _uSyncLicenceViewElement_instances.add(this);
+        _uSyncLicenceViewElement_licenceContext.set(this, void 0);
+        this.licence = {
+            key: 'key',
+            domains: 'domains',
+        };
+        this.licenceStatus = undefined;
+        this.consumeContext(USYNC_LICENCE_CONTEXT_TOKEN, (_context) => {
+            if (!_context)
+                return;
+            __classPrivateFieldSet(this, _uSyncLicenceViewElement_licenceContext, _context, "f");
+            _context.refresh();
+            this.observe(_context.licence, (_licence) => {
+                this.licence = {
+                    key: _licence?.key ?? '',
+                    domains: _licence?.domains ?? '',
+                };
+                this.requestUpdate('licence');
+            });
+            this.observe(_context.licenceStatus, (_status) => {
+                this.licenceStatus = _status;
+                this.requestUpdate('licenceStatus');
+            });
+        });
+    }
+    connectedCallback() {
+        super.connectedCallback();
+    }
+    render() {
+        return html `
+			<umb-body-layout>
+				<div class="layout">
+					${this.renderStatus()} ${this.renderDetails()} ${this.renderSubscription()}
+					${this.renderExpiration()}
+				</div></umb-body-layout
+			>
+		`;
+    }
+    renderStatus() {
+        return html `
+			<usync-licence-status .licenceStatus=${this.licenceStatus}></usync-licence-status>
+		`;
+    }
+    renderDetails() {
+        return this.licenceStatus
+            ? html `
+					<uui-box headline="uSync.Complete.Licence">
+						<div slot="header-actions">
+							<uui-button
+								type="button"
+								look="outline"
+								color="danger"
+								label="Clear"
+								@click=${__classPrivateFieldGet(this, _uSyncLicenceViewElement_instances, "m", _uSyncLicenceViewElement_clearLicence)}></uui-button>
+						</div>
+						<div class="details">
+							<umb-property-layout
+								label="Domains"
+								alias="domains"
+								description="Domains licence applys to">
+								<div slot="editor">
+									<uui-input
+										label="domains"
+										@input=${__classPrivateFieldGet(this, _uSyncLicenceViewElement_instances, "m", _uSyncLicenceViewElement_updateDomains)}
+										.value=${this.licence.domains}
+										.readonly=${this.licenceStatus?.licenceType ===
+                'Subscription'}></uui-input>
+								</div>
+							</umb-property-layout>
+
+							<umb-property-layout
+								label="Licence Key"
+								alias="key"
+								description="Key for licence">
+								<div slot="editor">
+									<uui-input
+										label="key"
+										@input=${__classPrivateFieldGet(this, _uSyncLicenceViewElement_instances, "m", _uSyncLicenceViewElement_updateKey)}
+										.value=${this.licence.key}></uui-input>
+								</div>
+							</umb-property-layout>
+
+							<div class="actions">
+								<uui-button
+									look="primary"
+									color="positive"
+									label="Save"
+									.state=${this.saveState}
+									@click=${__classPrivateFieldGet(this, _uSyncLicenceViewElement_instances, "m", _uSyncLicenceViewElement_saveLicence)}></uui-button>
+							</div>
+						</div>
+					</uui-box>
+				`
+            : nothing;
+    }
+    renderSubscription() {
+        if (this.licenceStatus?.licenceType !== 'Subscription')
+            return nothing;
+        if (!this.licenceStatus?.expires)
+            return nothing;
+        const expiresDate = new Date(this.licenceStatus.expires);
+        if (expiresDate >= new Date('9999-12-30'))
+            return nothing;
+        return html `<uui-box headline="uSync.Complete.Subscription">
+			<umb-localize key="usynccomplete_licenceSubscriptionInfo"></umb-localize>
+			<uui-button
+				look="secondary"
+				color="positive"
+				href="https://jumoo.co.uk/resend?sub=${this.licence.key}"
+				target="_blank"
+				rel="noopener noreferrer"
+				>Request subscription details</uui-button
+			>
+		</uui-box>`;
+    }
+    renderExpiration() {
+        if (!this.licenceStatus?.expires)
+            return nothing;
+        const expiresDate = new Date(this.licenceStatus.expires);
+        if (expiresDate >= new Date('9999-12-30'))
+            return nothing;
+        const today = new Date();
+        const remainingDays = Math.ceil((expiresDate.getTime() - today.getTime()) / (1000 * 60 * 60 * 24));
+        if (expiresDate < today) {
+            return html `<uui-box class="alert alert-danger">
+				<umb-localize key="usynccomplete_licenceExpired"></umb-localize>
+			</uui-box>`;
+        }
+        return html `<uui-box
+			class="alert ${remainingDays <= 60 && !this.licenceStatus.autoRenews ? 'alert-warning' : 'alert-default'}"
+		">
+		<div class="alert-content">
+			<div>
+			<umb-localize
+				key="usynccomplete_licenceExpires"
+				.args=${[expiresDate.toDateString()]}></umb-localize>
+			<umb-localize
+				key="usynccomplete_licenceDaysLeft"
+				.args=${[remainingDays]}></umb-localize>
+				</div>
+
+				<div>
+			${when(this.licenceStatus.autoRenews, () => html `<umb-icon name="icon-check"></umb-icon
+						><umb-localize key="usynccomplete_licenceAutoRenews"></umb-localize>`, () => html `<umb-icon name="icon-alarm-clock"></umb-icon
+						><umb-localize key="usynccomplete_licenceNotAutoRenews"></umb-localize>`)}</div>
+			</div>
+		</uui-box>`;
+    }
+};
+_uSyncLicenceViewElement_licenceContext = new WeakMap();
+_uSyncLicenceViewElement_instances = new WeakSet();
+_uSyncLicenceViewElement_saveLicence = async function _uSyncLicenceViewElement_saveLicence() {
+    this.saveState = 'waiting';
+    await __classPrivateFieldGet(this, _uSyncLicenceViewElement_licenceContext, "f")?.saveLicence(this.licence);
+    this.saveState = 'success';
+};
+_uSyncLicenceViewElement_updateDomains = function _uSyncLicenceViewElement_updateDomains(e) {
+    const value = e.target.value;
+    this.licence.domains = value;
+    this.requestUpdate('licence');
+};
+_uSyncLicenceViewElement_updateKey = function _uSyncLicenceViewElement_updateKey(e) {
+    const value = e.target.value;
+    this.licence.key = value;
+};
+_uSyncLicenceViewElement_clearLicence = async function _uSyncLicenceViewElement_clearLicence() {
+    const modalManager = await this.getContext(UMB_MODAL_MANAGER_CONTEXT);
+    if (!modalManager)
+        return;
+    const confirmModal = modalManager.open(this, UMB_CONFIRM_MODAL, {
+        data: {
+            headline: this.localize.term('usynccomplete_licenceClearHeading'),
+            content: this.localize.term('usynccomplete_licenceClearContent'),
+            confirmLabel: this.localize.term('general_clear'),
+            color: 'danger',
+        },
+    });
+    confirmModal
+        .onSubmit()
+        .then(async () => {
+        await __classPrivateFieldGet(this, _uSyncLicenceViewElement_licenceContext, "f")?.saveLicence({ key: '', domains: '' });
+        this.requestUpdate('licence');
+    })
+        .catch(() => {
+        // console.log('cancel');
+    });
+};
+uSyncLicenceViewElement.styles = [
+    UmbTextStyles,
+    css `
+			.layout {
+				display: flex;
+				flex-direction: column;
+				gap: var(--uui-size-space-4);
+			}
+
+			uui-input {
+				width: 100%;
+			}
+
+			.actions {
+				padding-left: calc(200px + var(--uui-size-layout-2));
+			}
+
+			.alert-content {
+				display: flex;
+				justify-content: space-between;
+			}
+
+			.alert-content > div {
+				display: flex;
+				gap: 10px;
+			}
+
+			.alert-danger {
+				background-color: var(--uui-color-danger);
+				color: var(--uui-color-danger-contrast);
+			}
+
+			.alert-default {
+				background-color: var(--uui-color-default);
+				color: var(--uui-color-default-contrast);
+			}
+
+			.alert-warning {
+				background-color: var(--uui-color-warning);
+				color: var(--uui-color-warning-contrast);
+			}
+		`,
+];
+__decorate([
+    state()
+], uSyncLicenceViewElement.prototype, "saveState", void 0);
+__decorate([
+    state()
+], uSyncLicenceViewElement.prototype, "licence", void 0);
+__decorate([
+    state()
+], uSyncLicenceViewElement.prototype, "licenceStatus", void 0);
+uSyncLicenceViewElement = __decorate([
+    customElement('usync-licence-view')
+], uSyncLicenceViewElement);
+export { uSyncLicenceViewElement };
+export default uSyncLicenceViewElement;

package/dist/licence/licence.repository.d.ts

@@ -0,0 +1,15 @@
+import { UmbControllerBase } from '@umbraco-cms/backoffice/class-api';
+import { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
+import { LicenceInfo } from '@jumoo/usync-expansions';
+export declare class uSyncLicenceRepository extends UmbControllerBase {
+    #private;
+    product: string;
+    version: string;
+    constructor(host: UmbControllerHost);
+    checkLegacy(): Promise<import("@umbraco-cms/backoffice/repository").UmbDataSourceResponse<string>>;
+    getLicence(): Promise<import("@umbraco-cms/backoffice/repository").UmbDataSourceResponse<import("@jumoo/usync-expansions").Licence>>;
+    getLicenceInfo(): Promise<import("@umbraco-cms/backoffice/repository").UmbDataSourceResponse<LicenceInfo>>;
+    getLicenceStatus(): Promise<import("@umbraco-cms/backoffice/repository").UmbDataSourceResponse<import("@jumoo/usync-expansions").LicenceStatusView>>;
+    isLicenced(): Promise<import("@umbraco-cms/backoffice/repository").UmbDataSourceResponse<boolean>>;
+    saveLicence(licence: LicenceInfo): Promise<import("@umbraco-cms/backoffice/repository").UmbDataSourceResponse<boolean>>;
+}

package/dist/licence/licence.repository.js

@@ -0,0 +1,42 @@
+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 _uSyncLicenceRepository_licenceDataSource;
+import { UmbControllerBase } from '@umbraco-cms/backoffice/class-api';
+import { uSyncLicenceSource } from '@jumoo/usync-expansions';
+export class uSyncLicenceRepository extends UmbControllerBase {
+    constructor(host) {
+        super(host);
+        _uSyncLicenceRepository_licenceDataSource.set(this, void 0);
+        this.product = 'uSync.Complete';
+        this.version = '15.0.0';
+        __classPrivateFieldSet(this, _uSyncLicenceRepository_licenceDataSource, new uSyncLicenceSource(this), "f");
+    }
+    async checkLegacy() {
+        return __classPrivateFieldGet(this, _uSyncLicenceRepository_licenceDataSource, "f").checkLegacy(this.product, this.version);
+    }
+    async getLicence() {
+        return __classPrivateFieldGet(this, _uSyncLicenceRepository_licenceDataSource, "f").getLicence(this.product, this.version);
+    }
+    async getLicenceInfo() {
+        return __classPrivateFieldGet(this, _uSyncLicenceRepository_licenceDataSource, "f").getLicenceInfo(this.product, this.version);
+    }
+    async getLicenceStatus() {
+        return __classPrivateFieldGet(this, _uSyncLicenceRepository_licenceDataSource, "f").getLicenceStatus(this.product, this.version);
+    }
+    async isLicenced() {
+        return __classPrivateFieldGet(this, _uSyncLicenceRepository_licenceDataSource, "f").isLicenced(this.product, this.version);
+    }
+    async saveLicence(licence) {
+        return __classPrivateFieldGet(this, _uSyncLicenceRepository_licenceDataSource, "f").saveLicence(licence);
+    }
+}
+_uSyncLicenceRepository_licenceDataSource = new WeakMap();

package/dist/licence/manifest.d.ts

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

package/dist/licence/manifest.js

@@ -0,0 +1,31 @@
+import { manifests as localizations } from './lang/manifests.js';
+import './components/index.js';
+import { UMB_CURRENT_USER_IS_ADMIN_CONDITION_ALIAS } from '@umbraco-cms/backoffice/current-user';
+const licenceContext = {
+    type: 'globalContext',
+    alias: 'usync.licence.context',
+    name: 'uSync licence context',
+    js: () => import('./licence.context.js'),
+};
+const licenceView = {
+    type: 'workspaceView',
+    alias: 'usync-extensions-licence-view',
+    name: 'uSync Licence view',
+    js: () => import('./licence.element.js'),
+    weight: 100,
+    meta: {
+        label: 'Licence',
+        pathname: 'licence',
+        icon: 'icon-certificate',
+    },
+    conditions: [
+        {
+            alias: 'Umb.Condition.WorkspaceAlias',
+            match: 'usync.workspace',
+        },
+        {
+            alias: UMB_CURRENT_USER_IS_ADMIN_CONDITION_ALIAS,
+        },
+    ],
+};
+export const manifests = [licenceContext, licenceView, ...localizations];

package/dist/licence/source/licence.source.d.ts

@@ -0,0 +1,15 @@
+import { UmbDataSourceResponse } from '@umbraco-cms/backoffice/repository';
+import { Licence, LicenceInfo, LicenceStatusView } from '@jumoo/usync-expansions';
+import { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
+export interface uSyncLicenceSource {
+}
+export declare class uSyncLicenceSource implements uSyncLicenceSource {
+    #private;
+    constructor(host: UmbControllerHost);
+    checkLegacy(product: string, version: string): Promise<UmbDataSourceResponse<string>>;
+    getLicence(product: string, version: string): Promise<UmbDataSourceResponse<Licence>>;
+    getLicenceInfo(product: string, version: string): Promise<UmbDataSourceResponse<LicenceInfo>>;
+    getLicenceStatus(product: string, version: string): Promise<UmbDataSourceResponse<LicenceStatusView>>;
+    isLicenced(product: string, version: string): Promise<UmbDataSourceResponse<boolean>>;
+    saveLicence(licence: LicenceInfo): Promise<UmbDataSourceResponse<boolean>>;
+}

package/dist/licence/source/licence.source.js

@@ -0,0 +1,39 @@
+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 _uSyncLicenceSource_host;
+import { LicenceService, } from '@jumoo/usync-expansions';
+import { tryExecute } from '@umbraco-cms/backoffice/resources';
+export class uSyncLicenceSource {
+    constructor(host) {
+        _uSyncLicenceSource_host.set(this, void 0);
+        __classPrivateFieldSet(this, _uSyncLicenceSource_host, host, "f");
+    }
+    async checkLegacy(product, version) {
+        return await tryExecute(__classPrivateFieldGet(this, _uSyncLicenceSource_host, "f"), LicenceService.checkLegacy({ query: { product: product, version: version } }));
+    }
+    async getLicence(product, version) {
+        return await tryExecute(__classPrivateFieldGet(this, _uSyncLicenceSource_host, "f"), LicenceService.getLicence({ query: { product: product, version: version } }));
+    }
+    async getLicenceInfo(product, version) {
+        return await tryExecute(__classPrivateFieldGet(this, _uSyncLicenceSource_host, "f"), LicenceService.getLicence({ query: { product: product, version: version } }));
+    }
+    async getLicenceStatus(product, version) {
+        return await tryExecute(__classPrivateFieldGet(this, _uSyncLicenceSource_host, "f"), LicenceService.getLicenceStatus({ query: { product: product, version: version } }));
+    }
+    async isLicenced(product, version) {
+        return await tryExecute(__classPrivateFieldGet(this, _uSyncLicenceSource_host, "f"), LicenceService.isLicenced({ query: { product: product, version: version } }));
+    }
+    async saveLicence(licence) {
+        return await tryExecute(__classPrivateFieldGet(this, _uSyncLicenceSource_host, "f"), LicenceService.saveLicence({ body: licence }));
+    }
+}
+_uSyncLicenceSource_host = new WeakMap();

package/dist/menu/manifest.d.ts

@@ -0,0 +1 @@
+export declare const manifests: import("@jumoo/usync").ManifestuSyncMenuItem[];

package/dist/menu/manifest.js

@@ -0,0 +1,12 @@
+const menuItem = {
+    type: 'usync-menuItem',
+    alias: 'usync.menu.extensions',
+    name: 'extensions',
+    meta: {
+        label: 'Extensions',
+        icon: 'icon-brick',
+        entityType: 'usync-menu-entry',
+        menus: ['usync.menu'],
+    },
+};
+export const manifests = [menuItem];

package/dist/restore/components/index.d.ts

@@ -0,0 +1 @@
+export * from './restore-point-table.element';

package/dist/restore/components/index.js

@@ -0,0 +1 @@
+export * from './restore-point-table.element';

package/dist/restore/components/restore-point-table.element.d.ts

@@ -0,0 +1,21 @@
+import { nothing } from '@umbraco-cms/backoffice/external/lit';
+import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
+import { RestorePoint } from '@jumoo/usync-expansions';
+import { UmbTableColumn, UmbTableConfig } from '@umbraco-cms/backoffice/components';
+/**
+ * @element usync-restore-point-table
+ * @property {Array<RestorePoint>} restorePoints - The restore points to display
+ * @fires delete-restore-point - When the delete options is selected
+ * @fires restore-restore-point - When the restore options is selected
+ */
+export declare class uSyncRestorePointTableElement extends UmbLitElement {
+    #private;
+    restorePoints?: RestorePoint[];
+    _tableConfig: UmbTableConfig;
+    _tableColumns: UmbTableColumn[];
+    filter: any;
+    render(): typeof nothing | import("lit-html").TemplateResult<1>;
+    renderStatus(restorePoint: RestorePoint): import("lit-html").TemplateResult<1>;
+    renderActions(restorePoint: RestorePoint): import("lit-html").TemplateResult<1>;
+}
+export default uSyncRestorePointTableElement;

package/dist/restore/components/restore-point-table.element.js

@@ -0,0 +1,126 @@
+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 __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 _uSyncRestorePointTableElement_instances, _uSyncRestorePointTableElement_onDelete, _uSyncRestorePointTableElement_onRestore;
+import { customElement, html, nothing, property, state, } from '@umbraco-cms/backoffice/external/lit';
+import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
+import { RestorePointStatus } from '@jumoo/usync-expansions';
+import { TimeOptions } from '@jumoo/usync-expansions';
+/**
+ * @element usync-restore-point-table
+ * @property {Array<RestorePoint>} restorePoints - The restore points to display
+ * @fires delete-restore-point - When the delete options is selected
+ * @fires restore-restore-point - When the restore options is selected
+ */
+let uSyncRestorePointTableElement = class uSyncRestorePointTableElement extends UmbLitElement {
+    constructor() {
+        super(...arguments);
+        _uSyncRestorePointTableElement_instances.add(this);
+        this._tableConfig = {
+            allowSelection: false,
+            hideIcon: false,
+        };
+        this._tableColumns = [
+            { name: 'Created', alias: 'created' },
+            { name: 'Name', alias: 'name' },
+            { name: 'Source', alias: 'action' },
+            { name: 'User', alias: 'user' },
+            { name: 'Status', alias: 'status' },
+            { name: '', alias: 'actions' },
+        ];
+    }
+    render() {
+        if (!this.restorePoints || this.restorePoints.length === 0)
+            return nothing;
+        const items = this.restorePoints
+            .map((restorePoint) => {
+            if (!restorePoint)
+                return undefined;
+            return {
+                id: restorePoint.key,
+                icon: 'icon-pushpin',
+                data: [
+                    {
+                        columnAlias: 'created',
+                        value: this.localize.date(restorePoint.created, TimeOptions),
+                    },
+                    { columnAlias: 'name', value: restorePoint.name },
+                    { columnAlias: 'action', value: restorePoint.action },
+                    { columnAlias: 'user', value: restorePoint.user },
+                    { columnAlias: 'status', value: html `${this.renderStatus(restorePoint)}` },
+                    { columnAlias: 'actions', value: html `${this.renderActions(restorePoint)}` },
+                ],
+            };
+        })
+            .filter((item) => item !== undefined);
+        return html `<umb-table
+			.config=${this._tableConfig}
+			.columns=${this._tableColumns}
+			.items=${items}
+			.filter=${this.filter}></umb-table>`;
+    }
+    renderStatus(restorePoint) {
+        switch (restorePoint.status) {
+            case RestorePointStatus.PENDING:
+                return html `<uui-tag color="warning" look="secondary">Compressing</uui-tag>`;
+            case RestorePointStatus.FAILED:
+                return html `<uui-tag color="danger" look="secondary">Failed</uui-tag>`;
+            case RestorePointStatus.COMPLETE:
+            default:
+                return html `<uui-tag color="positive" look="secondary">Complete</uui-tag>`;
+        }
+    }
+    renderActions(restorePoint) {
+        const isComplete = restorePoint.status === RestorePointStatus.COMPLETE || restorePoint.status === undefined;
+        return html ` <uui-button
+				compact
+				label="restore"
+				color="positive"
+				look="default"
+				?disabled=${!isComplete}
+				@click=${() => __classPrivateFieldGet(this, _uSyncRestorePointTableElement_instances, "m", _uSyncRestorePointTableElement_onRestore).call(this, restorePoint)}>
+				<uui-icon name="icon-paper-plane"></uui-icon>
+			</uui-button>
+
+			<uui-button
+				compact
+				label="delete"
+				color="danger"
+				look="default"
+				@click=${() => __classPrivateFieldGet(this, _uSyncRestorePointTableElement_instances, "m", _uSyncRestorePointTableElement_onDelete).call(this, restorePoint)}>
+				<uui-icon name="icon-trash"></uui-icon>
+			</uui-button>`;
+    }
+};
+_uSyncRestorePointTableElement_instances = new WeakSet();
+_uSyncRestorePointTableElement_onDelete = function _uSyncRestorePointTableElement_onDelete(restorePoint) {
+    this.dispatchEvent(new CustomEvent('delete-restore-point', { detail: restorePoint }));
+};
+_uSyncRestorePointTableElement_onRestore = function _uSyncRestorePointTableElement_onRestore(restorePoint) {
+    this.dispatchEvent(new CustomEvent('restore-restore-point', { detail: restorePoint }));
+};
+__decorate([
+    property({ type: Array })
+], uSyncRestorePointTableElement.prototype, "restorePoints", void 0);
+__decorate([
+    state()
+], uSyncRestorePointTableElement.prototype, "_tableConfig", void 0);
+__decorate([
+    state()
+], uSyncRestorePointTableElement.prototype, "_tableColumns", void 0);
+__decorate([
+    state()
+], uSyncRestorePointTableElement.prototype, "filter", void 0);
+uSyncRestorePointTableElement = __decorate([
+    customElement('usync-restore-point-table')
+], uSyncRestorePointTableElement);
+export { uSyncRestorePointTableElement };
+export default uSyncRestorePointTableElement;

package/dist/restore/constants.d.ts

@@ -0,0 +1,23 @@
+export declare const uSyncRestore: {
+    workspace: string;
+    context: string;
+    entity: string;
+    element: string;
+    icon: string;
+    processing: {
+        pipeline: string;
+        strategies: {
+            create: string;
+            restore: string;
+            report: string;
+            createAndRestore: string;
+        };
+    };
+    steps: {
+        restoreCreateStep: string;
+        restoreCreateComplete: string;
+        restoreReportConfigStep: string;
+        restoreReportStep: string;
+    };
+};
+export declare const TimeOptions: Intl.DateTimeFormatOptions;

package/dist/restore/constants.js

@@ -0,0 +1,30 @@
+export const uSyncRestore = {
+    workspace: 'usync.restore.workspace',
+    context: 'usync.restore.workspace.context',
+    entity: 'usync-restore-entry',
+    element: 'usync-restore-workspace-element',
+    icon: 'icon-paper-plane',
+    processing: {
+        pipeline: 'restorePointsPipeline',
+        strategies: {
+            create: 'restorePointCreate',
+            restore: 'restorePointRestore',
+            report: 'restorePointReport',
+            createAndRestore: 'restorePointCreateAndRestore',
+        },
+    },
+    steps: {
+        restoreCreateStep: 'usync-restore-create-config',
+        restoreCreateComplete: 'usync-restore-create-complete',
+        restoreReportConfigStep: 'usync-restore-report-config',
+        restoreReportStep: 'usync-restore-report',
+    },
+};
+export const TimeOptions = {
+    year: 'numeric',
+    month: 'long',
+    day: 'numeric',
+    hour: 'numeric',
+    minute: 'numeric',
+    second: 'numeric',
+};

package/dist/restore/index.d.ts

@@ -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';