@jumoo/usync 18.2.0 → 18.3.0

package/dist/lang/files/fr-fr.js

@@ -24,6 +24,43 @@ export default {
         showAll: 'Afficher tous les éléments',
         detailHeadline: 'Modifications détectées',
         detailHeader: 'Ce qui est différent',
+        detailPosition: '%0% sur %1%',
+        changesTab: 'Modifications',
+        diffTab: 'Diff',
+        previewCurrent: 'Actuel (ce site)',
+        previewIncoming: 'Entrant (fichiers uSync)',
+        previewNotInSite: "Cet élément n'existe pas encore sur le site",
+        previewDeleted: "Cet élément sera supprimé ou renommé par l'import",
+        previewFailed: "L'élément entrant n'a pas pu être construit pour l'aperçu",
+        previewEditor: "Aperçu de l'éditeur",
+        previewEditorDesc: 'Comment ce type de données apparaît aux éditeurs',
+        previewConfiguration: 'Configuration',
+        previewNoConfiguration: 'Aucune configuration',
+        previewPropertyEditor: 'Éditeur de propriété',
+        previewPropertyEditorUi: "UI de l'éditeur de propriété",
+        previewDocumentType: 'Type de document',
+        previewMediaType: 'Type de média',
+        previewMemberType: 'Type de membre',
+        previewElementType: "Type d'élément",
+        previewAllowedAtRoot: 'Autorisé à la racine',
+        previewVariesByCulture: 'Varie selon la culture',
+        previewVariesBySegment: 'Varie selon le segment',
+        previewCompositions: 'Compositions',
+        previewGenericTab: 'Général',
+        previewNoProperties: 'Aucune propriété',
+        previewMissingDataType: "le type de données de cette propriété n'existe pas encore sur le site",
+        previewNewDataType: 'nouveau type de données',
+        previewNew: 'nouveau',
+        previewParent: 'Parent',
+        previewRoot: '(racine)',
+        previewSortOrder: 'Ordre de tri',
+        previewTemplate: 'Modèle',
+        previewPublished: 'Publié',
+        previewNotPublished: 'Non publié',
+        previewTrashed: 'Dans la corbeille',
+        previewCulture: 'Langue',
+        previewOnlyChanges: 'Afficher uniquement les modifications',
+        previewNoValueChanges: 'Aucune valeur ne change',
         runningInBackground: 'uSync exécute ce processus en arrière-plan. Si vous quittez cette page, il continuera de fonctionner.',
         connectionLost: 'La connexion au serveur a été perdue. Le processus continuera de s\'exécuter en arrière-plan, mais vous ne verrez pas les mises à jour ici.',
         importSingle: 'Importer',
@@ -46,21 +83,21 @@ export default {
         changeHeading: 'Résultats',
         changeCount: '{1}/{0} modifications',
         noChangeCount: '0/{0} modifications',
-        legacyInfo: `<p>uSync a trouvé un dossier uSync hérité à <strong>%0%</strong>.<br />
+        legacyInfo: `<p>uSync a trouvé un dossier uSync hérité à <strong>%0%</strong>.<br />
 						Il est probable que son contenu devra être converti d'une façon ou d'une autre</p>`,
-        legacyObsolete: `<h4>Types de données obsolètes</h4>
-				<ul>%0%</ul>
-				<p>Vous pouvez convertir ces types de données en utilisant
-					<a href="https://github.com/Jumoo/uSyncMigrations" target="_blank">uSync.Migrations</a><br />
+        legacyObsolete: `<h4>Types de données obsolètes</h4>
+				<ul>%0%</ul>
+				<p>Vous pouvez convertir ces types de données en utilisant
+					<a href="https://github.com/Jumoo/uSyncMigrations" target="_blank">uSync.Migrations</a><br />
 					<em>(Dans la version complète d'uSync, la conversion se fera ici.)</em></p>`,
-        legacyCopy: `<h4>Copier vers uSync/v14</h4>
-					<p>Vous pouvez copier votre dossier %0% vers le dossier ~/uSync/v14<br />et exécuter une importation.</p>
-					<p>Si rien ne nécessite de conversion, tout devrait s'importer correctement.</p>
+        legacyCopy: `<h4>Copier vers uSync/v14</h4>
+					<p>Vous pouvez copier votre dossier %0% vers le dossier ~/uSync/v14<br />et exécuter une importation.</p>
+					<p>Si rien ne nécessite de conversion, tout devrait s'importer correctement.</p>
 					<p><strong>Supprimez ou renommez le dossier %0% pour éviter cette popup</strong></p>`,
-        hmacMismatch: `<h4>Incompatibilité HMAC <uui-icon name="alert"></uui-icon></h4>
-			<p>Il semble que le paramètre <code>Imaging:HMAC</code> utilisé pour générer les fichiers dans le dossier uSync ne corresponde pas au paramètre actuel de ce site.</p>
-			<p>Les images dans les contrôles RTE auront la valeur HMAC ajoutée à l'URL, et sans configuration supplémentaire, ces images pourraient ne pas s'afficher correctement.</p>
-			<ul><li>Vous pouvez activer le "mappage HMAC" dans uSync,</li>
+        hmacMismatch: `<h4>Incompatibilité HMAC <uui-icon name="alert"></uui-icon></h4>
+			<p>Il semble que le paramètre <code>Imaging:HMAC</code> utilisé pour générer les fichiers dans le dossier uSync ne corresponde pas au paramètre actuel de ce site.</p>
+			<p>Les images dans les contrôles RTE auront la valeur HMAC ajoutée à l'URL, et sans configuration supplémentaire, ces images pourraient ne pas s'afficher correctement.</p>
+			<ul><li>Vous pouvez activer le "mappage HMAC" dans uSync,</li>
 			<li>ou vous pouvez vous assurer que la valeur HMAC dans le paramètre <code>Imaging:HMAC</code> correspond à la valeur utilisée pour générer les fichiers dans le dossier uSync</li></ul>`,
         formatMismatch: 'La version du format du fichier de synchronisation ne correspond pas à la version attendue. Cela peut indiquer un problème de compatibilité potentiel.',
         legacyBanner: 'Ce site contient des fichiers d\'une version précédente d\'uSync. Consultez les détails dans l\'onglet Héritage.',

package/dist/lang/files/nl-nl.d.ts

@@ -24,6 +24,43 @@ declare const _default: {
         showAll: string;
         detailHeadline: string;
         detailHeader: string;
+        detailPosition: string;
+        changesTab: string;
+        diffTab: string;
+        previewCurrent: string;
+        previewIncoming: string;
+        previewNotInSite: string;
+        previewDeleted: string;
+        previewFailed: string;
+        previewEditor: string;
+        previewEditorDesc: string;
+        previewConfiguration: string;
+        previewNoConfiguration: string;
+        previewPropertyEditor: string;
+        previewPropertyEditorUi: string;
+        previewDocumentType: string;
+        previewMediaType: string;
+        previewMemberType: string;
+        previewElementType: string;
+        previewAllowedAtRoot: string;
+        previewVariesByCulture: string;
+        previewVariesBySegment: string;
+        previewCompositions: string;
+        previewGenericTab: string;
+        previewNoProperties: string;
+        previewMissingDataType: string;
+        previewNewDataType: string;
+        previewNew: string;
+        previewParent: string;
+        previewRoot: string;
+        previewSortOrder: string;
+        previewTemplate: string;
+        previewPublished: string;
+        previewNotPublished: string;
+        previewTrashed: string;
+        previewCulture: string;
+        previewOnlyChanges: string;
+        previewNoValueChanges: string;
         runningInBackground: string;
         connectionLost: string;
         importSingle: string;

package/dist/lang/files/nl-nl.js

@@ -24,6 +24,43 @@ export default {
         showAll: 'Alle items weergeven',
         detailHeadline: 'Gedetecteerde wijzigingen',
         detailHeader: 'Wat er anders is',
+        detailPosition: '%0% van %1%',
+        changesTab: 'Wijzigingen',
+        diffTab: 'Diff',
+        previewCurrent: 'Huidig (deze site)',
+        previewIncoming: 'Inkomend (uSync-bestanden)',
+        previewNotInSite: 'Dit item bestaat nog niet op de site',
+        previewDeleted: 'Dit item wordt door de import verwijderd of hernoemd',
+        previewFailed: 'Het inkomende item kon niet worden opgebouwd voor het voorbeeld',
+        previewEditor: 'Editor-voorbeeld',
+        previewEditorDesc: 'Zo ziet dit datatype eruit voor redacteuren',
+        previewConfiguration: 'Configuratie',
+        previewNoConfiguration: 'Geen configuratie',
+        previewPropertyEditor: 'Property editor',
+        previewPropertyEditorUi: 'Property editor UI',
+        previewDocumentType: 'Documenttype',
+        previewMediaType: 'Mediatype',
+        previewMemberType: 'Ledentype',
+        previewElementType: 'Elementtype',
+        previewAllowedAtRoot: 'Toegestaan in de root',
+        previewVariesByCulture: 'Varieert per cultuur',
+        previewVariesBySegment: 'Varieert per segment',
+        previewCompositions: 'Composities',
+        previewGenericTab: 'Algemeen',
+        previewNoProperties: 'Geen eigenschappen',
+        previewMissingDataType: 'het datatype voor deze eigenschap bestaat nog niet op de site',
+        previewNewDataType: 'nieuw datatype',
+        previewNew: 'nieuw',
+        previewParent: 'Bovenliggend',
+        previewRoot: '(root)',
+        previewSortOrder: 'Sorteervolgorde',
+        previewTemplate: 'Sjabloon',
+        previewPublished: 'Gepubliceerd',
+        previewNotPublished: 'Niet gepubliceerd',
+        previewTrashed: 'In de prullenbak',
+        previewCulture: 'Taal',
+        previewOnlyChanges: 'Alleen wijzigingen tonen',
+        previewNoValueChanges: 'Geen waarden veranderen',
         runningInBackground: 'uSync voert dit proces op de achtergrond uit. Als u van deze pagina navigeert, blijft het doorlopen.',
         connectionLost: 'De verbinding met de server is verbroken. Het proces blijft op de achtergrond draaien, maar u ziet hier geen updates.',
         importSingle: 'Importeren',
@@ -46,21 +83,21 @@ export default {
         changeHeading: 'Resultaten',
         changeCount: '{1}/{0} wijzigingen',
         noChangeCount: '0/{0} wijzigingen',
-        legacyInfo: `<p>uSync heeft een verouderde uSync-map gevonden op <strong>%0%</strong>.<br />
+        legacyInfo: `<p>uSync heeft een verouderde uSync-map gevonden op <strong>%0%</strong>.<br />
 						Het is waarschijnlijk dat de inhoud op de een of andere manier geconverteerd moet worden</p>`,
-        legacyObsolete: `<h4>Verouderde gegevenstypen</h4>
-				<ul>%0%</ul>
-				<p>U kunt deze gegevenstypen converteren met
-					<a href="https://github.com/Jumoo/uSyncMigrations" target="_blank">uSync.Migrations</a><br />
+        legacyObsolete: `<h4>Verouderde gegevenstypen</h4>
+				<ul>%0%</ul>
+				<p>U kunt deze gegevenstypen converteren met
+					<a href="https://github.com/Jumoo/uSyncMigrations" target="_blank">uSync.Migrations</a><br />
 					<em>(In de volledige uSync-release zal de conversie hier plaatsvinden.)</em></p>`,
-        legacyCopy: `<h4>Kopiëren naar uSync/v14</h4>
-					<p>U kunt uw %0%-map kopiëren naar de ~/uSync/v14-map<br />en een import uitvoeren.</p>
-					<p>Als er niets geconverteerd hoeft te worden, zou alles correct moeten importeren.</p>
+        legacyCopy: `<h4>Kopiëren naar uSync/v14</h4>
+					<p>U kunt uw %0%-map kopiëren naar de ~/uSync/v14-map<br />en een import uitvoeren.</p>
+					<p>Als er niets geconverteerd hoeft te worden, zou alles correct moeten importeren.</p>
 					<p><strong>Verwijder of hernoem de %0%-map om deze popup te voorkomen</strong></p>`,
-        hmacMismatch: `<h4>HMAC-mismatch <uui-icon name="alert"></uui-icon></h4>
-			<p>Het lijkt erop dat de <code>Imaging:HMAC</code>-instelling die werd gebruikt om de bestanden in de uSync-map te genereren, niet overeenkomt met de huidige instelling voor deze site.</p>
-			<p>Afbeeldingen in RTE-besturingselementen hebben de HMAC-waarde toegevoegd aan de URL-waarde, en zonder aanvullende configuratie worden deze afbeeldingen mogelijk niet correct weergegeven.</p>
-			<ul><li>U kunt "HMAC-mapping" inschakelen in uSync,</li>
+        hmacMismatch: `<h4>HMAC-mismatch <uui-icon name="alert"></uui-icon></h4>
+			<p>Het lijkt erop dat de <code>Imaging:HMAC</code>-instelling die werd gebruikt om de bestanden in de uSync-map te genereren, niet overeenkomt met de huidige instelling voor deze site.</p>
+			<p>Afbeeldingen in RTE-besturingselementen hebben de HMAC-waarde toegevoegd aan de URL-waarde, en zonder aanvullende configuratie worden deze afbeeldingen mogelijk niet correct weergegeven.</p>
+			<ul><li>U kunt "HMAC-mapping" inschakelen in uSync,</li>
 			<li>of u kunt ervoor zorgen dat de HMAC-waarde in de <code>Imaging:HMAC</code>-instelling overeenkomt met de waarde die werd gebruikt om de bestanden in de uSync-map te genereren</li></ul>`,
         formatMismatch: 'De versie van het synchronisatiebestandsformaat komt niet overeen met de verwachte versie. Dit kan wijzen op een mogelijk compatibiliteitsprobleem.',
         legacyBanner: 'Deze site bevat bestanden van een eerdere versie van uSync. Bekijk de details op het tabblad Verouderd.',

package/dist/manifests.js

@@ -4,6 +4,7 @@ import { manifests as localization } from './lang/manifest.js';
 import { manifests as dialogs } from './dialogs/manifest.js';
 import { manifests as conditions } from './conditions/manifest.js';
 import { manifests as icons } from './icons/manifest.js';
+import { manifests as previews } from './preview/manifest.js';
 export const manifests = [
     ...localization,
     ...trees,
@@ -11,4 +12,5 @@ export const manifests = [
     ...dialogs,
     ...conditions,
     ...icons,
+    ...previews,
 ];

package/dist/preview/index.d.ts

@@ -0,0 +1 @@
+export * from './types.js';

package/dist/preview/index.js

@@ -0,0 +1 @@
+export * from './types.js';

package/dist/preview/manifest.d.ts

@@ -0,0 +1,2 @@
+import type { ManifestuSyncItemPreview } from './types.js';
+export declare const manifests: ManifestuSyncItemPreview[];

package/dist/preview/manifest.js

@@ -0,0 +1,22 @@
+const dataTypePreview = {
+    type: 'usync-item-preview',
+    alias: 'usync.item-preview.data-type',
+    name: 'uSync data type preview',
+    element: () => import('../components/usync-data-type-preview.js'),
+    forEntityTypes: ['data-type'],
+};
+const contentTypePreview = {
+    type: 'usync-item-preview',
+    alias: 'usync.item-preview.content-type',
+    name: 'uSync content type preview',
+    element: () => import('../components/usync-content-type-preview.js'),
+    forEntityTypes: ['document-type', 'media-type', 'member-type'],
+};
+const contentPreview = {
+    type: 'usync-item-preview',
+    alias: 'usync.item-preview.content',
+    name: 'uSync content preview',
+    element: () => import('../components/usync-content-preview.js'),
+    forEntityTypes: ['document', 'media'],
+};
+export const manifests = [dataTypePreview, contentTypePreview, contentPreview];

package/dist/preview/types.d.ts

@@ -0,0 +1,72 @@
+import type { ManifestElement } from '@umbraco-cms/backoffice/extension-api';
+import type { DataTypeResponseModel, DocumentResponseModel, DocumentTypeResponseModel, MediaResponseModel, MediaTypeResponseModel, MemberTypeResponseModel } from '@umbraco-cms/backoffice/external/backend-api';
+import type { SyncItemPreviewResponse } from '../api';
+/**
+ * An element that shows the preview of an import for one or more entity types.
+ */
+export interface uSyncItemPreviewElement extends HTMLElement {
+    preview?: SyncItemPreviewResponse;
+}
+/**
+ * Shows the preview for items of the given entity types in the details dialog.
+ *
+ * The entity types match the `EntityType` of the server side preview mapper,
+ * and `preview.preview` is the model that mapper built.
+ */
+export interface ManifestuSyncItemPreview extends ManifestElement<uSyncItemPreviewElement> {
+    type: 'usync-item-preview';
+    forEntityTypes: Array<string>;
+}
+declare global {
+    interface UmbExtensionManifestMap {
+        ManifestuSyncItemPreview: ManifestuSyncItemPreview;
+    }
+}
+/** the model a preview mapper built, as the type the element expects. */
+export declare const getPreviewModel: <T>(preview?: SyncItemPreviewResponse) => T | undefined;
+export type uSyncPreviewContentTypeModel = DocumentTypeResponseModel | MediaTypeResponseModel | MemberTypeResponseModel;
+/** preview model for a data type (entity type data-type) */
+export interface SyncDataTypePreview {
+    current?: DataTypeResponseModel | null;
+    incoming?: DataTypeResponseModel | null;
+}
+/** what the preview needs to lay out the properties of an item */
+export interface SyncPropertiesPreview<TTypeModel> {
+    /** the content types either side is composed of (as they are in the site) */
+    compositions: Array<TTypeModel>;
+    /** the data types used by the properties on either side */
+    dataTypes: Array<DataTypeResponseModel>;
+    /** keys of the data types that aren't in the site yet */
+    newDataTypes: Array<string>;
+    /** keys of the compositions that aren't in the site yet */
+    newCompositions: Array<string>;
+}
+/** preview model for a document, media or member type */
+export interface SyncContentTypePreview<TTypeModel extends uSyncPreviewContentTypeModel = uSyncPreviewContentTypeModel> extends SyncPropertiesPreview<TTypeModel> {
+    current?: TTypeModel | null;
+    incoming?: TTypeModel | null;
+}
+export interface SyncContentPreviewCulture {
+    culture: string;
+    published: boolean;
+}
+/** the settings of a content or media item that aren't property values */
+export interface SyncContentPreviewInfo {
+    /** name of the parent item (null when the item is at the root) */
+    parent?: string | null;
+    sortOrder: number;
+    trashed: boolean;
+    /** alias of the template (content only) */
+    template?: string | null;
+    /** published state for each culture (an empty culture for invariant content) */
+    published: Array<SyncContentPreviewCulture>;
+}
+/** preview model for a document or media item */
+export interface SyncContentPreview<TModel extends DocumentResponseModel | MediaResponseModel = DocumentResponseModel | MediaResponseModel, TTypeModel extends DocumentTypeResponseModel | MediaTypeResponseModel = DocumentTypeResponseModel | MediaTypeResponseModel> extends SyncPropertiesPreview<TTypeModel> {
+    current?: TModel | null;
+    incoming?: TModel | null;
+    currentInfo?: SyncContentPreviewInfo | null;
+    incomingInfo?: SyncContentPreviewInfo | null;
+    /** the document (or media) type of the item, as it is in the site */
+    contentType?: TTypeModel | null;
+}

package/dist/preview/types.js

@@ -0,0 +1,2 @@
+/** the model a preview mapper built, as the type the element expects. */
+export const getPreviewModel = (preview) => preview?.preview;

package/dist/repository/SyncAction.respositoy.d.ts

@@ -118,4 +118,17 @@ export declare class uSyncActionRepository extends UmbControllerBase {
         request?: Request;
         response?: Response;
     }>>;
+    /**
+     * gets the current and incoming versions of an item, when its handler supports previews.
+     */
+    getPreview(handler: string, key: string): Promise<import("@umbraco-cms/backoffice/resources").UmbApiResponse<({
+        data: import("@jumoo/uSync").SyncItemPreviewResponse;
+        error: undefined;
+    } | {
+        data: undefined;
+        error: unknown;
+    }) & {
+        request?: Request;
+        response?: Response;
+    }>>;
 }

package/dist/repository/SyncAction.respositoy.js

@@ -121,5 +121,11 @@ export class uSyncActionRepository extends UmbControllerBase {
     async getSyncFileInfo() {
         return await __classPrivateFieldGet(this, _uSyncActionRepository_actionDataSource, "f").getSyncFileInfo();
     }
+    /**
+     * gets the current and incoming versions of an item, when its handler supports previews.
+     */
+    async getPreview(handler, key) {
+        return await __classPrivateFieldGet(this, _uSyncActionRepository_actionDataSource, "f").getPreview(handler, key);
+    }
 }
 _uSyncActionRepository_actionDataSource = new WeakMap(), _uSyncActionRepository_settingsDataSource = new WeakMap(), _uSyncActionRepository_migrartionDataSource = new WeakMap();

package/dist/repository/sources/SyncAction.source.d.ts

@@ -54,4 +54,14 @@ export declare class uSyncActionDataSource implements SyncActionDataSource {
         request?: Request;
         response?: Response;
     }>>;
+    getPreview(handler: string, key: string): Promise<import("@umbraco-cms/backoffice/resources").UmbApiResponse<({
+        data: import("@jumoo/uSync").SyncItemPreviewResponse;
+        error: undefined;
+    } | {
+        data: undefined;
+        error: unknown;
+    }) & {
+        request?: Request;
+        response?: Response;
+    }>>;
 }

package/dist/repository/sources/SyncAction.source.js

@@ -11,7 +11,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 };
 var _uSyncActionDataSource_host;
 import { tryExecute } from '@umbraco-cms/backoffice/resources';
-import { getActionsBySet, getRunning, getStatus, getSyncFileInfo, postDownload, postImport, postPerform, postProcessUpload, } from '@jumoo/uSync';
+import { getActionsBySet, getPreview, getRunning, getStatus, getSyncFileInfo, postDownload, postImport, postPerform, postProcessUpload, } from '@jumoo/uSync';
 export class uSyncActionDataSource {
     constructor(host) {
         _uSyncActionDataSource_host.set(this, void 0);
@@ -53,5 +53,10 @@ export class uSyncActionDataSource {
             body: view,
         }));
     }
+    async getPreview(handler, key) {
+        return await tryExecute(__classPrivateFieldGet(this, _uSyncActionDataSource_host, "f"), getPreview({
+            query: { handler, key },
+        }), { disableNotifications: true });
+    }
 }
 _uSyncActionDataSource_host = new WeakMap();

package/dist/signalr/signalr.context.js

@@ -1,19 +1,20 @@
-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 __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 _uSyncSignalRContext_instances, _uSyncSignalRContext_connection, _uSyncSignalRContext_connected, _uSyncSignalRContext_update, _uSyncSignalRContext_add, _uSyncSignalRContext_complete, _uSyncSignalRContext_setupConnection;
+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 _uSyncSignalRContext_instances, _uSyncSignalRContext_connection, _uSyncSignalRContext_auth, _uSyncSignalRContext_server, _uSyncSignalRContext_connect, _uSyncSignalRContext_clientId, _uSyncSignalRContext_connected, _uSyncSignalRContext_update, _uSyncSignalRContext_add, _uSyncSignalRContext_complete, _uSyncSignalRContext_setupConnection;
 import { UmbControllerBase } from '@umbraco-cms/backoffice/class-api';
 import { UmbObjectState } from '@umbraco-cms/backoffice/observable-api';
 import { USYNC_SIGNALR_CONTEXT_TOKEN, } from '@jumoo/uSync';
 import { UMB_AUTH_CONTEXT } from '@umbraco-cms/backoffice/auth';
+import { UMB_SERVER_CONTEXT } from '@umbraco-cms/backoffice/server';
 import * as signalR from '@jumoo/uSync/external/signalr';
 import { uSyncSignalRReconnectPolicy } from './signalr-reconnect-policy.js';
 export class uSyncSignalRContext extends UmbControllerBase {
@@ -21,6 +22,9 @@ export class uSyncSignalRContext extends UmbControllerBase {
         super(host);
         _uSyncSignalRContext_instances.add(this);
         _uSyncSignalRContext_connection.set(this, void 0);
+        _uSyncSignalRContext_auth.set(this, void 0);
+        _uSyncSignalRContext_server.set(this, void 0);
+        _uSyncSignalRContext_clientId.set(this, null);
         _uSyncSignalRContext_connected.set(this, new UmbObjectState(false));
         this.connected = __classPrivateFieldGet(this, _uSyncSignalRContext_connected, "f").asObservable();
         _uSyncSignalRContext_update.set(this, new UmbObjectState(undefined));
@@ -31,12 +35,12 @@ export class uSyncSignalRContext extends UmbControllerBase {
         this.complete = __classPrivateFieldGet(this, _uSyncSignalRContext_complete, "f").asObservable();
         this.provideContext(USYNC_SIGNALR_CONTEXT_TOKEN, this);
         this.consumeContext(UMB_AUTH_CONTEXT, (auth) => {
-            if (!auth)
-                return;
-            const authConfig = auth?.getOpenApiConfiguration();
-            if (!authConfig)
-                return;
-            __classPrivateFieldGet(this, _uSyncSignalRContext_instances, "m", _uSyncSignalRContext_setupConnection).call(this, '/umbraco/SyncHub', auth);
+            __classPrivateFieldSet(this, _uSyncSignalRContext_auth, auth, "f");
+            __classPrivateFieldGet(this, _uSyncSignalRContext_instances, "m", _uSyncSignalRContext_connect).call(this);
+        });
+        this.consumeContext(UMB_SERVER_CONTEXT, (server) => {
+            __classPrivateFieldSet(this, _uSyncSignalRContext_server, server, "f");
+            __classPrivateFieldGet(this, _uSyncSignalRContext_instances, "m", _uSyncSignalRContext_connect).call(this);
         });
     }
     hostConnected() {
@@ -49,7 +53,7 @@ export class uSyncSignalRContext extends UmbControllerBase {
         });
     }
     getClientId() {
-        return __classPrivateFieldGet(this, _uSyncSignalRContext_connection, "f")?.connectionId ?? null;
+        return __classPrivateFieldGet(this, _uSyncSignalRContext_clientId, "f");
     }
     /**
      * Synchronous read of the current connection state - used by callers
@@ -75,11 +79,34 @@ export class uSyncSignalRContext extends UmbControllerBase {
         __classPrivateFieldGet(this, _uSyncSignalRContext_update, "f").setValue({ message, count: 0, total: 1 });
     }
 }
-_uSyncSignalRContext_connection = new WeakMap(), _uSyncSignalRContext_connected = new WeakMap(), _uSyncSignalRContext_update = new WeakMap(), _uSyncSignalRContext_add = new WeakMap(), _uSyncSignalRContext_complete = new WeakMap(), _uSyncSignalRContext_instances = new WeakSet(), _uSyncSignalRContext_setupConnection = function _uSyncSignalRContext_setupConnection(url, auth) {
+_uSyncSignalRContext_connection = new WeakMap(), _uSyncSignalRContext_auth = new WeakMap(), _uSyncSignalRContext_server = new WeakMap(), _uSyncSignalRContext_clientId = new WeakMap(), _uSyncSignalRContext_connected = new WeakMap(), _uSyncSignalRContext_update = new WeakMap(), _uSyncSignalRContext_add = new WeakMap(), _uSyncSignalRContext_complete = new WeakMap(), _uSyncSignalRContext_instances = new WeakSet(), _uSyncSignalRContext_connect = function _uSyncSignalRContext_connect() {
+    // either context being re-provided replaces the connection, so
+    // stop the old one rather than leave it running alongside.
+    if (__classPrivateFieldGet(this, _uSyncSignalRContext_connection, "f")) {
+        __classPrivateFieldGet(this, _uSyncSignalRContext_connection, "f").stop();
+        __classPrivateFieldSet(this, _uSyncSignalRContext_connection, undefined, "f");
+        __classPrivateFieldSet(this, _uSyncSignalRContext_clientId, null, "f");
+        __classPrivateFieldGet(this, _uSyncSignalRContext_connected, "f").setValue(false);
+    }
+    if (!__classPrivateFieldGet(this, _uSyncSignalRContext_auth, "f") || !__classPrivateFieldGet(this, _uSyncSignalRContext_server, "f"))
+        return;
+    if (!__classPrivateFieldGet(this, _uSyncSignalRContext_auth, "f").getOpenApiConfiguration())
+        return;
+    const connection = __classPrivateFieldGet(this, _uSyncSignalRContext_server, "f").getServerConnection();
+    // Older Umbraco versions do not expose this setting.
+    const skipNegotiation = 'getSignalRSkipNegotiation' in connection &&
+        typeof connection.getSignalRSkipNegotiation === 'function' &&
+        connection.getSignalRSkipNegotiation() === true;
+    __classPrivateFieldGet(this, _uSyncSignalRContext_instances, "m", _uSyncSignalRContext_setupConnection).call(this, '/umbraco/SyncHub', __classPrivateFieldGet(this, _uSyncSignalRContext_auth, "f"), skipNegotiation);
+}, _uSyncSignalRContext_setupConnection = function _uSyncSignalRContext_setupConnection(url, auth, skipNegotiation) {
     // the token is fetched on every (re)connect, so a reconnect after
     // the original token has expired still authenticates.
     __classPrivateFieldSet(this, _uSyncSignalRContext_connection, new signalR.HubConnectionBuilder()
-        .withUrl(url, { accessTokenFactory: () => auth.getLatestToken() })
+        .withUrl(url, {
+        accessTokenFactory: () => auth.getLatestToken(),
+        skipNegotiation,
+        transport: skipNegotiation ? signalR.HttpTransportType.WebSockets : undefined,
+    })
         .withAutomaticReconnect(new uSyncSignalRReconnectPolicy())
         .configureLogging(signalR.LogLevel.Warning)
         .build(), "f");
@@ -92,19 +119,39 @@ _uSyncSignalRContext_connection = new WeakMap(), _uSyncSignalRContext_connected
     __classPrivateFieldGet(this, _uSyncSignalRContext_connection, "f").on('complete', (data) => {
         __classPrivateFieldGet(this, _uSyncSignalRContext_complete, "f").setValue(data);
     });
-    __classPrivateFieldGet(this, _uSyncSignalRContext_connection, "f").start().then(() => {
-        __classPrivateFieldGet(this, _uSyncSignalRContext_connected, "f").setValue(true);
+    const connection = __classPrivateFieldGet(this, _uSyncSignalRContext_connection, "f");
+    // a stopped connection can still report state while it winds down,
+    // only the current one may update connected.
+    const setConnected = (connected) => {
+        if (__classPrivateFieldGet(this, _uSyncSignalRContext_connection, "f") !== connection)
+            return;
+        if (!connected)
+            __classPrivateFieldSet(this, _uSyncSignalRContext_clientId, null, "f");
+        __classPrivateFieldGet(this, _uSyncSignalRContext_connected, "f").setValue(connected);
+    };
+    // the connection id comes from the negotiate response, so when
+    // negotiation is skipped we have to ask the hub for it.
+    const onConnected = async () => {
+        const clientId = connection.connectionId ??
+            (await connection.invoke('GetConnectionId').catch(() => null));
+        if (__classPrivateFieldGet(this, _uSyncSignalRContext_connection, "f") !== connection)
+            return;
+        __classPrivateFieldSet(this, _uSyncSignalRContext_clientId, clientId, "f");
+        setConnected(true);
+    };
+    connection
+        .start()
+        .then(onConnected)
+        .catch((error) => {
+        // with negotiation skipped there is no transport fallback, so a
+        // blocked WebSocket ends here; status polling covers progress.
+        console.warn('uSync: SignalR connection failed', error);
+        setConnected(false);
     });
     // the client id changes on reconnect, requests made after this
     // pick up the new one via getClientId().
-    __classPrivateFieldGet(this, _uSyncSignalRContext_connection, "f").onreconnecting(() => {
-        __classPrivateFieldGet(this, _uSyncSignalRContext_connected, "f").setValue(false);
-    });
-    __classPrivateFieldGet(this, _uSyncSignalRContext_connection, "f").onreconnected(() => {
-        __classPrivateFieldGet(this, _uSyncSignalRContext_connected, "f").setValue(true);
-    });
-    __classPrivateFieldGet(this, _uSyncSignalRContext_connection, "f").onclose(() => {
-        __classPrivateFieldGet(this, _uSyncSignalRContext_connected, "f").setValue(false);
-    });
+    connection.onreconnecting(() => setConnected(false));
+    connection.onreconnected(onConnected);
+    connection.onclose(() => setConnected(false));
 };
 export default uSyncSignalRContext;

package/dist/tree/usync.menu-element.js

@@ -37,17 +37,17 @@ let uSyncMenuElement = class uSyncMenuElement extends UmbElementMixin(LitElement
         });
     }
     render() {
-        return html `<umb-menu-item-layout
-			label=${this.manifest.meta.label ?? this.manifest.name}
-			icon-name=${this.manifest.meta.icon ?? 'icon-bug'}
-			.href=${this.itemPath}
-			?has-Children=${this.hasChildren}
-			>${this.renderChildren()}
+        return html `<umb-menu-item-layout
+			label=${this.manifest.meta.label ?? this.manifest.name}
+			icon-name=${this.manifest.meta.icon ?? 'icon-bug'}
+			.href=${this.itemPath}
+			?has-Children=${this.hasChildren}
+			>${this.renderChildren()}
 		</umb-menu-item-layout>`;
     }
     renderChildren() {
-        return html `<umb-extension-slot
-			type="usync-menuItem"
+        return html `<umb-extension-slot
+			type="usync-menuItem"
 			default-element="umb-menu-item-default"></umb-extension-slot>`;
     }
 };

package/dist/utils/preview/content-type-diff.d.ts

@@ -0,0 +1,18 @@
+import { type USyncPreviewContentType } from './content-type-layout.js';
+export type USyncPreviewStatus = 'added' | 'removed' | 'changed';
+export interface USyncPreviewItemChange {
+    status: USyncPreviewStatus;
+    /** the fields that differ (for a changed item) */
+    fields: string[];
+}
+export interface USyncContentTypeDiff {
+    /** top level fields (name, icon, compositions...) that differ */
+    fields: Set<string>;
+    properties: Map<string, USyncPreviewItemChange>;
+    containers: Map<string, USyncPreviewItemChange>;
+}
+/**
+ * compare two versions of a content type by key. Items only in the current
+ * version are being removed, items only in the incoming version are being added.
+ */
+export declare function diffContentTypes(current: USyncPreviewContentType | undefined, incoming: USyncPreviewContentType | undefined): USyncContentTypeDiff;