@disy/cadenza.js 1.0.0 → 1.1.0

package/cadenza.js

@@ -4,23 +4,28 @@
  * @param {string} baseUrl - The base URL of the Cadenza server
  * @param {object} [options] - Options
  * @param {HTMLIFrameElement | string} [options.iframe] - An iframe for embedding Cadenza or the iframe's ID
+ * @param {ExternalLinkKey} [options.webApplication] - An external link that Cadenza uses to resolve the [target origin](https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage#targetorigin) when posting events. This is required if Cadenza and your application are not running on the same origin.
  * @param {boolean} [options.debug] - Whether to enable debug logging
- * @throws For invalid base URL
+ * @throws For invalid arguments
  */
 export function cadenza(baseUrl, options) {
     return new CadenzaClient(baseUrl, options);
 }
 /* @ts-ignore */
 const previousGlobalCadenza = globalThis.cadenza;
-globalThis.cadenza = Object.assign(
-/** @param {Parameters<cadenza>} args */
-(...args) => cadenza(...args), {
+globalThis.cadenza = Object.assign((/** @type Parameters<cadenza> */ ...args) => cadenza(...args), {
     noConflict() {
         globalThis.cadenza = previousGlobalCadenza;
         return cadenza;
     },
 });
 /** @typedef {string} EmbeddingTargetId - The ID of an embedding target */
+/** @typedef {string} GlobalId - The ID of a navigator item */
+/**
+ * @typedef ExternalLinkKey - A tuple qualifying a Cadenza external link
+ * @property {string} repositoryName - The name of the link's repository
+ * @property {string} externalLinkId - The ID of the external link
+ */
 /**
  * @typedef WorkbookKey - A tuple qualifying a workbook
  * @property {string} repositoryName - The name of the workbook's repository
@@ -41,6 +46,14 @@ globalThis.cadenza = Object.assign(
 /** @typedef {EmbeddingTargetId | WorkbookKey} WorkbookSource - A workbook source */
 /** @typedef {EmbeddingTargetId | WorksheetKey} WorksheetSource - A worksheet source */
 /** @typedef {EmbeddingTargetId | WorkbookViewKey} WorkbookViewSource - A workbook view source */
+/** @typedef {'normal'|'simplified'} OperationMode - The mode in which a workbook should be operated */
+/**
+ * @typedef {'workbook-design'|'workbook-view-management'} UiFeature - The name of a Cadenza UI feature
+ *
+ * _Note:_ Supported features are:
+ * * 'workbook-design' - The workbook designer
+ * * 'workbook-view-management' - Add/Edit/Remove workbook views (Is included in 'workbook-design'.)
+ * */
 /**
  * @typedef Geometry - A [GeoJSON](https://geojson.org/) geometry object
  * @property {GeometryType} type - The type of the geometry
@@ -67,6 +80,8 @@ export class CadenzaClient {
     #origin;
     /** @readonly */
     #iframe;
+    /** @readonly @type {ExternalLinkKey | undefined} */
+    #webApplication;
     /** @type {HTMLIFrameElement | undefined} */
     #iframeElement;
     /** @readonly */
@@ -78,19 +93,24 @@ export class CadenzaClient {
      * @param {string} baseUrl
      * @param {object} [options]
      * @param {HTMLIFrameElement | string} [options.iframe]
+     * @param {ExternalLinkKey} [options.webApplication]
      * @param {boolean} [options.debug]
      */
-    constructor(baseUrl, { debug = false, iframe } = {}) {
+    constructor(baseUrl, { debug = false, iframe, webApplication } = {}) {
         assert(validUrl(baseUrl), `Invalid baseUrl: ${baseUrl}`);
+        if (webApplication) {
+            assert(validExternalLinkKey(webApplication), `Invalid webApplication parameter: ${webApplication}`);
+        }
         // Remove trailing /
         if (baseUrl.at(-1) === '/') {
             baseUrl = baseUrl.substring(0, baseUrl.length - 1);
         }
-        this.#log('Create Cadenza client', baseUrl, iframe);
         this.#baseUrl = baseUrl;
         this.#origin = new URL(baseUrl).origin;
         this.#iframe = iframe;
         this.#debug = debug;
+        this.#webApplication = webApplication;
+        this.#log('Create Cadenza client', baseUrl, iframe);
     }
     /** The base URL of the Cadenza server this client is requesting */
     get baseUrl() {
@@ -117,48 +137,69 @@ export class CadenzaClient {
      *
      * @param {WorkbookSource | WorksheetSource | WorkbookViewSource} source - The source to show
      * @param {object} [options]
-     * @param {boolean} [options.hideMainHeaderAndFooter] - Whether to hide the main Cadenza header and footer.
-     * @param {boolean} [options.hideWorkbookToolBar] - Whether to hide the workbook toolbar.
+     * @param {UiFeature[]} [options.disabledUiFeatures] - Cadenza UI features to disable
+     * @param {boolean} [options.hideMainHeaderAndFooter] - Whether to hide the main Cadenza header and footer
+     * @param {boolean} [options.hideWorkbookToolBar] - Whether to hide the workbook toolbar
+     * @param {GlobalId} [options.highlightGlobalId] - The ID of an item to highlight / expand in the navigator
+     * @param {string} [options.mediaType] - Set to 'application/pdf' for views of type "JasperReports report"
+     *     to show the report PDF directly, without any Cadenza headers or footers.
+     * @param {OperationMode} [options.operationMode] - The mode in which a workbook should be operated
      * @param {AbortSignal} [options.signal] - A signal to abort the iframe loading
      * @return {Promise<void>} A Promise for when the iframe is loaded
-     * @throws For an invalid source
+     * @throws For invalid arguments
      */
-    show(source, { hideMainHeaderAndFooter, hideWorkbookToolBar, signal } = {}) {
+    show(source, { disabledUiFeatures, hideMainHeaderAndFooter, hideWorkbookToolBar, highlightGlobalId, mediaType, operationMode, signal, } = {}) {
         this.#log('CadenzaClient#show', source);
-        const params = new URLSearchParams({
-            ...(hideMainHeaderAndFooter && { hideMainHeaderAndFooter: 'true' }),
-            ...(hideWorkbookToolBar && { hideWorkbookToolBar: 'true' }),
+        if (mediaType) {
+            assertSupportedMediaType(mediaType, [MediaType.PDF]);
+        }
+        const params = createParams({
+            disabledUiFeatures,
+            hideMainHeaderAndFooter,
+            hideWorkbookToolBar,
+            highlightGlobalId,
+            operationMode,
+            mediaType,
+            webApplication: this.#webApplication,
         });
-        return this.#show(resolvePath(source), { params, signal });
+        return this.#show(resolvePath(source), params, signal);
     }
     /**
      * Show a workbook map view in an iframe.
      *
      * @param {WorkbookViewSource} mapView - The workbook map view to show
      * @param {object} [options] - Options
+     * @param {UiFeature[]} [options.disabledUiFeatures] - Cadenza UI features to disable
      * @param {Geometry} [options.geometry] - A geometry to show on the map
-     * @param {boolean} [options.hideMainHeaderAndFooter] - Whether to hide the main Cadenza header and footer.
-     * @param {boolean} [options.hideWorkbookToolBar] - Whether to hide the workbook toolbar.
+     * @param {boolean} [options.hideMainHeaderAndFooter] - Whether to hide the main Cadenza header and footer
+     * @param {boolean} [options.hideWorkbookToolBar] - Whether to hide the workbook toolbar
+     * @param {GlobalId} [options.highlightGlobalId] - The ID of an item to highlight / expand in the navigator
      * @param {string} [options.locationFinder] - A search query for the location finder
      * @param {Extent} [options.mapExtent] - A map extent to set
+     * @param {OperationMode} [options.operationMode] - The mode in which a workbook should be operated
      * @param {boolean} [options.useMapSrs] -  Whether the geometry and the extent are in the map's SRS (otherwise EPSG:4326 is assumed)
      * @param {AbortSignal} [options.signal] - A signal to abort the iframe loading
      * @return {Promise<void>} A Promise for when the iframe is loaded
-     * @throws For an invalid workbook view source or geometry type
+     * @throws For invalid arguments
      */
-    showMap(mapView, { geometry, hideMainHeaderAndFooter, hideWorkbookToolBar, locationFinder, mapExtent, useMapSrs, signal, } = {}) {
+    async showMap(mapView, { disabledUiFeatures, geometry, hideMainHeaderAndFooter, hideWorkbookToolBar, highlightGlobalId, locationFinder, mapExtent, operationMode, useMapSrs, signal, } = {}) {
         this.#log('CadenzaClient#showMap', mapView, geometry);
         if (geometry) {
             assertValidGeometryType(geometry.type);
         }
-        const params = new URLSearchParams({
-            ...(hideMainHeaderAndFooter && { hideMainHeaderAndFooter: 'true' }),
-            ...(hideWorkbookToolBar && { hideWorkbookToolBar: 'true' }),
-            ...(locationFinder && { locationFinder }),
-            ...(mapExtent && { mapExtent: mapExtent.join() }),
-            ...(useMapSrs && { useMapSrs: 'true' }),
+        const params = createParams({
+            disabledUiFeatures,
+            hideMainHeaderAndFooter,
+            hideWorkbookToolBar,
+            highlightGlobalId,
+            locationFinder,
+            mapExtent,
+            operationMode,
+            useMapSrs,
+            webApplication: this.#webApplication,
         });
-        return this.#show(resolvePath(mapView), { params, signal }).then(() => this.#postEvent('setGeometry', { geometry }));
+        await this.#show(resolvePath(mapView), params, signal);
+        this.#postEvent('setGeometry', { geometry });
     }
     /**
      * Create a geometry.
@@ -169,29 +210,29 @@ export class CadenzaClient {
      * @param {WorkbookViewSource} backgroundMapView - The workbook map view in the background
      * @param {GeometryType} geometryType - The geometry type
      * @param {object} [options] - Options
-     * @param {Extent} [options.mapExtent] - A map extent to set
      * @param {string} [options.locationFinder] - A search query for the location finder
-     * @param {boolean} [options.useMapSrs] - Whether the created geometry should use the map's SRS (otherwise EPSG:4326 will be used)
+     * @param {Extent} [options.mapExtent] - A map extent to set
      * @param {number} [options.minScale] - The minimum scale where the user should work on. A warning is shown when the map is zoomed out above the threshold.
+     * @param {boolean} [options.useMapSrs] - Whether the created geometry should use the map's SRS (otherwise EPSG:4326 will be used)
      * @param {AbortSignal} [options.signal] - A signal to abort the iframe loading
      * @return {Promise<void>} A Promise for when the iframe is loaded
-     * @throws For an invalid workbook view source or geometry type
+     * @throws For invalid arguments
      * @fires `editGeometry:update` - When the user changed the geometry. The event includes the edited geometry.
      * @fires `editGeometry:ok` - When the user completed the geometry editing. The event includes the edited geometry.
      * @fires `editGeometry:cancel` - When the user cancelled the geometry editing in Cadenza.
      */
-    createGeometry(backgroundMapView, geometryType, { mapExtent, locationFinder, useMapSrs, minScale, signal } = {}) {
+    createGeometry(backgroundMapView, geometryType, { locationFinder, mapExtent, minScale, useMapSrs, signal } = {}) {
         this.#log('CadenzaClient#createGeometry', backgroundMapView, geometryType);
-        assertValidGeometryType(geometryType);
-        const params = new URLSearchParams({
+        const params = createParams({
             action: 'editGeometry',
             geometryType,
-            ...(useMapSrs && { useMapSrs: 'true' }),
-            ...(locationFinder && { locationFinder }),
-            ...(mapExtent && { mapExtent: mapExtent.join() }),
-            ...(minScale && { minScale: String(minScale) }),
+            locationFinder,
+            mapExtent,
+            minScale,
+            useMapSrs,
+            webApplication: this.#webApplication,
         });
-        return this.#show(resolvePath(backgroundMapView), { params, signal });
+        return this.#show(resolvePath(backgroundMapView), params, signal);
     }
     /**
      * Edit a geometry.
@@ -201,48 +242,39 @@ export class CadenzaClient {
      * @param {object} [options] - Options
      * @param {string} [options.locationFinder] - A search query for the location finder
      * @param {Extent} [options.mapExtent] - A map extent to set
-     * @param {boolean} [options.useMapSrs] - Whether the geometry is in the map's SRS (otherwise EPSG:4326 is assumed)
      * @param {number} [options.minScale] - The minimum scale where the user should work on. A warning is shown when the map is zoomed out above the threshold.
+     * @param {boolean} [options.useMapSrs] - Whether the geometry is in the map's SRS (otherwise EPSG:4326 is assumed)
      * @param {AbortSignal} [options.signal] - A signal to abort the iframe loading
      * @return {Promise<void>} A Promise for when the iframe is loaded
-     * @throws For an invalid workbook view source
+     * @throws For invalid arguments
      * @fires `editGeometry:update` - When the user changed the geometry. The event includes the edited geometry.
      * @fires `editGeometry:ok` - When the user completed the geometry editing. The event includes the edited geometry.
      * @fires `editGeometry:cancel` - When the user cancelled the geometry editing in Cadenza.
      */
-    editGeometry(backgroundMapView, geometry, { mapExtent, locationFinder, useMapSrs, minScale, signal } = {}) {
+    async editGeometry(backgroundMapView, geometry, { locationFinder, mapExtent, minScale, useMapSrs, signal } = {}) {
         this.#log('CadenzaClient#editGeometry', backgroundMapView, geometry);
         assertValidGeometryType(geometry.type);
-        const params = new URLSearchParams({
+        const params = createParams({
             action: 'editGeometry',
-            ...(locationFinder && { locationFinder }),
-            ...(mapExtent && { mapExtent: mapExtent.join() }),
-            ...(useMapSrs && { useMapSrs: 'true' }),
-            ...(minScale && { minScale: String(minScale) }),
+            locationFinder,
+            mapExtent,
+            minScale,
+            useMapSrs,
+            webApplication: this.#webApplication,
         });
-        return this.#show(resolvePath(backgroundMapView), { params, signal }).then(() => this.#postEvent('setGeometry', { geometry }));
+        await this.#show(resolvePath(backgroundMapView), params, signal);
+        this.#postEvent('setGeometry', { geometry });
     }
-    /**
-     * @param {string} path
-     * @param {object} options
-     * @param {URLSearchParams} [options.params]
-     * @param {AbortSignal} [options.signal]
-     */
-    #show(path, { params, signal }) {
-        const url = new URL(this.baseUrl + path);
-        if (params) {
-            for (const [param, value] of params) {
-                url.searchParams.append(param, value);
-            }
-        }
+    #show(
+    /** @type string */ path, 
+    /** @type URLSearchParams */ params, 
+    /** @type AbortSignal | undefined */ signal) {
+        const url = this.#createUrl(path, params);
         this.#log('Load iframe', url.toString());
         this.#requiredIframe.src = url.toString();
         return this.#getIframePromise(signal);
     }
-    /**
-     * @param {AbortSignal} [signal]
-     */
-    #getIframePromise(signal) {
+    #getIframePromise(/** @type AbortSignal | undefined */ signal) {
         const iframe = this.#requiredIframe;
         /** @type {() => void} */
         let onerror;
@@ -269,8 +301,9 @@ export class CadenzaClient {
                 }),
             ];
         });
-        promise.then(() => this.#log('Iframe loaded'), (error) => this.#log('Iframe loading failed', error));
-        promise.finally(() => {
+        promise
+            .then(() => this.#log('Iframe loaded'), (error) => this.#log('Iframe loading failed', error))
+            .finally(() => {
             iframe.removeEventListener('error', onerror);
             signal?.removeEventListener('abort', onabort);
             unsubscribes.forEach((unsubscribe) => unsubscribe());
@@ -303,9 +336,8 @@ export class CadenzaClient {
             }
         };
     }
-    /** @param {MessageEvent<CadenzaEvent<never>>} event */
     // Use arrow function so that it's bound to this.
-    #onMessage = (event) => {
+    #onMessage = (/** @type MessageEvent<CadenzaEvent<never>> */ event) => {
         this.#log('Received message', event);
         if (event.origin !== this.#origin ||
             event.source !== this.#requiredIframe.contentWindow) {
@@ -318,25 +350,98 @@ export class CadenzaClient {
             }
         });
     };
-    /**
-     * @param {string} type
-     * @param {unknown} detail
-     */
-    #postEvent(type, detail) {
+    #postEvent(/** @type string */ type, /** @type unknown */ detail) {
         const event = { type, detail };
         this.#log('postMessage', event);
         const contentWindow = /** @type {WindowProxy} */ (this.#requiredIframe.contentWindow);
         contentWindow.postMessage(event, { targetOrigin: this.#origin });
     }
-    /** @param {unknown[]} args */
-    #log(...args) {
+    /**
+     * Fetch data from a workbook view.
+     *
+     * @param {WorkbookViewSource} source - The workbook view to fetch data from
+     * @param {MediaType} mediaType - The media type to use for the data. Allowed are:
+     * * 'application/json'
+     * * 'application/pdf' (for Jasper Report views)
+     * * 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' (Excel)
+     * * 'text/csv'
+     * @param {object} options - Options
+     * @param {AbortSignal} [options.signal] - A signal to abort the data fetching
+     * @return {Promise<Response>} A Promise for the fetch response
+     * @throws For invalid arguments
+     */
+    fetchData(source, mediaType, { signal } = {}) {
+        this.#log('CadenzaClient#fetchData', source, mediaType);
+        assertSupportedMediaType(mediaType);
+        const params = createParams({ mediaType });
+        return this.#fetch(resolvePath(source), params, signal);
+    }
+    async #fetch(
+    /** @type string */ path, 
+    /** @type URLSearchParams */ params, 
+    /** @type AbortSignal | undefined */ signal) {
+        const url = this.#createUrl(path, params);
+        this.#log('Fetch', url.toString());
+        const res = await fetch(url, { signal });
+        if (!res.ok) {
+            const errorType = {
+                400: 'bad-request',
+                401: 'unauthorized',
+                404: 'not-found',
+            }[res.status] ?? 'internal-error';
+            throw new CadenzaError(errorType, 'Failed to fetch data');
+        }
+        return res;
+    }
+    /**
+     * Download data from a workbook view.
+     *
+     * _Note:_ The file name, if not provided, is generated from the name of the workbook view and the current date.
+     *
+     * @param {WorkbookViewSource} source - The workbook view to download data from
+     * @param {MediaType} mediaType - The media type to use for the data. Allowed are:
+     * * 'application/json'
+     * * 'application/pdf' (for Jasper Report views)
+     * * 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' (Excel)
+     * * 'text/csv'
+     * @param {object} options - Options
+     * @param {string} [options.fileName] - The file name to use; The file extension is appended by Cadenza.
+     * @throws For invalid arguments
+     */
+    downloadData(source, mediaType, { fileName }) {
+        this.#log('CadenzaClient#downloadData', source, mediaType);
+        assertSupportedMediaType(mediaType);
+        const params = createParams({ fileName, mediaType });
+        this.#download(resolvePath(source), params);
+    }
+    #download(/** @type string */ path, /** @type URLSearchParams */ params) {
+        const url = this.#createUrl(path, params);
+        const a = document.createElement('a');
+        a.href = url.toString();
+        // causes the file to be downloaded even if the server sends a "Content-disposition: inline" header
+        a.download = '';
+        a.hidden = true;
+        document.body.append(a);
+        a.click();
+        a.remove();
+    }
+    #createUrl(/** @type string */ path, /** @type URLSearchParams */ params) {
+        const url = new URL(this.baseUrl + path);
+        if (params) {
+            for (const [param, value] of params) {
+                url.searchParams.append(param, value);
+            }
+        }
+        return url;
+    }
+    #log(/** @type unknown[] */ ...args) {
         if (this.#debug) {
             console.log(...args);
         }
     }
 }
-/** @param {WorkbookSource | WorksheetSource | WorkbookViewSource} source */
-function resolvePath(source) {
+function resolvePath(
+/** @type WorkbookSource | WorksheetSource | WorkbookViewSource */ source) {
     if (typeof source === 'string') {
         assert(validEmbeddingTargetId(source), `Invalid embedding target ID: ${source}`);
         return `/w/${source}`;
@@ -359,17 +464,12 @@ function resolvePath(source) {
         return path;
     }
 }
-/**
- * @param {boolean} assertion
- * @param {string} message
- */
-function assert(assertion, message) {
+function assert(/** @type boolean */ assertion, /** @type string */ message) {
     if (!assertion) {
         throw new Error(message);
     }
 }
-/** @param {string} value */
-function validUrl(value) {
+function validUrl(/** @type string */ value) {
     try {
         new URL(value);
         return true;
@@ -378,16 +478,13 @@ function validUrl(value) {
         return false;
     }
 }
-/** @param {string} value */
-function validEmbeddingTargetId(value) {
+function validEmbeddingTargetId(/** @type string */ value) {
     return /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(value);
 }
-/** @param {string} value */
-function validRepositoryName(value) {
+function validRepositoryName(/** @type string */ value) {
     return /^[\w -]{1,255}$/.test(value);
 }
-/** @param {string} value */
-function validWorkbookId(value) {
+function validWorkbookId(/** @type string */ value) {
     try {
         // Workbook IDs are url-safe base64 strings.
         // https://stackoverflow.com/a/44528376
@@ -398,12 +495,14 @@ function validWorkbookId(value) {
         return false;
     }
 }
-/** @param {string} value */
-function assertValidGeometryType(value) {
-    assert(validGeometryType(value), 'Invalid geometry type');
+function validExternalLinkKey(/** @type ExternalLinkKey */ linkKey) {
+    return (validRepositoryName(linkKey.repositoryName) &&
+        validWorkbookId(linkKey.externalLinkId));
+}
+function assertValidGeometryType(/** @type string */ value) {
+    assert(validGeometryType(value), `Invalid geometry type: ${value}`);
 }
-/** @param {string} value */
-function validGeometryType(value) {
+function validGeometryType(/** @type string */ value) {
     return [
         'Point',
         'MultiPoint',
@@ -413,6 +512,78 @@ function validGeometryType(value) {
         'MultiPolygon',
     ].includes(value);
 }
+function validOperationMode(/** @type string */ value) {
+    return ['normal', 'simplified'].includes(value);
+}
+function validUiFeature(/** @type string */ value) {
+    return ['workbook-design', 'workbook-view-management'].includes(value);
+}
+/**
+ * @typedef {string} MediaType - A media type
+ *
+ * See {@link https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types}
+ */
+const MediaType = /** @type {Record<string, MediaType>} */ {
+    CSV: 'text/csv',
+    EXCEL: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    JSON: 'application/json',
+    PDF: 'application/pdf',
+};
+function assertSupportedMediaType(
+/** @type MediaType */ type, 
+/** @type MediaType[] */ supportedTypes = Object.values(MediaType)) {
+    return assert(supportedTypes.includes(type), `Invalid media type: ${type}`);
+}
+/**
+ * @param {object} params - Options
+ * @param {string} [params.action]
+ * @param {UiFeature[]} [params.disabledUiFeatures]
+ * @param {string} [params.fileName]
+ * @param {GeometryType} [params.geometryType]
+ * @param {boolean} [params.hideMainHeaderAndFooter]
+ * @param {boolean} [params.hideWorkbookToolBar]
+ * @param {GlobalId} [params.highlightGlobalId]
+ * @param {string} [params.locationFinder]
+ * @param {Extent} [params.mapExtent]
+ * @param {string} [params.mediaType]
+ * @param {number} [params.minScale]
+ * @param {OperationMode} [params.operationMode]
+ * @param {boolean} [params.useMapSrs]
+ * @param {ExternalLinkKey} [params.webApplication]
+ * @return {URLSearchParams}
+ */
+function createParams({ action, fileName, geometryType, hideMainHeaderAndFooter, hideWorkbookToolBar, highlightGlobalId, locationFinder, mapExtent, mediaType, minScale, useMapSrs, webApplication, operationMode, disabledUiFeatures, }) {
+    if (disabledUiFeatures) {
+        disabledUiFeatures.forEach((feature) => assert(validUiFeature(feature), `Invalid UI feature: ${feature}`));
+    }
+    if (geometryType) {
+        assertValidGeometryType(geometryType);
+    }
+    if (operationMode) {
+        assert(validOperationMode(operationMode), `Invalid operation mode: ${operationMode}`);
+    }
+    return new URLSearchParams({
+        ...(action && { action }),
+        ...(disabledUiFeatures && {
+            disabledUiFeatures: disabledUiFeatures.join(),
+        }),
+        ...(fileName && { fileName }),
+        ...(geometryType && { geometryType }),
+        ...(hideMainHeaderAndFooter && { hideMainHeaderAndFooter: 'true' }),
+        ...(hideWorkbookToolBar && { hideWorkbookToolBar: 'true' }),
+        ...(highlightGlobalId && { highlightGlobalId }),
+        ...(locationFinder && { locationFinder }),
+        ...(mapExtent && { mapExtent: mapExtent.join() }),
+        ...(mediaType && { mediaType }),
+        ...(minScale && { minScale: String(minScale) }),
+        ...(operationMode && { operationMode }),
+        ...(useMapSrs && { useMapSrs: 'true' }),
+        ...(webApplication && {
+            webApplicationLink: webApplication.externalLinkId,
+            webApplicationLinkRepository: webApplication.repositoryName,
+        }),
+    });
+}
 /**
  * @template [T=unknown]
  * @typedef CadenzaEvent - A Cadenza `postMessage()` event

package/package.json

@@ -1,6 +1,8 @@
 {
   "name": "@disy/cadenza.js",
-  "version": "1.0.0",
+  "version": "1.1.0",
+  "license": "Apache-2.0",
+  "repository": "github:DisyInformationssysteme/cadenza.js",
   "type": "module",
   "main": "./cadenza.js",
   "types": "./cadenza.d.ts",
@@ -8,27 +10,32 @@
     "apidoc/**/*",
     "cadenza.js",
     "cadenza.d.ts",
-    "CHANGELOG.md"
+    "CHANGELOG.md",
+    "sandbox.html"
   ],
   "scripts": {
-    "build": "run-p build:*",
+    "build": "run-p validate:* build:*",
     "build:docs": "typedoc",
     "build:ts": "tsc",
-    "reformat": "prettier ./src --write",
+    "validate:format": "prettier ./src --check",
+    "validate:changelog": "changelog --latest-release",
     "start": "run-p start:*",
     "start:docs": "npm run build:docs -- --watch",
     "start:test": "npm test -- --watch",
+    "start:ts": "npm run build:ts -- --watch",
     "start:reformat": "onchange \"src/**/*\" -- prettier {{changed}} --write",
     "test": "cross-env NODE_OPTIONS=--unhandled-rejections=warn jest",
     "deploy:docs": "gh-pages --dist apidoc",
-    "sandbox": "npx http-server -a localhost -c-1 -d false --proxy http://localhost:8000 -o /sandbox.html"
+    "sandbox": "node ./sandbox.cjs"
   },
   "devDependencies": {
     "@types/jest": "29.5.3",
     "cross-env": "7.0.3",
     "gh-pages": "6.0.0",
+    "http-server": "14.1.1",
     "jest": "29.6.1",
     "jest-environment-jsdom": "29.6.1",
+    "keep-a-changelog": "2.3.0",
     "npm-run-all": "4.1.5",
     "onchange": "7.1.0",
     "prettier": "3.0.0",