@jumoo/usync 0.0.0-stage → 18.2.0

package/dist/workspace/workspace.context.js

@@ -0,0 +1,448 @@
+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 _uSyncWorkspaceContext_instances, _uSyncWorkspaceContext_repository, _uSyncWorkspaceContext_signalRContext, _uSyncWorkspaceContext_pollTimer, _uSyncWorkspaceContext_lastSignalRMessageAt, _uSyncWorkspaceContext_pendingDownload, _uSyncWorkspaceContext_actions, _uSyncWorkspaceContext_workingGroup, _uSyncWorkspaceContext_workingActions, _uSyncWorkspaceContext_working, _uSyncWorkspaceContext_inBackground, _uSyncWorkspaceContext_completed, _uSyncWorkspaceContext_results, _uSyncWorkspaceContext_settings, _uSyncWorkspaceContext_handlerSettings, _uSyncWorkspaceContext_handlerSets, _uSyncWorkspaceContext_legacy, _uSyncWorkspaceContext_syncFileInfo, _uSyncWorkspaceContext_checkForRunningOperation, _uSyncWorkspaceContext_startPolling, _uSyncWorkspaceContext_stopPolling, _uSyncWorkspaceContext_onRunComplete, _uSyncWorkspaceContext_getFileName;
+import { UmbArrayState, UmbBooleanState, UmbObjectState, } from '@umbraco-cms/backoffice/observable-api';
+import { UmbContextToken } from '@umbraco-cms/backoffice/context-api';
+import { UmbControllerBase } from '@umbraco-cms/backoffice/class-api';
+import { uSyncActionRepository, uSyncConstants, } from '@jumoo/uSync';
+import uSyncSignalRContext from '../signalr/signalr.context';
+import { UMB_WORKSPACE_CONTEXT, } from '@umbraco-cms/backoffice/workspace';
+import { UMB_MODAL_MANAGER_CONTEXT } from '@umbraco-cms/backoffice/modal';
+import { USYNC_IMPORT_MODAL } from './dialogs';
+/**
+ * Status-poll interval bounds while a background run is active and SignalR
+ * isn't delivering. Starts close to real-time so the progress bar actually
+ * moves during a run - polling is now gated on message liveness rather than
+ * being the sole progress mechanism, and only kicks in when SignalR isn't
+ * doing the job, so the SQLite contention risk noted in the background-mode
+ * docs is far smaller than when this was the only path. Still backs off
+ * towards POLL_INTERVAL_MAX_MS on a long-running import so a multi-minute
+ * run doesn't sustain a steady 1s query rate the whole way through.
+ */
+const POLL_INTERVAL_MIN_MS = 1000;
+const POLL_INTERVAL_MAX_MS = 20000;
+/**
+ * How long to go without a SignalR message before treating the connection as
+ * not actually delivering for this run, and falling back to polling.
+ *
+ * A "connected" socket is not the same as "receiving messages for this run" -
+ * under a load-balanced backoffice without a SignalR backplane (or sticky
+ * sessions), the socket can be happily connected to a server that isn't the
+ * one running the job, so it never delivers anything and `getConnected()`
+ * alone would leave the UI hung forever on a run that already finished.
+ * Comfortably longer than the gap between handler steps on a healthy
+ * single-server run, so the normal (SignalR-only) path is unaffected.
+ */
+const SIGNALR_STALE_MS = 15000;
+/**
+ * Context for getting and seting up actions.
+ */
+export class uSyncWorkspaceContext extends UmbControllerBase {
+    getEntityType() {
+        return uSyncConstants.workspace.rootElement;
+    }
+    constructor(host) {
+        super(host);
+        _uSyncWorkspaceContext_instances.add(this);
+        this.workspaceAlias = uSyncConstants.workspace.alias;
+        _uSyncWorkspaceContext_repository.set(this, void 0);
+        _uSyncWorkspaceContext_signalRContext.set(this, null);
+        /**
+         * poll timer used while a background operation is running - this is the
+         * safety net (and the page-reload reattach mechanism) alongside SignalR,
+         * which is the fast path for live progress.
+         */
+        _uSyncWorkspaceContext_pollTimer.set(this, null);
+        /**
+         * timestamp of the last SignalR add/update/complete message seen for the
+         * current run - used to detect a socket that's "connected" but not
+         * actually delivering (see SIGNALR_STALE_MS).
+         */
+        _uSyncWorkspaceContext_lastSignalRMessageAt.set(this, 0);
+        /**
+         * true when the current background run needs to trigger a file download
+         * once it completes (export-to-file can't download until the export has
+         * actually finished writing, which - in background mode - is not when
+         * the enqueue call returns).
+         */
+        _uSyncWorkspaceContext_pendingDownload.set(this, false);
+        /**
+         * list of actions that have been returned from the process
+         */
+        _uSyncWorkspaceContext_actions.set(this, new UmbArrayState([], (x) => x.key));
+        this.actions = __classPrivateFieldGet(this, _uSyncWorkspaceContext_actions, "f").asObservable();
+        this._currentSetName = '';
+        /**
+         * the working group name
+         */
+        _uSyncWorkspaceContext_workingGroup.set(this, new UmbObjectState(undefined));
+        this.workingGroup = __classPrivateFieldGet(this, _uSyncWorkspaceContext_workingGroup, "f").asObservable();
+        /**
+         * The summary objects that show the handler boxes
+         */
+        _uSyncWorkspaceContext_workingActions.set(this, new UmbArrayState([], (x) => x.name));
+        this.currentAction = __classPrivateFieldGet(this, _uSyncWorkspaceContext_workingActions, "f").asObservable();
+        /**
+         * Flag to say if things are currently being processed
+         */
+        _uSyncWorkspaceContext_working.set(this, new UmbBooleanState(false));
+        this.working = __classPrivateFieldGet(this, _uSyncWorkspaceContext_working, "f").asObservable();
+        _uSyncWorkspaceContext_inBackground.set(this, new UmbBooleanState(false));
+        this.inBackground = __classPrivateFieldGet(this, _uSyncWorkspaceContext_inBackground, "f").asObservable();
+        /**
+         * Flag to say that the last run has been completed (so results will show)
+         */
+        _uSyncWorkspaceContext_completed.set(this, new UmbBooleanState(false));
+        this.completed = __classPrivateFieldGet(this, _uSyncWorkspaceContext_completed, "f").asObservable();
+        /**
+         * The results of a run.
+         */
+        _uSyncWorkspaceContext_results.set(this, new UmbArrayState([], (x) => x.name));
+        this.results = __classPrivateFieldGet(this, _uSyncWorkspaceContext_results, "f").asObservable();
+        /**
+         * Current settings for uSync
+         */
+        _uSyncWorkspaceContext_settings.set(this, new UmbObjectState(undefined));
+        this.settings = __classPrivateFieldGet(this, _uSyncWorkspaceContext_settings, "f")?.asObservable();
+        /**
+         * Handler settings object
+         */
+        _uSyncWorkspaceContext_handlerSettings.set(this, new UmbObjectState(undefined));
+        this.handlerSettings = __classPrivateFieldGet(this, _uSyncWorkspaceContext_handlerSettings, "f")?.asObservable();
+        _uSyncWorkspaceContext_handlerSets.set(this, new UmbArrayState([], (x) => x));
+        this.sets = __classPrivateFieldGet(this, _uSyncWorkspaceContext_handlerSets, "f").asObservable();
+        _uSyncWorkspaceContext_legacy.set(this, new UmbObjectState(undefined));
+        this.legacy = __classPrivateFieldGet(this, _uSyncWorkspaceContext_legacy, "f")?.asObservable();
+        _uSyncWorkspaceContext_syncFileInfo.set(this, new UmbObjectState(undefined));
+        this.syncFileInfo = __classPrivateFieldGet(this, _uSyncWorkspaceContext_syncFileInfo, "f")?.asObservable();
+        this.provideContext(USYNC_CORE_CONTEXT_TOKEN, this);
+        this.provideContext(UMB_WORKSPACE_CONTEXT, this);
+        __classPrivateFieldSet(this, _uSyncWorkspaceContext_repository, new uSyncActionRepository(this), "f");
+        __classPrivateFieldSet(this, _uSyncWorkspaceContext_signalRContext, new uSyncSignalRContext(this), "f");
+        this.observe(__classPrivateFieldGet(this, _uSyncWorkspaceContext_signalRContext, "f").connected, (connected) => {
+            console.debug('SignalR connected', connected);
+        });
+        // a "connected" socket only tells us it's connected to *some* server -
+        // under a load-balanced backoffice it may not be the one running the
+        // job. Track actual message arrival separately so the poll fallback can
+        // notice a connection that isn't delivering (see SIGNALR_STALE_MS).
+        this.observe(__classPrivateFieldGet(this, _uSyncWorkspaceContext_signalRContext, "f").add, (add) => {
+            if (!add)
+                return;
+            __classPrivateFieldSet(this, _uSyncWorkspaceContext_lastSignalRMessageAt, Date.now(), "f");
+        });
+        this.observe(__classPrivateFieldGet(this, _uSyncWorkspaceContext_signalRContext, "f").update, (update) => {
+            if (!update)
+                return;
+            __classPrivateFieldSet(this, _uSyncWorkspaceContext_lastSignalRMessageAt, Date.now(), "f");
+        });
+        this.observe(__classPrivateFieldGet(this, _uSyncWorkspaceContext_signalRContext, "f").complete, (complete) => {
+            if (!complete)
+                return;
+            __classPrivateFieldSet(this, _uSyncWorkspaceContext_lastSignalRMessageAt, Date.now(), "f");
+            if (complete.success) {
+                __classPrivateFieldGet(this, _uSyncWorkspaceContext_instances, "m", _uSyncWorkspaceContext_onRunComplete).call(this, complete.actions ?? []);
+            }
+        });
+        // on load, ask the server if a background run is already active -
+        // this is what lets the dashboard reattach after a page reload.
+        __classPrivateFieldGet(this, _uSyncWorkspaceContext_instances, "m", _uSyncWorkspaceContext_checkForRunningOperation).call(this);
+    }
+    hostDisconnected() {
+        super.hostDisconnected();
+        __classPrivateFieldGet(this, _uSyncWorkspaceContext_instances, "m", _uSyncWorkspaceContext_stopPolling).call(this);
+    }
+    /**
+     * Return the current actions from the repository
+     */
+    async getActions(setName) {
+        const { data } = await __classPrivateFieldGet(this, _uSyncWorkspaceContext_repository, "f").getActions(setName);
+        if (data) {
+            __classPrivateFieldGet(this, _uSyncWorkspaceContext_actions, "f").setValue(data);
+            this._currentSetName = setName;
+        }
+    }
+    /**
+     * Get the current uSync settings
+     */
+    async getSettings() {
+        const { data } = await __classPrivateFieldGet(this, _uSyncWorkspaceContext_repository, "f").getSettings();
+        if (data) {
+            __classPrivateFieldGet(this, _uSyncWorkspaceContext_settings, "f").setValue(data);
+        }
+        return data;
+    }
+    async getAddons() {
+        const { data } = await __classPrivateFieldGet(this, _uSyncWorkspaceContext_repository, "f").getAddons();
+        return data;
+    }
+    async getSyncFileInfo() {
+        const { data } = await __classPrivateFieldGet(this, _uSyncWorkspaceContext_repository, "f").getSyncFileInfo();
+        if (data) {
+            __classPrivateFieldGet(this, _uSyncWorkspaceContext_syncFileInfo, "f").setValue(data);
+        }
+        return data;
+    }
+    /**
+     * Check to see if there is a legacy uSync folder on disk.
+     */
+    async checkLegacy() {
+        const { data } = await __classPrivateFieldGet(this, _uSyncWorkspaceContext_repository, "f").checkLegacy();
+        if (data) {
+            __classPrivateFieldGet(this, _uSyncWorkspaceContext_legacy, "f").setValue(data);
+        }
+        return data;
+    }
+    async ignoreLegacy() {
+        const { data } = await __classPrivateFieldGet(this, _uSyncWorkspaceContext_repository, "f").ignoreLegacy();
+        return data ?? false;
+    }
+    async copyLegacy() {
+        const { data } = await __classPrivateFieldGet(this, _uSyncWorkspaceContext_repository, "f").copyLegacy();
+        return data ?? false;
+    }
+    /**
+     * Get handler defaults.
+     */
+    async getDefaultHandlerSetSettings(setName) {
+        const { data } = await __classPrivateFieldGet(this, _uSyncWorkspaceContext_repository, "f").getHandlerSettings(setName);
+        if (data) {
+            __classPrivateFieldGet(this, _uSyncWorkspaceContext_handlerSettings, "f").setValue(data);
+        }
+    }
+    async getHandlerSets() {
+        const { data } = await __classPrivateFieldGet(this, _uSyncWorkspaceContext_repository, "f").getSets();
+        if (data) {
+            __classPrivateFieldGet(this, _uSyncWorkspaceContext_handlerSets, "f").setValue(data);
+        }
+    }
+    /**
+     * Perform an action (e.g import, export, etc) with options
+     * @param options options for the action
+     */
+    async performAction(options) {
+        var clientId = __classPrivateFieldGet(this, _uSyncWorkspaceContext_signalRContext, "f")?.getClientId() ?? '';
+        __classPrivateFieldGet(this, _uSyncWorkspaceContext_working, "f").setValue(true);
+        __classPrivateFieldGet(this, _uSyncWorkspaceContext_completed, "f").setValue(false);
+        __classPrivateFieldGet(this, _uSyncWorkspaceContext_results, "f").setValue([]);
+        __classPrivateFieldGet(this, _uSyncWorkspaceContext_workingGroup, "f").setValue(options.group);
+        var complete = false;
+        var id = '';
+        var step = 0;
+        var lastResponse;
+        // pre-action checks, for files.
+        if (options.file && options.action === 'Import') {
+            // imports need to open the file dialog to get the file first.
+            const uploadResult = await this.uploadFile();
+            if (!uploadResult) {
+                __classPrivateFieldGet(this, _uSyncWorkspaceContext_completed, "f").setValue(true);
+                __classPrivateFieldGet(this, _uSyncWorkspaceContext_working, "f").setValue(false);
+                __classPrivateFieldGet(this, _uSyncWorkspaceContext_results, "f").setValue([]);
+                return;
+            }
+        }
+        do {
+            const { data } = await __classPrivateFieldGet(this, _uSyncWorkspaceContext_repository, "f").performAction({
+                id: id,
+                set: options.setName,
+                action: options.action,
+                group: options.group.key,
+                force: options.force,
+                clean: options.clean,
+                file: options.file,
+                step: step,
+                clientId: clientId,
+            });
+            if (data) {
+                step++;
+                let summary = data.status ?? [];
+                __classPrivateFieldGet(this, _uSyncWorkspaceContext_workingActions, "f").setValue(summary);
+                id = data.requestId;
+                complete = data.complete;
+                lastResponse = data;
+                __classPrivateFieldGet(this, _uSyncWorkspaceContext_inBackground, "f").setValue(data.inBackground);
+                if (complete && !data.inBackground) {
+                    __classPrivateFieldGet(this, _uSyncWorkspaceContext_results, "f").setValue(data?.actions ?? []);
+                    this.getActions(this._currentSetName);
+                }
+            }
+            else {
+                complete = true;
+            }
+        } while (!complete);
+        if (lastResponse?.message) {
+            // the run couldn't be started (e.g. one is already in progress) -
+            // nothing happened, so don't report a completed run.
+            console.warn('[uSync]', lastResponse.message);
+            __classPrivateFieldGet(this, _uSyncWorkspaceContext_working, "f").setValue(false);
+            __classPrivateFieldGet(this, _uSyncWorkspaceContext_completed, "f").setValue(false);
+            __classPrivateFieldGet(this, _uSyncWorkspaceContext_inBackground, "f").setValue(false);
+            return;
+        }
+        if (lastResponse?.inBackground && lastResponse?.operationId) {
+            // enqueued - poll (and listen via SignalR) until it completes.
+            // export-to-file must wait until then too, it can't download yet.
+            __classPrivateFieldGet(this, _uSyncWorkspaceContext_instances, "m", _uSyncWorkspaceContext_startPolling).call(this, lastResponse.operationId, options);
+            return;
+        }
+        // normal (stepped, foreground) mode - already complete.
+        if (options.file && options.action === 'Export') {
+            await this.downloadFile();
+        }
+        __classPrivateFieldGet(this, _uSyncWorkspaceContext_completed, "f").setValue(true);
+        __classPrivateFieldGet(this, _uSyncWorkspaceContext_working, "f").setValue(false);
+    }
+    /**
+     * Manually clear a stuck "running in background" state - a workaround for
+     * when the server that was running the sync crashed or restarted and this
+     * client is left showing it as still active. This only resets what THIS
+     * client shows; it does not (and cannot - Umbraco's long-running-operation
+     * service has no cancel API) force the server-side operation to end. If
+     * the run really is still active elsewhere, starting a new one will still
+     * be rejected until the server-side run actually finishes or its
+     * expiration window passes (a few minutes by default).
+     */
+    dismissBackgroundRun() {
+        __classPrivateFieldGet(this, _uSyncWorkspaceContext_instances, "m", _uSyncWorkspaceContext_stopPolling).call(this);
+        __classPrivateFieldSet(this, _uSyncWorkspaceContext_pendingDownload, false, "f");
+        __classPrivateFieldGet(this, _uSyncWorkspaceContext_completed, "f").setValue(false);
+        __classPrivateFieldGet(this, _uSyncWorkspaceContext_working, "f").setValue(false);
+        __classPrivateFieldGet(this, _uSyncWorkspaceContext_inBackground, "f").setValue(false);
+        __classPrivateFieldGet(this, _uSyncWorkspaceContext_workingActions, "f").setValue([]);
+    }
+    async uploadFile() {
+        const modalManager = await this.getContext(UMB_MODAL_MANAGER_CONTEXT);
+        if (!modalManager)
+            return;
+        const importModal = modalManager.open(this, USYNC_IMPORT_MODAL, {
+            data: {},
+        });
+        const data = await importModal.onSubmit().catch(() => {
+            return false;
+        });
+        if (!data)
+            return false;
+        return true;
+    }
+    async downloadFile() {
+        const response = await __classPrivateFieldGet(this, _uSyncWorkspaceContext_repository, "f").downloadFile();
+        if (!response)
+            return;
+        console.log('Downloading file', response);
+        const url = window.URL.createObjectURL(response);
+        const download = document.createElement('a');
+        download.href = url;
+        download.download = __classPrivateFieldGet(this, _uSyncWorkspaceContext_instances, "m", _uSyncWorkspaceContext_getFileName).call(this);
+        document.body.appendChild(download);
+        download.dispatchEvent(new MouseEvent('click'));
+        download.remove();
+        window.URL.revokeObjectURL(url);
+    }
+    async importSingle(item) {
+        if (!item)
+            return;
+        const data = await __classPrivateFieldGet(this, _uSyncWorkspaceContext_repository, "f").importSingle(item);
+        return data;
+    }
+}
+_uSyncWorkspaceContext_repository = new WeakMap(), _uSyncWorkspaceContext_signalRContext = new WeakMap(), _uSyncWorkspaceContext_pollTimer = new WeakMap(), _uSyncWorkspaceContext_lastSignalRMessageAt = new WeakMap(), _uSyncWorkspaceContext_pendingDownload = new WeakMap(), _uSyncWorkspaceContext_actions = new WeakMap(), _uSyncWorkspaceContext_workingGroup = new WeakMap(), _uSyncWorkspaceContext_workingActions = new WeakMap(), _uSyncWorkspaceContext_working = new WeakMap(), _uSyncWorkspaceContext_inBackground = new WeakMap(), _uSyncWorkspaceContext_completed = new WeakMap(), _uSyncWorkspaceContext_results = new WeakMap(), _uSyncWorkspaceContext_settings = new WeakMap(), _uSyncWorkspaceContext_handlerSettings = new WeakMap(), _uSyncWorkspaceContext_handlerSets = new WeakMap(), _uSyncWorkspaceContext_legacy = new WeakMap(), _uSyncWorkspaceContext_syncFileInfo = new WeakMap(), _uSyncWorkspaceContext_instances = new WeakSet(), _uSyncWorkspaceContext_checkForRunningOperation = 
+/**
+ * Ask the server if a background run is already active, and if so,
+ * reattach to it (used on load, to recover from a page reload).
+ */
+async function _uSyncWorkspaceContext_checkForRunningOperation() {
+    const { data } = await __classPrivateFieldGet(this, _uSyncWorkspaceContext_repository, "f").getRunningOperation();
+    if (!data?.operationId)
+        return;
+    __classPrivateFieldGet(this, _uSyncWorkspaceContext_working, "f").setValue(true);
+    __classPrivateFieldGet(this, _uSyncWorkspaceContext_completed, "f").setValue(false);
+    __classPrivateFieldGet(this, _uSyncWorkspaceContext_inBackground, "f").setValue(true);
+    __classPrivateFieldGet(this, _uSyncWorkspaceContext_instances, "m", _uSyncWorkspaceContext_startPolling).call(this, data.operationId);
+}, _uSyncWorkspaceContext_startPolling = function _uSyncWorkspaceContext_startPolling(operationId, options) {
+    __classPrivateFieldGet(this, _uSyncWorkspaceContext_instances, "m", _uSyncWorkspaceContext_stopPolling).call(this);
+    __classPrivateFieldSet(this, _uSyncWorkspaceContext_pendingDownload, options?.file === true && options?.action === 'Export', "f");
+    // seed this so the very first poll still waits the normal interval
+    // rather than firing immediately just because no message has arrived
+    // yet for a run that only just started.
+    __classPrivateFieldSet(this, _uSyncWorkspaceContext_lastSignalRMessageAt, Date.now(), "f");
+    let interval = POLL_INTERVAL_MIN_MS;
+    const poll = async () => {
+        // SignalR is the fast path for progress/completion - polling is only
+        // the fallback (initial reattach before the socket is up, if it drops
+        // mid-run, or - under a load-balanced backoffice without a SignalR
+        // backplane/sticky sessions - if it's connected to a server that
+        // isn't the one running the job and so never delivers anything for
+        // this run). Every poll is an authenticated request, and on SQLite a
+        // background run can hold locks long enough that a steady stream of
+        // unrelated queries starts timing out, so we only spend that request
+        // when nothing is actually delivering progress for us right now.
+        const signalRDelivering = __classPrivateFieldGet(this, _uSyncWorkspaceContext_signalRContext, "f")?.getConnected() &&
+            Date.now() - __classPrivateFieldGet(this, _uSyncWorkspaceContext_lastSignalRMessageAt, "f") < SIGNALR_STALE_MS;
+        if (!signalRDelivering) {
+            const { data } = await __classPrivateFieldGet(this, _uSyncWorkspaceContext_repository, "f").getOperationStatus(operationId);
+            if (data) {
+                __classPrivateFieldGet(this, _uSyncWorkspaceContext_workingActions, "f").setValue(data.status ?? []);
+                // usync-progress-box only ever renders a message from the
+                // SignalR update push - without this, the box under the
+                // handler icons stays blank/stale for a run whose socket
+                // isn't delivering. Only publish while there's still a
+                // message worth showing; the completion path below drives
+                // its own "Completed"/error state via complete.
+                if (data.message && !data.complete) {
+                    __classPrivateFieldGet(this, _uSyncWorkspaceContext_signalRContext, "f")?.setPolledUpdate(data.message);
+                }
+                if (data.complete) {
+                    __classPrivateFieldGet(this, _uSyncWorkspaceContext_instances, "m", _uSyncWorkspaceContext_onRunComplete).call(this, data.actions ?? [], data.operationStatus === 'Success', data.message);
+                    return;
+                }
+            }
+            // back off while a run drags on, so a long import doesn't sustain
+            // a steady stream of extra queries against the same database.
+            interval = Math.min(interval * 1.5, POLL_INTERVAL_MAX_MS);
+        }
+        __classPrivateFieldSet(this, _uSyncWorkspaceContext_pollTimer, setTimeout(poll, interval), "f");
+    };
+    __classPrivateFieldSet(this, _uSyncWorkspaceContext_pollTimer, setTimeout(poll, interval), "f");
+}, _uSyncWorkspaceContext_stopPolling = function _uSyncWorkspaceContext_stopPolling() {
+    if (__classPrivateFieldGet(this, _uSyncWorkspaceContext_pollTimer, "f")) {
+        clearTimeout(__classPrivateFieldGet(this, _uSyncWorkspaceContext_pollTimer, "f"));
+        __classPrivateFieldSet(this, _uSyncWorkspaceContext_pollTimer, null, "f");
+    }
+}, _uSyncWorkspaceContext_onRunComplete = function _uSyncWorkspaceContext_onRunComplete(actions, success = true, message) {
+    if (__classPrivateFieldGet(this, _uSyncWorkspaceContext_completed, "f").getValue())
+        return;
+    __classPrivateFieldGet(this, _uSyncWorkspaceContext_instances, "m", _uSyncWorkspaceContext_stopPolling).call(this);
+    if (!success) {
+        console.warn('[uSync]', message ?? 'The background run did not complete successfully.');
+    }
+    __classPrivateFieldGet(this, _uSyncWorkspaceContext_results, "f").setValue(actions);
+    __classPrivateFieldGet(this, _uSyncWorkspaceContext_completed, "f").setValue(true);
+    __classPrivateFieldGet(this, _uSyncWorkspaceContext_working, "f").setValue(false);
+    __classPrivateFieldGet(this, _uSyncWorkspaceContext_inBackground, "f").setValue(false);
+    this.getActions(this._currentSetName);
+    if (success && __classPrivateFieldGet(this, _uSyncWorkspaceContext_pendingDownload, "f")) {
+        __classPrivateFieldSet(this, _uSyncWorkspaceContext_pendingDownload, false, "f");
+        this.downloadFile();
+    }
+}, _uSyncWorkspaceContext_getFileName = function _uSyncWorkspaceContext_getFileName() {
+    const now = new Date();
+    const year = now.getUTCFullYear().toString();
+    const month = (now.getUTCMonth() + 1).toString().padStart(2, '0');
+    const day = now.getUTCDate().toString().padStart(2, '0');
+    const hours = now.getUTCHours().toString().padStart(2, '0');
+    const minutes = now.getUTCMinutes().toString().padStart(2, '0');
+    const seconds = now.getUTCSeconds().toString().padStart(2, '0');
+    const timestamp = `${year}${month}${day}_${hours}${minutes}${seconds}`;
+    return `usync_export_${timestamp}.zip`;
+};
+export default uSyncWorkspaceContext;
+export const USYNC_CORE_CONTEXT_TOKEN = new UmbContextToken('uSyncWorkspaceContext');

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

@@ -0,0 +1,17 @@
+import { LitElement } from '@umbraco-cms/backoffice/external/lit';
+import './views/default/default.element.js';
+declare const uSyncWorkspaceRootElement_base: import("@umbraco-cms/backoffice/extension-api").HTMLElementConstructor<import("@umbraco-cms/backoffice/element-api").UmbElement> & typeof LitElement;
+export declare class uSyncWorkspaceRootElement extends uSyncWorkspaceRootElement_base {
+    #private;
+    version: string;
+    constructor();
+    connectedCallback(): Promise<void>;
+    render(): import("lit-html").TemplateResult<1>;
+    static styles: import("lit").CSSResult[];
+}
+export default uSyncWorkspaceRootElement;
+declare global {
+    interface HTMLElementTagNameMap {
+        'usync-workspace-root': uSyncWorkspaceRootElement;
+    }
+}

package/dist/workspace/workspace.element.js

@@ -0,0 +1,69 @@
+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 _uSyncWorkspaceRootElement_workspaceContext;
+import { UmbTextStyles } from '@umbraco-cms/backoffice/style';
+import { UmbElementMixin } from '@umbraco-cms/backoffice/element-api';
+import { LitElement, css, customElement, html, state, } from '@umbraco-cms/backoffice/external/lit';
+import { uSyncWorkspaceContext, uSyncConstants } from '@jumoo/uSync';
+import './views/default/default.element.js';
+let uSyncWorkspaceRootElement = class uSyncWorkspaceRootElement extends UmbElementMixin(LitElement) {
+    constructor() {
+        super();
+        _uSyncWorkspaceRootElement_workspaceContext.set(this, void 0);
+        this.version = uSyncConstants.version;
+        __classPrivateFieldSet(this, _uSyncWorkspaceRootElement_workspaceContext, new uSyncWorkspaceContext(this), "f");
+        this.observe(__classPrivateFieldGet(this, _uSyncWorkspaceRootElement_workspaceContext, "f").completed, (_completed) => { });
+    }
+    async connectedCallback() {
+        super.connectedCallback();
+        const addons = await __classPrivateFieldGet(this, _uSyncWorkspaceRootElement_workspaceContext, "f").getAddons();
+        this.version = `v${addons?.version ?? uSyncConstants.version}`;
+    }
+    render() {
+        return html `
+			<umb-workspace-editor .enforceNoFooter=${true}>
+				<div slot="header" class="header">
+					<div>
+						<strong><umb-localize key="uSync_name"></umb-localize></strong><br /><em
+							>${this.version}</em
+						>
+					</div>
+				</div>
+			</umb-workspace-editor>
+		`;
+    }
+};
+_uSyncWorkspaceRootElement_workspaceContext = new WeakMap();
+uSyncWorkspaceRootElement.styles = [
+    UmbTextStyles,
+    css `
+			umb-workspace-editor > div.header {
+				display: flex;
+				align-items: center;
+				align-content: center;
+			}
+		`,
+];
+__decorate([
+    state()
+], uSyncWorkspaceRootElement.prototype, "version", void 0);
+uSyncWorkspaceRootElement = __decorate([
+    customElement('usync-workspace-root')
+], uSyncWorkspaceRootElement);
+export { uSyncWorkspaceRootElement };
+export default uSyncWorkspaceRootElement;

package/package.json

@@ -1,6 +1,77 @@
-{
-  "name": "@jumoo/usync",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+{
+	"name": "@jumoo/usync",
+	"description": "uSync client libraries for extending uSync behavior in Umbraco",
+	"keywords": [
+		"Umbraco",
+		"uSync"
+	],
+	"homepage": "https://jumoo.co.uk/uSync",
+	"license": "MPL-2.0",
+	"type": "module",
+	"version": "18.2.0",
+	"main": "./dist/usync.js",
+	"types": "./dist/index.d.ts",
+	"module": "./dist/usync.js",
+	"publishConfig": {
+		"access": "restricted"
+	},
+	"exports": {
+		".": "./dist/index.js",
+		"./signalr": "./dist/signalr/index.js",
+		"./api": "./dist/api/index.js",
+		"./components": "./dist/components/index.js",
+		"./constants": "./dist/constants.js",
+		"./tree": "./dist/tree/index.js",
+		"./dialogs": "./dist/dialogs/index.js"
+	},
+	"files": [
+		"./dist/**/*"
+	],
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/KevinJump/uSync.git"
+	},
+	"bugs": {
+		"url": "https://github.com/kevinjump/usync/issues"
+	},
+	"author": {
+		"name": "Jumoo Ltd",
+		"email": "info@jumoo.co.uk",
+		"url": "https://jumoo.co.uk"
+	},
+	"site": {
+		"port": "16903",
+		"api": "uSync"
+	},
+	"scripts": {
+		"client:build": "tsc --project ./tsconfig.dist.json",
+		"client:pack": "npm pack --pack-destination ./pack",
+		"client:publish": "npm publish --tag next",
+		"client:make": "npm run client:build && npm run client:pack && npm run client:publish",
+		"client:link": "npm link",
+		"generate-client": "node scripts/generate-openapi.js https://localhost:44304/umbraco/openapi/uSync.json",
+		"format:fix": "npm run format -- --write",
+		"format": "prettier \"src/**/*.ts\" --check",
+		"build": "tsc && vite build",
+		"watch": "vite build --watch",
+		"typescript:build": "tsc",
+		"make": "npm run build && npm run client:make"
+	},
+	"devDependencies": {
+		"@hey-api/openapi-ts": "^0.99.0",
+		"@microsoft/signalr": "^10.0.11",
+		"@umbraco-cms/backoffice": "^18.0.0-rc3",
+		"chalk": "^6.0.0",
+		"cross-env": "^10.1.0",
+		"eslint": "^10.13.0",
+		"lit": "^3.3.3",
+		"node-fetch": "^3.3.2",
+		"prettier": "^3.9.10",
+		"typescript": "^5.9.3",
+		"vite": "^8.3.4",
+		"vite-plugin-dts": "^5.1.2"
+	},
+	"overrides": {
+		"js-yaml": "^4.3.1"
+	}
+}