@jumoo/usync-expansions 0.0.0-stage → 18.3.0

package/dist/licence/components/licence-notice.js

@@ -0,0 +1,55 @@
+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 { css, customElement, html, nothing, state, } from '@umbraco-cms/backoffice/external/lit';
+import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
+import { JumooLicenceStyles } from './styles';
+import { USYNC_LICENCE_CONTEXT_TOKEN } from '../licence.context';
+let uSyncLicenceNoticeElement = class uSyncLicenceNoticeElement extends UmbLitElement {
+    constructor() {
+        super();
+        this.licenceStatus = undefined;
+        this.consumeContext(USYNC_LICENCE_CONTEXT_TOKEN, (_context) => {
+            if (!_context)
+                return;
+            this.observe(_context.licenceStatus, async (_status) => {
+                if (!this.licenceStatus)
+                    await _context.getLicenceStatus();
+                this.licenceStatus = _status;
+            });
+        });
+    }
+    render() {
+        if (this.licenceStatus == undefined)
+            return nothing;
+        if (this.licenceStatus?.status == 'Valid')
+            return nothing;
+        const status = this.licenceStatus.status;
+        const messageString = `usynccomplete_licence${status}`;
+        const className = status.toLowerCase();
+        const icon = status === 'Invalid' ? 'icon-wrong' : 'icon-alert';
+        return html `<div class="licence-alert ${className}">
+			<uui-icon .name=${icon}></uui-icon>
+			<umb-localize key="${messageString}"></umb-localize>
+		</div>`;
+    }
+};
+uSyncLicenceNoticeElement.styles = [
+    JumooLicenceStyles,
+    css `
+			.licence-alert {
+				display: block;
+			}
+		`,
+];
+__decorate([
+    state()
+], uSyncLicenceNoticeElement.prototype, "licenceStatus", void 0);
+uSyncLicenceNoticeElement = __decorate([
+    customElement('usync-licence-notice')
+], uSyncLicenceNoticeElement);
+export { uSyncLicenceNoticeElement };
+export default uSyncLicenceNoticeElement;

package/dist/licence/components/licence-status.view.d.ts

@@ -0,0 +1,14 @@
+import { LitElement, nothing } from '@umbraco-cms/backoffice/external/lit';
+import { LicenceStatusView } from '@jumoo/usync-expansions';
+declare const uSyncLicenceStatusView_base: import("@umbraco-cms/backoffice/extension-api").HTMLElementConstructor<import("@umbraco-cms/backoffice/element-api").UmbElement> & typeof LitElement;
+export declare class uSyncLicenceStatusView extends uSyncLicenceStatusView_base {
+    licenceStatus: LicenceStatusView | undefined;
+    render(): typeof nothing | import("lit-html").TemplateResult<1>;
+    static styles: import("lit").CSSResult[];
+}
+export default uSyncLicenceStatusView;
+declare global {
+    interface HtmlElementTagNameMap {
+        'usync-licence-status': uSyncLicenceStatusView;
+    }
+}

package/dist/licence/components/licence-status.view.js

@@ -0,0 +1,50 @@
+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, nothing, property, when, } from '@umbraco-cms/backoffice/external/lit';
+import { UmbTextStyles } from '@umbraco-cms/backoffice/style';
+import { JumooLicenceStyles } from './styles';
+let uSyncLicenceStatusView = class uSyncLicenceStatusView extends UmbElementMixin(LitElement) {
+    constructor() {
+        super(...arguments);
+        this.licenceStatus = undefined;
+    }
+    render() {
+        if (this.licenceStatus == undefined)
+            return nothing;
+        const className = this.licenceStatus?.status.toLocaleLowerCase();
+        const icon = this.licenceStatus?.status === 'Valid' ? 'icon-check' : 'icon-alert';
+        return html ` <div class="licence-alert ${className}">
+			<uui-icon .name=${icon}></uui-icon> ${this.licenceStatus?.message ??
+            'licenece is valid'}
+			${when(this.licenceStatus.link, () => html `<a
+						href="${this.licenceStatus?.link ?? '#'}"
+						target="_blank"
+						rel="noopener noreferrer"
+						>${this.licenceStatus?.linkTitle}</a
+					>`)}
+		</div>`;
+    }
+};
+uSyncLicenceStatusView.styles = [
+    UmbTextStyles,
+    JumooLicenceStyles,
+    css `
+			:host {
+				display: block;
+				margin-bottom: 10px;
+			}
+		`,
+];
+__decorate([
+    property({ type: Object })
+], uSyncLicenceStatusView.prototype, "licenceStatus", void 0);
+uSyncLicenceStatusView = __decorate([
+    customElement('usync-licence-status')
+], uSyncLicenceStatusView);
+export { uSyncLicenceStatusView };
+export default uSyncLicenceStatusView;

package/dist/licence/components/styles.d.ts

@@ -0,0 +1 @@
+export declare const JumooLicenceStyles: import("lit").CSSResult;

package/dist/licence/components/styles.js

@@ -0,0 +1,41 @@
+import { css } from '@umbraco-cms/backoffice/external/lit';
+export const JumooLicenceStyles = css `
+	.licence-alert {
+		padding: 20px;
+		border-radius: var(--uui-button-border-radius, var(--uui-border-radius, 3px));
+	}
+
+	uui-icon {
+		padding-right: 10px;
+		font-size: var(--uui-type-h4-size);
+	}
+
+	.valid {
+		background-color: var(--uui-color-positive);
+		color: var(--uui-color-positive-contrast);
+	}
+
+	.invalid,
+	.expired {
+		background-color: var(--uui-color-danger);
+		color: var(--uui-color-danger-contrast);
+	}
+
+	.trial {
+		background-color: var(--uui-color-warning);
+		color: var(--uui-color-warning-contrast);
+	}
+
+	.licence-alert a {
+		color: var(--uui-color-positive-contrast) !important;
+	}
+
+	.trial a {
+		color: var(--uui-color-warning-contrast) !important;
+	}
+
+	.invalid a,
+	.expired a {
+		color: var(--uui-color-danger-contrast) !important;
+	}
+`;

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

@@ -0,0 +1,17 @@
+declare const _default: {
+    usynccomplete: {
+        licenceValid: string;
+        licenceInvalid: string;
+        licenceTrial: string;
+        licenceExpired: string;
+        licenceExpires: string;
+        licenceDaysLeft: string;
+        licenceAutoRenews: string;
+        licenceNotAutoRenews: string;
+        licenceStatus: string;
+        licenceSubscriptionInfo: string;
+        licenceClearHeading: string;
+        licenceClearContent: string;
+    };
+};
+export default _default;

package/dist/licence/lang/en.js

@@ -0,0 +1,17 @@
+export default {
+    usynccomplete: {
+        licenceValid: 'Your licence is valid',
+        licenceInvalid: `Your licence is currently invalid - <a href="/umbraco/section/settings/workspace/usync-root/view/licence">Check licence</a>`,
+        licenceTrial: 'You are running a trial version of uSync.Complete',
+        licenceExpired: 'Your uSync.Complete licence has expired.',
+        licenceExpires: 'Your uSync.Complete licence expires on {0}.',
+        licenceDaysLeft: 'You have {0} days left on your licence.',
+        licenceAutoRenews: 'This licence will auto-renew at the end of the period.',
+        licenceNotAutoRenews: 'This licence does not auto-renew, You will need to renew it manually.',
+        licenceStatus: 'uSync.Complete licence status',
+        licenceSubscriptionInfo: `<p>Your subscription licence can be managed via the link sent to you when you purchased licence</p>
+			<p>For security reasons we don't show you that information in the umbraco back office but you can request that we send the details again</p>`,
+        licenceClearHeading: 'Clear licence details?',
+        licenceClearContent: 'Do you want to remove this current licence details? Once cleared you will need to re-enter your licence details.',
+    },
+};

package/dist/licence/lang/manifests.d.ts

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

package/dist/licence/lang/manifests.js

@@ -0,0 +1,13 @@
+const localizations = [
+    {
+        type: 'localization',
+        alias: 'usync.complete.en',
+        name: 'uSyncComplete Localizations English',
+        weight: 0,
+        js: () => import('./en.js'),
+        meta: {
+            culture: 'en',
+        },
+    },
+];
+export const manifests = [...localizations];

package/dist/licence/licence.context.d.ts

@@ -0,0 +1,17 @@
+import { UmbControllerBase } from '@umbraco-cms/backoffice/class-api';
+import { UmbContextToken } from '@umbraco-cms/backoffice/context-api';
+import { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
+import { Licence, LicenceInfo, LicenceStatusView } from '@jumoo/usync-expansions';
+import './components/licence-notice';
+export declare class uSyncLicenceContext extends UmbControllerBase {
+    #private;
+    readonly licence: import("rxjs").Observable<Licence | undefined>;
+    readonly licenceStatus: import("rxjs").Observable<LicenceStatusView | undefined>;
+    constructor(host: UmbControllerHost);
+    refresh(): Promise<void>;
+    saveLicence(licence: LicenceInfo): Promise<void>;
+    loadLicence(): Promise<void>;
+    getLicenceStatus(): Promise<void>;
+}
+export default uSyncLicenceContext;
+export declare const USYNC_LICENCE_CONTEXT_TOKEN: UmbContextToken<uSyncLicenceContext, uSyncLicenceContext>;

package/dist/licence/licence.context.js

@@ -0,0 +1,66 @@
+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 _uSyncLicenceContext_repository, _uSyncLicenceContext_notificationContext, _uSyncLicenceContext_licence, _uSyncLicenceContext_licenceStatus;
+import { UmbControllerBase } from '@umbraco-cms/backoffice/class-api';
+import { UmbContextToken } from '@umbraco-cms/backoffice/context-api';
+import { UmbObjectState } from '@umbraco-cms/backoffice/observable-api';
+import { UMB_NOTIFICATION_CONTEXT, } from '@umbraco-cms/backoffice/notification';
+import { uSyncLicenceRepository } from './licence.repository';
+import './components/licence-notice';
+export class uSyncLicenceContext extends UmbControllerBase {
+    constructor(host) {
+        super(host);
+        _uSyncLicenceContext_repository.set(this, void 0);
+        _uSyncLicenceContext_notificationContext.set(this, void 0);
+        _uSyncLicenceContext_licence.set(this, new UmbObjectState(undefined));
+        this.licence = __classPrivateFieldGet(this, _uSyncLicenceContext_licence, "f").asObservable();
+        _uSyncLicenceContext_licenceStatus.set(this, new UmbObjectState(undefined));
+        this.licenceStatus = __classPrivateFieldGet(this, _uSyncLicenceContext_licenceStatus, "f").asObservable();
+        this.consumeContext(UMB_NOTIFICATION_CONTEXT, (_instance) => {
+            __classPrivateFieldSet(this, _uSyncLicenceContext_notificationContext, _instance, "f");
+        });
+        __classPrivateFieldSet(this, _uSyncLicenceContext_repository, new uSyncLicenceRepository(this), "f");
+        this.provideContext(USYNC_LICENCE_CONTEXT_TOKEN, this);
+    }
+    async refresh() {
+        await this.loadLicence();
+        await this.getLicenceStatus();
+    }
+    async saveLicence(licence) {
+        const { data } = await __classPrivateFieldGet(this, _uSyncLicenceContext_repository, "f").saveLicence(licence);
+        if (data) {
+            await this.loadLicence();
+            await this.refresh();
+            __classPrivateFieldGet(this, _uSyncLicenceContext_notificationContext, "f")?.peek('positive', {
+                data: {
+                    headline: 'Licence saved',
+                    message: 'Licence has been saved',
+                },
+            });
+        }
+    }
+    async loadLicence() {
+        const { data } = await __classPrivateFieldGet(this, _uSyncLicenceContext_repository, "f").getLicence();
+        if (data) {
+            __classPrivateFieldGet(this, _uSyncLicenceContext_licence, "f").setValue(data);
+        }
+    }
+    async getLicenceStatus() {
+        const { data } = await __classPrivateFieldGet(this, _uSyncLicenceContext_repository, "f").getLicenceStatus();
+        if (data) {
+            __classPrivateFieldGet(this, _uSyncLicenceContext_licenceStatus, "f").setValue(data);
+        }
+    }
+}
+_uSyncLicenceContext_repository = new WeakMap(), _uSyncLicenceContext_notificationContext = new WeakMap(), _uSyncLicenceContext_licence = new WeakMap(), _uSyncLicenceContext_licenceStatus = new WeakMap();
+export default uSyncLicenceContext;
+export const USYNC_LICENCE_CONTEXT_TOKEN = new UmbContextToken('uSyncLicenceContext');

package/dist/licence/licence.element.d.ts

@@ -0,0 +1,19 @@
+import { LitElement, nothing } from '@umbraco-cms/backoffice/external/lit';
+import { LicenceInfo, LicenceStatusView } from '@jumoo/usync-expansions';
+import { UUIButtonState } from '@umbraco-cms/backoffice/external/uui';
+declare const uSyncLicenceViewElement_base: import("@umbraco-cms/backoffice/extension-api").HTMLElementConstructor<import("@umbraco-cms/backoffice/element-api").UmbElement> & typeof LitElement;
+export declare class uSyncLicenceViewElement extends uSyncLicenceViewElement_base {
+    #private;
+    saveState?: UUIButtonState;
+    constructor();
+    connectedCallback(): void;
+    licence: LicenceInfo;
+    licenceStatus: LicenceStatusView | undefined;
+    render(): import("lit-html").TemplateResult<1>;
+    renderStatus(): import("lit-html").TemplateResult<1>;
+    renderDetails(): typeof nothing | import("lit-html").TemplateResult<1>;
+    renderSubscription(): typeof nothing | import("lit-html").TemplateResult<1>;
+    renderExpiration(): typeof nothing | import("lit-html").TemplateResult<1>;
+    static styles: import("lit").CSSResult[];
+}
+export default uSyncLicenceViewElement;

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 { UmbTextStyles } from '@umbraco-cms/backoffice/style';
+import { UMB_CONFIRM_MODAL, UMB_MODAL_MANAGER_CONTEXT, } from '@umbraco-cms/backoffice/modal';
+import { USYNC_LICENCE_CONTEXT_TOKEN } from './licence.context';
+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 '../api';
+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("..").Licence>>;
+    getLicenceInfo(): Promise<import("@umbraco-cms/backoffice/repository").UmbDataSourceResponse<LicenceInfo>>;
+    getLicenceStatus(): Promise<import("@umbraco-cms/backoffice/repository").UmbDataSourceResponse<import("..").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 './source/licence.source';
+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 @@
+export declare const manifests: import("@umbraco-cms/backoffice/extension-api").ManifestBase[];