@vcmap/ui 6.1.0-rc.2 → 6.1.0-rc.3

package/src/application/positionDisplayInteraction.js

@@ -55,7 +55,7 @@ class PositionDisplayInteraction extends AbstractInteraction {
    * @returns {Promise<import("@vcmap/core").InteractionEvent>}
    */
   pipe(event) {
-    if (!event.position.every((pos) => pos === 0)) {
+    if (event.position && !event.position.every((pos) => pos === 0)) {
       this.position.value = [...event.position];
     }
     return Promise.resolve(event);

package/src/callback/activateClippingPolygonCallback.d.ts

@@ -0,0 +1,29 @@
+export default ActivateClippingPolygonCallback;
+export type ActivateClippingPolygonOptions = import("./vcsCallback.js").VcsCallbackOptions & {
+    names: string[];
+};
+/**
+ * @typedef {import("./vcsCallback.js").VcsCallbackOptions & { names: string[] }} ActivateClippingPolygonOptions
+ * @property {string[]} names - names of the ClippingPolygonObjects to activate
+ */
+/**
+ * @class
+ * @extends {VcsCallback}
+ */
+declare class ActivateClippingPolygonCallback extends VcsCallback {
+    /**
+     * @param {ActivateClippingPolygonOptions} options
+     * @param {import("@src/vcsUiApp.js").default} app
+     */
+    constructor(options: ActivateClippingPolygonOptions, app: import("@src/vcsUiApp.js").default);
+    /**
+     * @type {string[]}
+     * @private
+     */
+    private _names;
+    /**
+     * @returns {ActivateClippingPolygonOptions}
+     */
+    toJSON(): ActivateClippingPolygonOptions;
+}
+import VcsCallback from './vcsCallback.js';

package/src/callback/activateClippingPolygonCallback.js

@@ -0,0 +1,54 @@
+import VcsCallback, { callbackClassRegistry } from './vcsCallback.js';
+
+/**
+ * @typedef {import("./vcsCallback.js").VcsCallbackOptions & { names: string[] }} ActivateClippingPolygonOptions
+ * @property {string[]} names - names of the ClippingPolygonObjects to activate
+ */
+
+/**
+ * @class
+ * @extends {VcsCallback}
+ */
+class ActivateClippingPolygonCallback extends VcsCallback {
+  /**
+   * @type {string}
+   */
+  static get className() {
+    return 'ActivateClippingPolygonCallback';
+  }
+
+  /**
+   * @param {ActivateClippingPolygonOptions} options
+   * @param {import("@src/vcsUiApp.js").default} app
+   */
+  constructor(options, app) {
+    super(options, app);
+    /**
+     * @type {string[]}
+     * @private
+     */
+    this._names = options.names;
+  }
+
+  callback() {
+    this._names
+      .map((n) => this._app.clippingPolygons.getByKey(n))
+      .filter((l) => l)
+      .forEach((l) => l.activate());
+  }
+
+  /**
+   * @returns {ActivateClippingPolygonOptions}
+   */
+  toJSON() {
+    const config = super.toJSON();
+    config.names = this._names.slice();
+    return config;
+  }
+}
+
+export default ActivateClippingPolygonCallback;
+callbackClassRegistry.registerClass(
+  ActivateClippingPolygonCallback.className,
+  ActivateClippingPolygonCallback,
+);

package/src/callback/closeSplashScreenCallback.d.ts

@@ -0,0 +1,8 @@
+export default CloseSplashScreenCallback;
+/**
+ * @class
+ * @extends {VcsCallback}
+ */
+declare class CloseSplashScreenCallback extends VcsCallback {
+}
+import VcsCallback from './vcsCallback.js';

package/src/callback/closeSplashScreenCallback.js

@@ -0,0 +1,33 @@
+import VcsCallback, { callbackClassRegistry } from './vcsCallback.js';
+
+/**
+ * @class
+ * @extends {VcsCallback}
+ */
+class CloseSplashScreenCallback extends VcsCallback {
+  /**
+   * @type {string}
+   */
+  static get className() {
+    return 'CloseSplashScreenCallback';
+  }
+
+  callback() {
+    this._app.uiConfig.showSplashScreen = false;
+  }
+
+  /**
+   * @returns {import('./vcsCallback.js').VcsCallbackOptions}
+   */
+  toJSON() {
+    return super.toJSON();
+  }
+}
+
+export default CloseSplashScreenCallback;
+
+// Register the class
+callbackClassRegistry.registerClass(
+  CloseSplashScreenCallback.className,
+  CloseSplashScreenCallback,
+);

package/src/callback/deactivateClippingPolygonCallback.d.ts

@@ -0,0 +1,29 @@
+export default DeactivateClippingPolygonCallback;
+export type DeactivateClippingPolygonOptions = import("./vcsCallback.js").VcsCallbackOptions & {
+    names: string[];
+};
+/**
+ * @typedef {import("./vcsCallback.js").VcsCallbackOptions & { names: string[] }} DeactivateClippingPolygonOptions
+ * @property {string[]} names - names of the ClippingPolygonObjects to deactivate
+ */
+/**
+ * @class
+ * @extends {VcsCallback}
+ */
+declare class DeactivateClippingPolygonCallback extends VcsCallback {
+    /**
+     * @param {DeactivateClippingPolygonOptions} options
+     * @param {import("@src/vcsUiApp.js").default} app
+     */
+    constructor(options: DeactivateClippingPolygonOptions, app: import("@src/vcsUiApp.js").default);
+    /**
+     * @type {string[]}
+     * @private
+     */
+    private _names;
+    /**
+     * @returns {DeactivateClippingPolygonOptions}
+     */
+    toJSON(): DeactivateClippingPolygonOptions;
+}
+import VcsCallback from './vcsCallback.js';

package/src/callback/deactivateClippingPolygonCallback.js

@@ -0,0 +1,54 @@
+import VcsCallback, { callbackClassRegistry } from './vcsCallback.js';
+
+/**
+ * @typedef {import("./vcsCallback.js").VcsCallbackOptions & { names: string[] }} DeactivateClippingPolygonOptions
+ * @property {string[]} names - names of the ClippingPolygonObjects to deactivate
+ */
+
+/**
+ * @class
+ * @extends {VcsCallback}
+ */
+class DeactivateClippingPolygonCallback extends VcsCallback {
+  /**
+   * @type {string}
+   */
+  static get className() {
+    return 'DeactivateClippingPolygonCallback';
+  }
+
+  /**
+   * @param {DeactivateClippingPolygonOptions} options
+   * @param {import("@src/vcsUiApp.js").default} app
+   */
+  constructor(options, app) {
+    super(options, app);
+    /**
+     * @type {string[]}
+     * @private
+     */
+    this._names = options.names;
+  }
+
+  callback() {
+    this._names
+      .map((n) => this._app.clippingPolygons.getByKey(n))
+      .filter((l) => l)
+      .forEach((l) => l.deactivate());
+  }
+
+  /**
+   * @returns {DeactivateClippingPolygonOptions}
+   */
+  toJSON() {
+    const config = super.toJSON();
+    config.names = this._names.slice();
+    return config;
+  }
+}
+
+export default DeactivateClippingPolygonCallback;
+callbackClassRegistry.registerClass(
+  DeactivateClippingPolygonCallback.className,
+  DeactivateClippingPolygonCallback,
+);

package/src/callback/openSplashScreenCallback.d.ts

@@ -0,0 +1,8 @@
+export default OpenSplashScreenCallback;
+/**
+ * @class
+ * @extends {VcsCallback}
+ */
+declare class OpenSplashScreenCallback extends VcsCallback {
+}
+import VcsCallback from './vcsCallback.js';

package/src/callback/openSplashScreenCallback.js

@@ -0,0 +1,35 @@
+import VcsCallback, { callbackClassRegistry } from './vcsCallback.js';
+
+/**
+ * @class
+ * @extends {VcsCallback}
+ */
+class OpenSplashScreenCallback extends VcsCallback {
+  /**
+   * @type {string}
+   */
+  static get className() {
+    return 'OpenSplashScreenCallback';
+  }
+
+  callback() {
+    if (this._app.uiConfig.getByKey('splashScreen')) {
+      this._app.uiConfig.showSplashScreen = true;
+    }
+  }
+
+  /**
+   * @returns {import('./vcsCallback.js').VcsCallbackOptions}
+   */
+  toJSON() {
+    return super.toJSON();
+  }
+}
+
+export default OpenSplashScreenCallback;
+
+// Register the class
+callbackClassRegistry.registerClass(
+  OpenSplashScreenCallback.className,
+  OpenSplashScreenCallback,
+);

package/src/callback/toggleNavbarButtonCallback.d.ts

@@ -0,0 +1,36 @@
+export default ToggleNavbarButtonCallback;
+export type ToggleNavbarButtonOptions = import("./vcsCallback.js").VcsCallbackOptions & {
+    buttonId: string;
+    activeState?: boolean;
+};
+/**
+ * @typedef {import("./vcsCallback.js").VcsCallbackOptions & { buttonId: string, activeState?:boolean }} ToggleNavbarButtonOptions
+ * @property {string} buttonId - id of the Navbar button
+ * @property {boolean} [activeState] - state to be applied to the button
+ */
+/**
+ * @class
+ * @extends {VcsCallback}
+ */
+declare class ToggleNavbarButtonCallback extends VcsCallback {
+    /**
+     * @param {ToggleNavbarButtonOptions} options
+     * @param {import("@src/vcsUiApp.js").default} app
+     */
+    constructor(options: ToggleNavbarButtonOptions, app: import("@src/vcsUiApp.js").default);
+    /**
+     * @type {string}
+     * @private
+     */
+    private _buttonId;
+    /**
+     * @type {boolean|undefined}
+     * @private
+     */
+    private _activeState;
+    /**
+     * @returns {ToggleNavbarButtonOptions}
+     */
+    toJSON(): ToggleNavbarButtonOptions;
+}
+import VcsCallback from './vcsCallback.js';

package/src/callback/toggleNavbarButtonCallback.js

@@ -0,0 +1,62 @@
+import VcsCallback, { callbackClassRegistry } from './vcsCallback.js';
+
+/**
+ * @typedef {import("./vcsCallback.js").VcsCallbackOptions & { buttonId: string, activeState?:boolean }} ToggleNavbarButtonOptions
+ * @property {string} buttonId - id of the Navbar button
+ * @property {boolean} [activeState] - state to be applied to the button
+ */
+
+/**
+ * @class
+ * @extends {VcsCallback}
+ */
+class ToggleNavbarButtonCallback extends VcsCallback {
+  /**
+   * @type {string}
+   */
+  static get className() {
+    return 'ToggleNavbarButtonCallback';
+  }
+
+  /**
+   * @param {ToggleNavbarButtonOptions} options
+   * @param {import("@src/vcsUiApp.js").default} app
+   */
+  constructor(options, app) {
+    super(options, app);
+    /**
+     * @type {string}
+     * @private
+     */
+    this._buttonId = options.buttonId;
+    /**
+     * @type {boolean|undefined}
+     * @private
+     */
+    this._activeState = options.activeState;
+  }
+
+  callback() {
+    this._app.navbarManager.toggle(this._buttonId, this._activeState);
+  }
+
+  /**
+   * @returns {ToggleNavbarButtonOptions}
+   */
+  toJSON() {
+    const config = super.toJSON();
+    config.buttonId = this._buttonId;
+    if (this._activeState) {
+      config.activeState = this._activeState;
+    }
+    return config;
+  }
+}
+
+export default ToggleNavbarButtonCallback;
+
+// Register the class
+callbackClassRegistry.registerClass(
+  ToggleNavbarButtonCallback.className,
+  ToggleNavbarButtonCallback,
+);

package/src/components/form-inputs-controls/VcsSelect.vue

@@ -52,7 +52,7 @@
           <template #prepend="prependScope" v-if="multiple">
             <VcsCheckbox
               v-model="prependScope.isSelected"
-              class="py-0"
+              class="py-0 pr-1"
             ></VcsCheckbox>
           </template>
         </v-list-item>

package/src/components/form-inputs-controls/VcsTextArea.vue

@@ -72,24 +72,27 @@
     border-color: rgb(var(--v-theme-primary));
   }
 
-  :deep(.v-field--focused .v-field__outline__end) {
-    border-width: 1px 1px 1px 0 !important;
-  }
   :deep(.v-field--focused .v-field__outline__start) {
     border-width: 1px 0 1px 1px !important;
   }
+  :deep(.v-field--focused .v-field__outline__notch)::after {
+    border-width: 0 0 1px 0 !important;
+  }
+  :deep(.v-field--focused .v-field__outline__end) {
+    border-width: 1px 1px 1px 0 !important;
+  }
 
   // remove outline, if not focused, hovered or an error
   :deep(.v-field:not(.v-field--focused):not(.v-field--error):not(:hover)) {
     .v-field__outline * {
-      border-width: 0 0 0 0;
+      border-width: 0 0 1px 0 !important;
       border-radius: 0;
     }
+    .v-field__outline__start {
+      margin-left: 4px;
+    }
     .v-field__outline__end {
-      border-width: 0 0 1px 0 !important;
-      border-radius: 0;
       margin-right: 4px;
-      margin-left: -8px;
     }
     .v-field__loader {
       padding-left: 3px;
@@ -102,6 +105,8 @@
     .v-field__outline * label {
       color: rgb(var(--v-theme-primary));
       margin-left: -4px;
+      border-width: 0 0 0 0;
+      border-radius: 0;
     }
   }
   :deep(.v-field .v-field--focused .v-field--error):hover {

package/src/components/form-output/markdownHelper.d.ts

@@ -1,30 +1,5 @@
-/**
- * @typedef {Object} Block
- * @property {RegExpExecArray} opening
- * @property {RegExpExecArray} closing
- */
-/**
- * @typedef {Block} ConditionalBlock
- * @property {RegExpExecArray|undefined} elseStatement
- * @property {RegExpExecArray[]} elseIfs
- */
 /**
  * @param {string} content
  * @returns {string}
  */
 export function parseAndSanitizeMarkdown(content: string): string;
-/**
- * Renders a template in these steps
- * 1. expand conditional blocks. this will remove any blocks that do not match their expressions and choose from if / elseif / else block which of them to render
- * 2. expand iterations. this will create new templates for each iteration and re-run the rendering for those blocks
- * 3. render attributes. this will add the attributes to all the blocks not within each blocks
- * @param {string|string[]} template
- * @param {Record<string, unknown>} data
- * @returns {string}
- */
-export function renderTemplate(template: string | string[], data: Record<string, unknown>): string;
-export type Block = {
-    opening: RegExpExecArray;
-    closing: RegExpExecArray;
-};
-export type ConditionalBlock = Block;