@jumoo/usync 0.0.0-stage → 18.2.0

package/dist/workspace/types.d.ts

@@ -0,0 +1,12 @@
+import { SyncActionGroup } from '@jumoo/uSync';
+/**
+ * Options passed to the performAction method on the workspace context
+ */
+export type SyncPerformActionOptions = {
+    setName: string;
+    group: SyncActionGroup;
+    action: string;
+    force: boolean;
+    clean: boolean;
+    file: boolean;
+};

package/dist/workspace/types.js

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

package/dist/workspace/views/addons/addons.element.d.ts

@@ -0,0 +1,7 @@
+import { LitElement } from '@umbraco-cms/backoffice/external/lit';
+declare const uSyncAddOnsElement_base: import("@umbraco-cms/backoffice/extension-api").HTMLElementConstructor<import("@umbraco-cms/backoffice/element-api").UmbElement> & typeof LitElement;
+export declare class uSyncAddOnsElement extends uSyncAddOnsElement_base {
+    render(): import("lit-html").TemplateResult<1>;
+    static styles: import("lit").CSSResult;
+}
+export default uSyncAddOnsElement;

package/dist/workspace/views/addons/addons.element.js

@@ -0,0 +1,117 @@
+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 { UmbElementMixin } from '@umbraco-cms/backoffice/element-api';
+import { LitElement, css, customElement, html, } from '@umbraco-cms/backoffice/external/lit';
+const logo = '/App_Plugins/uSync/img/usync-complete.png';
+let uSyncAddOnsElement = class uSyncAddOnsElement extends UmbElementMixin(LitElement) {
+    render() {
+        return html `
+			<umb-body-layout>
+				<div class="addon-view">
+					<div>
+						<div class="header">
+							<img src=${logo} />
+							<h1>uSync Complete</h1>
+							<p>
+								uSync Complete gives you total control over your Umbraco settings and
+								content.
+							</p>
+						</div>
+
+						<div class="logos">
+							<div class="logo">
+								<uui-icon name="icon-shift"></uui-icon>
+								<h4>publish</h4>
+							</div>
+							<div class="logo">
+								<uui-icon name="icon-compress"></uui-icon>
+								<h4>export</h4>
+							</div>
+							<div class="logo">
+								<uui-icon name="icon-connection"></uui-icon>
+								<h4>snapshot</h4>
+							</div>
+							<div class="logo">
+								<uui-icon name="icon-undo"></uui-icon>
+								<h4>restore</h4>
+							</div>
+							<div class="logo">
+								<uui-icon name="icon-operator"></uui-icon>
+								<h4>people</h4>
+							</div>
+						</div>
+
+						<div class="cta">
+							<uui-button
+								href="https://jumoo.co.uk/uSync/complete/"
+								target="_blank"
+								color="positive"
+								look="primary"
+								label="Find out more"></uui-button>
+						</div>
+					</div>
+				</div>
+			</umb-body-layout>
+		`;
+    }
+};
+uSyncAddOnsElement.styles = css `
+		umb-body-layout {
+			// background: linear-gradient(#e3e3f1,#f6f4f4);
+			background: linear-gradient(var(--uui-color-background), var(--uui-color-border));
+		}
+
+		.addon-view {
+			display: flex;
+			justify-content: center;
+			align-items: center;
+			height: 100%;
+		}
+
+		.addon-view > div {
+			margin-top: -15vh;
+		}
+
+		.header,
+		.cta {
+			display: flex;
+			flex-direction: column;
+			align-items: center;
+		}
+
+		.header {
+			font-size: larger;
+			margin-bottom: var(--uui-size-space-6);
+		}
+
+		.logos {
+			display: flex;
+			justify-content: space-between;
+			font-size: var(--uui-type-h3-size);
+		}
+
+		.logo {
+			display: flex;
+			flex-direction: column;
+			align-items: center;
+			margin: var(--uui-size-space-2) var(--uui-size-space-6);
+			color: var(--uui-color-text-alt);
+		}
+
+		.cta {
+			margin: var(--uui-size-space-6) 0;
+		}
+
+		uui-button {
+			font-size: var(--uui-type-h4-size);
+		}
+	`;
+uSyncAddOnsElement = __decorate([
+    customElement('usync-addons-view')
+], uSyncAddOnsElement);
+export { uSyncAddOnsElement };
+export default uSyncAddOnsElement;

package/dist/workspace/views/default/default.element.d.ts

@@ -0,0 +1,31 @@
+import { UUIButtonState } from '@umbraco-cms/backoffice/external/uui';
+import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
+import { SyncActionGroup, SyncHandlerSummary, SyncLegacyCheckResponse, USyncActionView, SyncSelectableSet, SyncFileVersionCheckResult } from '@jumoo/uSync';
+export declare class uSyncDefaultViewElement extends UmbLitElement {
+    #private;
+    _actions?: Array<SyncActionGroup>;
+    _workingActions?: Array<SyncHandlerSummary>;
+    _loaded: Boolean;
+    _legacy?: SyncLegacyCheckResponse;
+    _syncFileInfo?: SyncFileVersionCheckResult;
+    _buttonState: UUIButtonState;
+    _working: boolean;
+    _completed: boolean;
+    _inBackground: boolean;
+    _connected: boolean;
+    _showProgress: boolean;
+    _group?: SyncActionGroup;
+    _results: Array<USyncActionView>;
+    _disabled: boolean;
+    _setName: string;
+    _sets: Array<SyncSelectableSet>;
+    constructor();
+    render(): import("lit-html").TemplateResult<1>;
+    static styles: import("lit").CSSResult[];
+}
+export default uSyncDefaultViewElement;
+declare global {
+    interface HTMLElementTagNameMap {
+        'usync-default-view': uSyncDefaultViewElement;
+    }
+}

package/dist/workspace/views/default/default.element.js

@@ -0,0 +1,466 @@
+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 _uSyncDefaultViewElement_instances, _uSyncDefaultViewElement_actionContext, _uSyncDefaultViewElement_refreshTrees, _uSyncDefaultViewElement_performAction, _uSyncDefaultViewElement_renderSetPicker, _uSyncDefaultViewElement_renderLegacyBanner, _uSyncDefaultViewElement_renderSyncFileInfo, _uSyncDefaultViewElement_renderActions, _uSyncDefaultViewElement_renderBanner, _uSyncDefaultViewElement_renderProcessBox, _uSyncDefaultViewElement_renderReport, _uSyncDefaultViewElement_renderBackgroundBanner, _uSyncDefaultViewElement_renderDismissBackgroundRun;
+import { css, customElement, html, nothing, state, } from '@umbraco-cms/backoffice/external/lit';
+import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
+import { USYNC_CORE_CONTEXT_TOKEN, USYNC_SIGNALR_CONTEXT_TOKEN, } from '@jumoo/uSync';
+import { UmbRequestReloadChildrenOfEntityEvent } from '@umbraco-cms/backoffice/entity-action';
+import { UMB_ACTION_EVENT_CONTEXT } from '@umbraco-cms/backoffice/action';
+import { UMB_DOCUMENT_TYPE_ROOT_ENTITY_TYPE } from '@umbraco-cms/backoffice/document-type';
+import { UMB_MEDIA_TYPE_ROOT_ENTITY_TYPE } from '@umbraco-cms/backoffice/media-type';
+import { UMB_TEMPLATE_ROOT_ENTITY_TYPE } from '@umbraco-cms/backoffice/template';
+import { UMB_DATA_TYPE_ROOT_ENTITY_TYPE } from '@umbraco-cms/backoffice/data-type';
+import { UMB_MEMBER_TYPE_ROOT_ENTITY_TYPE } from '@umbraco-cms/backoffice/member-type';
+import { UMB_STYLESHEET_ROOT_ENTITY_TYPE } from '@umbraco-cms/backoffice/stylesheet';
+import { UMB_PARTIAL_VIEW_ROOT_ENTITY_TYPE } from '@umbraco-cms/backoffice/partial-view';
+import { UMB_SCRIPT_ROOT_ENTITY_TYPE } from '@umbraco-cms/backoffice/script';
+let uSyncDefaultViewElement = class uSyncDefaultViewElement extends UmbLitElement {
+    constructor() {
+        super();
+        _uSyncDefaultViewElement_instances.add(this);
+        _uSyncDefaultViewElement_actionContext.set(this, void 0);
+        this._loaded = false;
+        this._working = false;
+        this._completed = false;
+        this._inBackground = false;
+        this._connected = false;
+        this._showProgress = false;
+        this._results = [];
+        this._disabled = false;
+        this._setName = 'Default';
+        this._sets = [];
+        this.consumeContext(USYNC_SIGNALR_CONTEXT_TOKEN, (_signalR) => {
+            if (!_signalR)
+                return;
+            this.observe(_signalR.connected, (_connected) => {
+                this._connected = _connected;
+            });
+        });
+        this.consumeContext(USYNC_CORE_CONTEXT_TOKEN, (_instance) => {
+            if (!_instance)
+                return;
+            __classPrivateFieldSet(this, _uSyncDefaultViewElement_actionContext, _instance, "f");
+            _instance.getSettings();
+            this.observe(_instance.settings, (_settings) => {
+                if (!_settings)
+                    return;
+                this._setName = _settings.defaultSet ?? 'Default';
+                __classPrivateFieldGet(this, _uSyncDefaultViewElement_actionContext, "f")?.checkLegacy();
+                __classPrivateFieldGet(this, _uSyncDefaultViewElement_actionContext, "f")?.getHandlerSets();
+                __classPrivateFieldGet(this, _uSyncDefaultViewElement_actionContext, "f")?.getSyncFileInfo();
+            });
+            this.observe(_instance.sets, (sets) => {
+                if (!sets)
+                    return;
+                this._sets = sets;
+                __classPrivateFieldGet(this, _uSyncDefaultViewElement_actionContext, "f")?.getActions(this._setName);
+            });
+            this.observe(_instance.actions, (_actions) => {
+                if (!_actions || _actions.length == 0)
+                    return;
+                this._actions = _actions;
+                this._loaded = this._actions !== null;
+            });
+            this.observe(_instance.currentAction, (_currentAction) => {
+                this._workingActions = _currentAction;
+            });
+            this.observe(_instance.working, (_working) => {
+                this._working = _working;
+                if (this._working) {
+                    this._buttonState = 'waiting';
+                    this._disabled = true;
+                }
+                else {
+                    this._disabled = false;
+                }
+            });
+            this.observe(_instance.results, (_results) => {
+                this._results = _results;
+            });
+            this.observe(_instance.completed, async (_completed) => {
+                this._completed = _completed;
+                if (this._completed) {
+                    this._buttonState = 'success';
+                    await __classPrivateFieldGet(this, _uSyncDefaultViewElement_instances, "m", _uSyncDefaultViewElement_refreshTrees).call(this);
+                }
+            });
+            this.observe(_instance.legacy, (_legacy) => {
+                this._legacy = _legacy;
+            });
+            this.observe(_instance.syncFileInfo, (_syncFileInfo) => {
+                this._syncFileInfo = _syncFileInfo;
+            });
+            this.observe(_instance.inBackground, (_inBackground) => {
+                this._inBackground = _inBackground;
+            });
+            this.observe(_instance.workingGroup, (_workingGroup) => {
+                if (_workingGroup) {
+                    this._group = _workingGroup;
+                }
+            });
+        });
+    }
+    render() {
+        if (this._loaded == false) {
+            return html `<uui-loader></uui-loader>`;
+        }
+        else {
+            return html `
+				<umb-body-layout>
+					${__classPrivateFieldGet(this, _uSyncDefaultViewElement_instances, "m", _uSyncDefaultViewElement_renderBackgroundBanner).call(this)}
+					${__classPrivateFieldGet(this, _uSyncDefaultViewElement_instances, "m", _uSyncDefaultViewElement_renderSyncFileInfo).call(this)} ${__classPrivateFieldGet(this, _uSyncDefaultViewElement_instances, "m", _uSyncDefaultViewElement_renderLegacyBanner).call(this)}
+					${__classPrivateFieldGet(this, _uSyncDefaultViewElement_instances, "m", _uSyncDefaultViewElement_renderSetPicker).call(this)}
+					<div class="wrapper">
+						${__classPrivateFieldGet(this, _uSyncDefaultViewElement_instances, "m", _uSyncDefaultViewElement_renderActions).call(this)} ${__classPrivateFieldGet(this, _uSyncDefaultViewElement_instances, "m", _uSyncDefaultViewElement_renderBanner).call(this)}
+						${__classPrivateFieldGet(this, _uSyncDefaultViewElement_instances, "m", _uSyncDefaultViewElement_renderProcessBox).call(this)}${__classPrivateFieldGet(this, _uSyncDefaultViewElement_instances, "m", _uSyncDefaultViewElement_renderReport).call(this)}
+					</div>
+				</umb-body-layout>
+			`;
+        }
+    }
+};
+_uSyncDefaultViewElement_actionContext = new WeakMap();
+_uSyncDefaultViewElement_instances = new WeakSet();
+_uSyncDefaultViewElement_refreshTrees = async function _uSyncDefaultViewElement_refreshTrees() {
+    const actionEventContext = await this.getContext(UMB_ACTION_EVENT_CONTEXT);
+    const refreshTypes = [
+        UMB_DOCUMENT_TYPE_ROOT_ENTITY_TYPE,
+        UMB_MEDIA_TYPE_ROOT_ENTITY_TYPE,
+        UMB_MEMBER_TYPE_ROOT_ENTITY_TYPE,
+        UMB_TEMPLATE_ROOT_ENTITY_TYPE,
+        UMB_DATA_TYPE_ROOT_ENTITY_TYPE,
+        UMB_STYLESHEET_ROOT_ENTITY_TYPE,
+        UMB_PARTIAL_VIEW_ROOT_ENTITY_TYPE,
+        UMB_SCRIPT_ROOT_ENTITY_TYPE,
+    ];
+    refreshTypes.forEach((type) => {
+        const event = new UmbRequestReloadChildrenOfEntityEvent({
+            entityType: type,
+            unique: null,
+        });
+        actionEventContext?.dispatchEvent(event);
+    });
+};
+_uSyncDefaultViewElement_performAction = function _uSyncDefaultViewElement_performAction(event) {
+    if (!event)
+        return;
+    this._showProgress = true;
+    __classPrivateFieldGet(this, _uSyncDefaultViewElement_actionContext, "f")?.performAction({
+        setName: this._setName,
+        group: event.group,
+        action: event.key,
+        force: event.force ?? false,
+        clean: event.clean ?? false,
+        file: event.file ?? false,
+    });
+};
+_uSyncDefaultViewElement_renderSetPicker = function _uSyncDefaultViewElement_renderSetPicker() {
+    if (this._sets.length < 2)
+        return nothing;
+    var options = this._sets.map((set) => {
+        return {
+            name: set.name,
+            value: set.name,
+            selected: set.name === this._setName,
+        };
+    });
+    return html `<div class="set-picker">
+			<label for="set-select"
+				>${this.localize.termOrDefault('USyncSettings_currentHandlerSet', 'Current Set')}</label
+			>
+			<uui-select
+				id="set-select"
+				.label=${this.localize.termOrDefault('USyncSettings_currentHandlerSet', 'Current Set')}
+				.options=${options}
+				@change=${(e) => {
+        const select = e.target;
+        this._setName = select.value;
+        __classPrivateFieldGet(this, _uSyncDefaultViewElement_actionContext, "f")?.getActions(this._setName);
+    }}>
+			</uui-select>
+		</div> `;
+};
+_uSyncDefaultViewElement_renderLegacyBanner = function _uSyncDefaultViewElement_renderLegacyBanner() {
+    return !this._legacy?.hasLegacy
+        ? nothing
+        : html `
+					<div class="legacy-banner">
+						<umb-icon name="icon-alert"></umb-icon>
+						${this.localize.termOrDefault('uSync_legacyBanner', 'This site contains files from a previous version of uSync, view the details in the legacy tab.')}
+					</div>
+				`;
+};
+_uSyncDefaultViewElement_renderSyncFileInfo = function _uSyncDefaultViewElement_renderSyncFileInfo() {
+    return nothing;
+    // TODO: We might show this info to the user here, but we need a nice way of turning it off,
+    // 			 if they have all the correct settings in place.
+    // if (this._syncFileInfo?.isCurrent && this._syncFileInfo?.hmacMatch) return nothing;
+    // return html`<usync-sync-file-info
+    // 	._syncFileInfo=${this._syncFileInfo}></usync-sync-file-info>`;
+};
+_uSyncDefaultViewElement_renderActions = function _uSyncDefaultViewElement_renderActions() {
+    if (!this._actions || !Array.isArray(this._actions))
+        return nothing;
+    var actions = this._actions?.map((group) => {
+        return html `
+				<usync-action-box
+					.disabled=${this._disabled}
+					.group="${group}"
+					.state=${this._buttonState}
+					@perform-action=${__classPrivateFieldGet(this, _uSyncDefaultViewElement_instances, "m", _uSyncDefaultViewElement_performAction)}>
+				</usync-action-box>
+			`;
+    });
+    return html ` <div class="action-buttons-box">${actions}</div> `;
+};
+_uSyncDefaultViewElement_renderBanner = function _uSyncDefaultViewElement_renderBanner() {
+    if (this._showProgress === true || this._completed === true)
+        return nothing;
+    return html `
+			<umb-empty-state>
+				<h2>
+					<uui-icon name="usync-logo"></uui-icon>
+					<umb-localize key="uSync_banner"></umb-localize>
+				</h2>
+			</umb-empty-state>
+		`;
+};
+_uSyncDefaultViewElement_renderProcessBox = function _uSyncDefaultViewElement_renderProcessBox() {
+    if (this._showProgress == false && this._completed == false)
+        return nothing;
+    return html `
+			<usync-progress-box
+				.title=${this._group?.groupName ?? 'doh!'}
+				.actions=${this._workingActions}
+				.complete=${this._completed}></usync-progress-box>
+		`;
+};
+_uSyncDefaultViewElement_renderReport = function _uSyncDefaultViewElement_renderReport() {
+    if (!this._completed)
+        return nothing;
+    return html `<usync-results .results=${this._results}></usync-results>`;
+};
+_uSyncDefaultViewElement_renderBackgroundBanner = function _uSyncDefaultViewElement_renderBackgroundBanner() {
+    if (!this._inBackground || !this._working)
+        return nothing;
+    if (!this._connected) {
+        return html ` <uui-box class="banner warning">
+				<div class="banner-row">
+					<uui-icon name="icon-alert"></uui-icon>
+					<div class="banner-text">
+						${this.localize.termOrDefault('uSync_runningInBackground', 'uSync is running this process in background, if you navigate away from this page it will continue to run.')}
+						<br />
+						${this.localize.termOrDefault('uSync_connectionLost', 'the connection to the server has been lost, the process will continue to run in the background but you will not see updates here.')}
+					</div>
+					${__classPrivateFieldGet(this, _uSyncDefaultViewElement_instances, "m", _uSyncDefaultViewElement_renderDismissBackgroundRun).call(this)}
+				</div>
+			</uui-box>`;
+    }
+    return html `<uui-box class="banner info">
+			<div class="banner-row">
+				<uui-icon name="icon-info"></uui-icon>
+				<div class="banner-text">
+					${this.localize.termOrDefault('uSync_runningInBackground', 'uSync is running this process in background, if you navigate away from this page it will continue to run.')}
+				</div>
+				${__classPrivateFieldGet(this, _uSyncDefaultViewElement_instances, "m", _uSyncDefaultViewElement_renderDismissBackgroundRun).call(this)}
+			</div>
+		</uui-box>`;
+};
+_uSyncDefaultViewElement_renderDismissBackgroundRun = function _uSyncDefaultViewElement_renderDismissBackgroundRun() {
+    return html `
+			<uui-button
+				class="dismiss"
+				look="secondary"
+				compact
+				label=${this.localize.termOrDefault('uSync_dismissBackgroundRun', 'Not actually running? Reset this view')}
+				@click=${() => __classPrivateFieldGet(this, _uSyncDefaultViewElement_actionContext, "f")?.dismissBackgroundRun()}>
+				<uui-icon name="icon-remove"></uui-icon>
+			</uui-button>
+		`;
+};
+uSyncDefaultViewElement.styles = [
+    css `
+			:host {
+				display: block;
+				// margin-top: calc(var(--uui-size-space-4) * -1);
+			}
+
+			.wrapper {
+				display: flex;
+				flex-direction: column;
+				gap: var(--uui-size-space-4);
+			}
+
+			.legacy-banner {
+				display: flex;
+				gap: var(--uui-size-space-2);
+				padding: var(--uui-size-space-4);
+				margin: var(--uui-size-space-4) 0;
+				background-color: var(--uui-color-warning);
+				color: var(--uui-color-warning-contrast);
+			}
+
+			.results-box {
+				position: relative;
+				display: block;
+				z-index: 1;
+			}
+
+			.action-buttons-box {
+				display: grid;
+				grid-template-columns: repeat(auto-fit, minmax(370px, 1fr));
+				position: relative;
+				gap: var(--uui-size-space-4);
+				flex-wrap: wrap;
+				align-content: stretch;
+				z-index: 1;
+			}
+
+			umb-empty-state {
+				position: absolute;
+				top: 50%;
+				transform: translateY(-50%);
+				left: 0;
+				right: 0;
+				margin: 0 auto;
+				text-align: center;
+				color: var(--uui-color-border);
+				z-index: 0;
+			}
+
+			umb-empty-state h2 {
+				font-size: var(--uui-type-h2-size);
+			}
+
+			umb-empty-state uui-icon {
+				position: relative;
+				top: var(--uui-size-2);
+			}
+
+			.set-picker {
+				display: flex;
+				flex-direction: row;
+				align-items: center;
+				justify-content: flex-end;
+				gap: var(--uui-size-space-2);
+				margin-bottom: var(--uui-size-space-4);
+				border: 1px solid var(--uui-color-border);
+				padding: var(--uui-size-space-4);
+			}
+
+			.set-picker label {
+				font-weight: 700;
+			}
+
+			.set-picker label::after {
+				content: ':';
+			}
+
+			.info {
+				background-color: var(--uui-color-positive);
+				color: var(--uui-color-positive-contrast);
+			}
+
+			.banner-row {
+				display: flex;
+				align-items: flex-start;
+				gap: var(--uui-size-space-3);
+			}
+
+			.banner-text {
+				flex: 1 1 auto;
+			}
+
+			.banner-row uui-button.dismiss {
+				flex: 0 0 auto;
+				margin: calc(var(--uui-size-space-2) * -1) calc(var(--uui-size-space-2) * -1) 0 0;
+				/* blend into the alert - same colour as its background/text, so it
+				   doesn't draw attention unless someone's actually looking for it */
+				color: inherit;
+				--uui-button-background-color: transparent;
+				--uui-button-background-color-hover: rgb(0 0 0 / 8%);
+				--uui-button-contrast: currentColor;
+				--uui-button-contrast-hover: currentColor;
+				--uui-button-border-color: transparent;
+				--uui-button-border-color-hover: transparent;
+			}
+
+			.banner {
+				display: block;
+				margin-bottom: var(--uui-size-space-4);
+			}
+
+			.warning {
+				background-color: var(--uui-color-warning);
+				color: var(--uui-color-warning-contrast);
+			}
+		`,
+];
+__decorate([
+    state()
+], uSyncDefaultViewElement.prototype, "_actions", void 0);
+__decorate([
+    state()
+], uSyncDefaultViewElement.prototype, "_workingActions", void 0);
+__decorate([
+    state()
+], uSyncDefaultViewElement.prototype, "_loaded", void 0);
+__decorate([
+    state()
+], uSyncDefaultViewElement.prototype, "_legacy", void 0);
+__decorate([
+    state()
+], uSyncDefaultViewElement.prototype, "_syncFileInfo", void 0);
+__decorate([
+    state()
+], uSyncDefaultViewElement.prototype, "_buttonState", void 0);
+__decorate([
+    state()
+], uSyncDefaultViewElement.prototype, "_working", void 0);
+__decorate([
+    state()
+], uSyncDefaultViewElement.prototype, "_completed", void 0);
+__decorate([
+    state()
+], uSyncDefaultViewElement.prototype, "_inBackground", void 0);
+__decorate([
+    state()
+], uSyncDefaultViewElement.prototype, "_connected", void 0);
+__decorate([
+    state()
+], uSyncDefaultViewElement.prototype, "_showProgress", void 0);
+__decorate([
+    state()
+], uSyncDefaultViewElement.prototype, "_group", void 0);
+__decorate([
+    state()
+], uSyncDefaultViewElement.prototype, "_results", void 0);
+__decorate([
+    state()
+], uSyncDefaultViewElement.prototype, "_disabled", void 0);
+__decorate([
+    state()
+], uSyncDefaultViewElement.prototype, "_setName", void 0);
+__decorate([
+    state()
+], uSyncDefaultViewElement.prototype, "_sets", void 0);
+uSyncDefaultViewElement = __decorate([
+    customElement('usync-default-view')
+], uSyncDefaultViewElement);
+export { uSyncDefaultViewElement };
+export default uSyncDefaultViewElement;

package/dist/workspace/views/legacy/legacy.element.d.ts

@@ -0,0 +1,14 @@
+import { nothing } from '@umbraco-cms/backoffice/external/lit';
+import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
+import { SyncLegacyCheckResponse } from '@jumoo/uSync';
+export declare class SyncLegacyFilesElement extends UmbLitElement {
+    #private;
+    _legacy?: SyncLegacyCheckResponse;
+    constructor();
+    render(): import("lit-html").TemplateResult<1>;
+    renderLegacyNote(): import("lit-html").TemplateResult<1>;
+    renderLegacyTypes(legacyTypes: Array<string> | undefined): typeof nothing | import("lit-html").TemplateResult<1>;
+    renderActions(): import("lit-html").TemplateResult<1>;
+    static styles: import("lit").CSSResult;
+}
+export default SyncLegacyFilesElement;