@umbraco-cms/backoffice 14.2.0 → 14.3.0

package/dist-cms/packages/core/validation/mixins/form-control.mixin.js

@@ -7,11 +7,24 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { UmbValidationInvalidEvent } from '../events/validation-invalid.event.js';
 import { UmbValidationValidEvent } from '../events/validation-valid.event.js';
 import { property } from '../../../../external/lit/index.js';
+const WeightedErrorFlagTypes = [
+    'customError',
+    'valueMissing',
+    'badInput',
+    'typeMismatch',
+    'patternMismatch',
+    'rangeOverflow',
+    'rangeUnderflow',
+    'stepMismatch',
+    'tooLong',
+    'tooShort',
+];
 /**
+ * @mixin
  * The mixin allows a custom element to participate in HTML forms.
  * @param {object} superClass - superclass to be extended.
- * @param defaultValue
- * @mixin
+ * @param {object} defaultValue - Default value for the form control.
+ * @returns {Function} - The mixin class.
  */
 export function UmbFormControlMixin(superClass, defaultValue) {
     class UmbFormControlMixinClass extends superClass {
@@ -67,11 +80,15 @@ export function UmbFormControlMixin(superClass, defaultValue) {
             this.#form = null;
             this.#validators = [];
             this.#formCtrlElements = [];
+            this.#runValidatorsCallback = () => this._runValidators;
             this.#onFormSubmit = () => {
                 this.pristine = false;
             };
             this._internals = this.attachInternals();
             this.addEventListener('blur', () => {
+                /*if (e.composedPath().some((x) => x === this)) {
+                    return;
+                }*/
                 this.pristine = false;
                 this.checkValidity();
             });
@@ -80,7 +97,7 @@ export function UmbFormControlMixin(superClass, defaultValue) {
          * Get internal form element.
          * This has to be implemented to provide a FormControl Element of choice for the given context. The element is used as anchor for validation-messages.
          * @function getFormElement
-         * @returns {HTMLElement | undefined | null}
+         * @returns {HTMLElement | undefined | null} - Returns the form element or undefined if not found.
          */
         getFormElement() {
             return this.#formCtrlElements.find((el) => el.validity.valid === false);
@@ -88,7 +105,7 @@ export function UmbFormControlMixin(superClass, defaultValue) {
         /**
          * Focus first element that is invalid.
          * @function focusFirstInvalidElement
-         * @returns {HTMLElement | undefined}
+         * @returns {HTMLElement | undefined} - Returns the first invalid element or undefined if no invalid elements are found.
          */
         focusFirstInvalidElement() {
             const firstInvalid = this.#formCtrlElements.find((el) => el.validity.valid === false);
@@ -126,14 +143,18 @@ export function UmbFormControlMixin(superClass, defaultValue) {
          * @param {FlagTypes} flagKey the type of validation.
          * @param {method} getMessageMethod method to retrieve relevant message. Is executed every time the validator is re-executed.
          * @param {method} checkMethod method to determine if this validator should invalidate this form control. Return true if this should prevent submission.
+         * @returns {UmbFormControlValidatorConfig} - The added validator configuration.
          */
         addValidator(flagKey, getMessageMethod, checkMethod) {
             const validator = {
                 flagKey: flagKey,
                 getMessageMethod: getMessageMethod,
                 checkMethod: checkMethod,
+                weight: WeightedErrorFlagTypes.indexOf(flagKey),
             };
             this.#validators.push(validator);
+            // Sort validators based on the WeightedErrorFlagTypes order. [NL]
+            this.#validators.sort((a, b) => (a.weight > b.weight ? 1 : b.weight > a.weight ? -1 : 0));
             return validator;
         }
         /**
@@ -147,19 +168,17 @@ export function UmbFormControlMixin(superClass, defaultValue) {
                 this.#validators.splice(index, 1);
             }
         }
+        #runValidatorsCallback;
         /**
          * @function addFormControlElement
          * @description Important notice if adding a native form control then ensure that its value and thereby validity is updated when value is changed from the outside.
-         * @param element {UmbNativeFormControlElement} - element to validate and include as part of this form association.
+         * @param {UmbNativeFormControlElement} element - element to validate and include as part of this form control association.
+         * @returns {void}
          */
         addFormControlElement(element) {
             this.#formCtrlElements.push(element);
-            element.addEventListener(UmbValidationInvalidEvent.TYPE, () => {
-                this._runValidators();
-            });
-            element.addEventListener(UmbValidationValidEvent.TYPE, () => {
-                this._runValidators();
-            });
+            element.addEventListener(UmbValidationInvalidEvent.TYPE, this.#runValidatorsCallback);
+            element.addEventListener(UmbValidationValidEvent.TYPE, this.#runValidatorsCallback);
             // If we are in validationMode/'touched'/not-pristine then we need to validate this newly added control. [NL]
             if (this._pristine === false) {
                 element.checkValidity();
@@ -167,10 +186,26 @@ export function UmbFormControlMixin(superClass, defaultValue) {
                 this._runValidators();
             }
         }
+        /**
+         * @function removeFormControlElement
+         * @param {UmbNativeFormControlElement} element - element to remove as part of this form controls associated controls.
+         * @returns {void}
+         */
+        removeFormControlElement(element) {
+            const index = this.#formCtrlElements.indexOf(element);
+            if (index !== -1) {
+                this.#formCtrlElements.splice(index, 1);
+                element.removeEventListener(UmbValidationInvalidEvent.TYPE, this.#runValidatorsCallback);
+                element.removeEventListener(UmbValidationValidEvent.TYPE, this.#runValidatorsCallback);
+                if (this._pristine === false) {
+                    this._runValidators();
+                }
+            }
+        }
         /**
          * @function setCustomValidity
          * @description Set custom validity state, set to empty string to remove the custom message.
-         * @param message {string} - The message to be shown
+         * @param {string} message - The message to be shown
          * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLObjectElement/setCustomValidity|HTMLObjectElement:setCustomValidity}
          */
         setCustomValidity(message) {
@@ -191,33 +226,43 @@ export function UmbFormControlMixin(superClass, defaultValue) {
          */
         _runValidators() {
             this.#validity = {};
-            const messages = new Set();
+            //const messages: Set<string> = new Set();
+            let message = undefined;
             let innerFormControlEl = undefined;
-            // Loop through inner native form controls to adapt their validityState. [NL]
-            this.#formCtrlElements.forEach((formCtrlEl) => {
-                let key;
-                for (key in formCtrlEl.validity) {
-                    if (key !== 'valid' && formCtrlEl.validity[key]) {
-                        this.#validity[key] = true;
-                        messages.add(formCtrlEl.validationMessage);
-                        innerFormControlEl ??= formCtrlEl;
-                    }
-                }
-            });
             // Loop through custom validators, currently its intentional to have them overwritten native validity. but might need to be reconsidered (This current way enables to overwrite with custom messages) [NL]
-            this.#validators.forEach((validator) => {
+            this.#validators.some((validator) => {
                 if (validator.checkMethod()) {
                     this.#validity[validator.flagKey] = true;
-                    messages.add(validator.getMessageMethod());
+                    //messages.add(validator.getMessageMethod());
+                    message = validator.getMessageMethod();
+                    return true;
                 }
+                return false;
             });
+            if (!message) {
+                // Loop through inner native form controls to adapt their validityState. [NL]
+                this.#formCtrlElements.some((formCtrlEl) => {
+                    let key;
+                    for (key in formCtrlEl.validity) {
+                        if (key !== 'valid' && formCtrlEl.validity[key]) {
+                            this.#validity[key] = true;
+                            //messages.add(formCtrlEl.validationMessage);
+                            message = formCtrlEl.validationMessage;
+                            innerFormControlEl ??= formCtrlEl;
+                            return true;
+                        }
+                    }
+                    return false;
+                });
+            }
             const hasError = Object.values(this.#validity).includes(true);
             // https://developer.mozilla.org/en-US/docs/Web/API/ValidityState#valid
             this.#validity.valid = !hasError;
             // Transfer the new validityState to the ElementInternals. [NL]
             this._internals.setValidity(this.#validity, 
             // Turn messages into an array and join them with a comma. [NL]:
-            [...messages].join(', '), innerFormControlEl ?? this.getFormElement() ?? undefined);
+            //[...messages].join(', '),
+            message, innerFormControlEl ?? this.getFormElement() ?? undefined);
             this.#dispatchValidationState();
         }
         #dispatchValidationState() {

package/dist-cms/packages/core/validation/translators/abstract-array-path-translator.controller.d.ts

@@ -0,0 +1,8 @@
+import { UmbValidationPathTranslatorBase } from './validation-path-translator-base.controller.js';
+import type { UmbControllerHost } from '../../../../libs/controller-api/index.js';
+export declare abstract class UmbAbstractArrayValidationPathTranslator extends UmbValidationPathTranslatorBase {
+    #private;
+    constructor(host: UmbControllerHost, initialPathToMatch: string, queryMethod: (data: any) => string);
+    translate(path: string): string | false | undefined;
+    abstract getDataFromIndex(index: number): unknown | undefined;
+}

package/dist-cms/packages/core/validation/translators/abstract-array-path-translator.controller.js

@@ -0,0 +1,35 @@
+import { UmbValidationPathTranslatorBase } from './validation-path-translator-base.controller.js';
+export class UmbAbstractArrayValidationPathTranslator extends UmbValidationPathTranslatorBase {
+    #initialPathToMatch;
+    #queryMethod;
+    constructor(host, initialPathToMatch, queryMethod) {
+        super(host);
+        this.#initialPathToMatch = initialPathToMatch;
+        this.#queryMethod = queryMethod;
+    }
+    translate(path) {
+        if (!this._context)
+            return;
+        if (path.indexOf(this.#initialPathToMatch) !== 0) {
+            // We do not handle this path.
+            return false;
+        }
+        const pathEnd = path.indexOf(']');
+        if (pathEnd === -1) {
+            // We do not handle this path.
+            return false;
+        }
+        // retrieve the number from the message values index: [NL]
+        const index = parseInt(path.substring(this.#initialPathToMatch.length, pathEnd));
+        if (isNaN(index)) {
+            // index is not a number, this means its not a path we want to translate. [NL]
+            return false;
+        }
+        // Get the data from the validation request, the context holds that for us: [NL]
+        const data = this.getDataFromIndex(index);
+        if (!data)
+            return false;
+        // replace the values[ number ] with JSON-Path filter values[@.(...)], continues by the rest of the path:
+        return this.#initialPathToMatch + this.#queryMethod(data) + path.substring(path.indexOf(']'));
+    }
+}

package/dist-cms/packages/core/validation/translators/index.d.ts

@@ -1,2 +1,5 @@
-export type * from './validation-message-translator.interface.js';
-export * from './variant-values-validation-message-translator.controller.js';
+export * from './validation-path-translator-base.controller.js';
+export * from './abstract-array-path-translator.controller.js';
+export * from './variant-values-validation-path-translator.controller.js';
+export * from './variants-validation-path-translator.controller.js';
+export type * from './validation-message-path-translator.interface.js';

package/dist-cms/packages/core/validation/translators/index.js

@@ -1 +1,4 @@
-export * from './variant-values-validation-message-translator.controller.js';
+export * from './validation-path-translator-base.controller.js';
+export * from './abstract-array-path-translator.controller.js';
+export * from './variant-values-validation-path-translator.controller.js';
+export * from './variants-validation-path-translator.controller.js';

package/dist-cms/packages/core/validation/translators/validation-message-path-translator.interface.d.ts

@@ -0,0 +1,8 @@
+export interface UmbValidationMessageTranslator {
+    /**
+     *
+     * @param path - The path to translate
+     * @returns {false | undefined | string} - Returns false if the path is not handled by this translator, undefined if the path is invalid, or the translated path as a string.
+     */
+    translate(path: string): false | undefined | string;
+}

package/dist-cms/packages/core/validation/translators/validation-message-path-translator.interface.js

@@ -0,0 +1 @@
+export {};

package/dist-cms/packages/core/validation/translators/validation-path-translator-base.controller.d.ts

@@ -0,0 +1,10 @@
+import { UMB_VALIDATION_CONTEXT } from '../index.js';
+import type { UmbValidationMessageTranslator } from './validation-message-path-translator.interface.js';
+import type { UmbControllerHost } from '../../../../libs/controller-api/index.js';
+import { UmbControllerBase } from '../../../../libs/class-api/index.js';
+export declare abstract class UmbValidationPathTranslatorBase extends UmbControllerBase implements UmbValidationMessageTranslator {
+    protected _context?: typeof UMB_VALIDATION_CONTEXT.TYPE;
+    constructor(host: UmbControllerHost);
+    hostDisconnected(): void;
+    abstract translate(path: string): ReturnType<UmbValidationMessageTranslator['translate']>;
+}

package/dist-cms/packages/core/validation/translators/validation-path-translator-base.controller.js

@@ -0,0 +1,17 @@
+import { UMB_VALIDATION_CONTEXT } from '../index.js';
+import { UmbControllerBase } from '../../../../libs/class-api/index.js';
+export class UmbValidationPathTranslatorBase extends UmbControllerBase {
+    constructor(host) {
+        super(host);
+        this.consumeContext(UMB_VALIDATION_CONTEXT, (context) => {
+            this._context?.removeTranslator(this);
+            this._context = context;
+            context.addTranslator(this);
+        });
+    }
+    hostDisconnected() {
+        this._context?.removeTranslator(this);
+        this._context = undefined;
+        super.hostDisconnected();
+    }
+}

package/dist-cms/packages/core/validation/translators/variant-values-validation-path-translator.controller.d.ts

@@ -0,0 +1,6 @@
+import { UmbAbstractArrayValidationPathTranslator } from './abstract-array-path-translator.controller.js';
+import type { UmbControllerHost } from '../../../../libs/controller-api/index.js';
+export declare class UmbVariantValuesValidationPathTranslator extends UmbAbstractArrayValidationPathTranslator {
+    constructor(host: UmbControllerHost);
+    getDataFromIndex(index: number): any;
+}

package/dist-cms/packages/core/validation/translators/variant-values-validation-path-translator.controller.js

@@ -0,0 +1,13 @@
+import { UmbDataPathPropertyValueQuery } from '../utils/data-path-property-value-query.function.js';
+import { UmbAbstractArrayValidationPathTranslator } from './abstract-array-path-translator.controller.js';
+export class UmbVariantValuesValidationPathTranslator extends UmbAbstractArrayValidationPathTranslator {
+    constructor(host) {
+        super(host, '$.values[', UmbDataPathPropertyValueQuery);
+    }
+    getDataFromIndex(index) {
+        if (!this._context)
+            return;
+        const data = this._context.getTranslationData();
+        return data.values[index];
+    }
+}

package/dist-cms/packages/core/validation/translators/variants-validation-path-translator.controller.d.ts

@@ -0,0 +1,6 @@
+import { UmbAbstractArrayValidationPathTranslator } from './abstract-array-path-translator.controller.js';
+import type { UmbControllerHost } from '../../../../libs/controller-api/index.js';
+export declare class UmbVariantsValidationPathTranslator extends UmbAbstractArrayValidationPathTranslator {
+    constructor(host: UmbControllerHost);
+    getDataFromIndex(index: number): any;
+}

package/dist-cms/packages/core/validation/translators/variants-validation-path-translator.controller.js

@@ -0,0 +1,13 @@
+import { UmbDataPathVariantQuery } from '../utils/data-path-variant-query.function.js';
+import { UmbAbstractArrayValidationPathTranslator } from './abstract-array-path-translator.controller.js';
+export class UmbVariantsValidationPathTranslator extends UmbAbstractArrayValidationPathTranslator {
+    constructor(host) {
+        super(host, '$.variants[', UmbDataPathVariantQuery);
+    }
+    getDataFromIndex(index) {
+        if (!this._context)
+            return;
+        const data = this._context.getTranslationData();
+        return data.variants[index];
+    }
+}

package/dist-cms/packages/core/validation/utils/{data-path-property-value-filter.function.d.ts → data-path-property-value-query.function.d.ts}

@@ -1,10 +1,10 @@
 import type { UmbPartialSome } from '../../utils/index.js';
 import type { UmbVariantPropertyValueModel } from '../../variant/index.js';
 /**
- * Validation Data Path filter for Property Value.
+ * Validation Data Path Query generator for Property Value.
  * write a JSON-Path filter similar to `?(@.alias = 'myAlias' && @.culture == 'en-us' && @.segment == 'mySegment')`
  * where culture and segment are optional
  * @param value
  * @returns
  */
-export declare function UmbDataPathPropertyValueFilter(value: UmbPartialSome<Omit<UmbVariantPropertyValueModel, 'value'>, 'culture' | 'segment'>): string;
+export declare function UmbDataPathPropertyValueQuery(value: UmbPartialSome<Omit<UmbVariantPropertyValueModel, 'value'>, 'culture' | 'segment'>): string;

package/dist-cms/packages/core/validation/utils/{data-path-property-value-filter.function.js → data-path-property-value-query.function.js}

@@ -1,18 +1,18 @@
 /**
- * Validation Data Path filter for Property Value.
+ * Validation Data Path Query generator for Property Value.
  * write a JSON-Path filter similar to `?(@.alias = 'myAlias' && @.culture == 'en-us' && @.segment == 'mySegment')`
  * where culture and segment are optional
  * @param value
  * @returns
  */
-export function UmbDataPathPropertyValueFilter(value) {
+export function UmbDataPathPropertyValueQuery(value) {
     // write a array of strings for each property, where alias must be present and culture and segment are optional
     const filters = [`@.alias = '${value.alias}'`];
-    if (value.culture) {
-        filters.push(`@.culture == '${value.culture}'`);
+    if (value.culture !== undefined) {
+        filters.push(`@.culture = ${value.culture ? `'${value.culture}'` : 'null'}`);
     }
-    if (value.segment) {
-        filters.push(`@.segment == '${value.segment}'`);
+    if (value.segment !== undefined) {
+        filters.push(`@.segment = ${value.segment ? `'${value.segment}'` : 'null'}`);
     }
     return `?(${filters.join(' && ')})`;
 }

package/dist-cms/packages/core/validation/utils/data-path-variant-query.function.d.ts

@@ -0,0 +1,10 @@
+import type { UmbPartialSome } from '../../utils/index.js';
+import type { UmbVariantPropertyValueModel } from '../../variant/index.js';
+/**
+ * Validation Data Path query generator for Variant.
+ * write a JSON-Path filter similar to `?(@.culture == 'en-us' && @.segment == 'mySegment')`
+ * where segment are optional.
+ * @param value
+ * @returns
+ */
+export declare function UmbDataPathVariantQuery(value: UmbPartialSome<Pick<UmbVariantPropertyValueModel, 'culture' | 'segment'>, 'segment'>): string;

package/dist-cms/packages/core/validation/utils/data-path-variant-query.function.js

@@ -0,0 +1,15 @@
+/**
+ * Validation Data Path query generator for Variant.
+ * write a JSON-Path filter similar to `?(@.culture == 'en-us' && @.segment == 'mySegment')`
+ * where segment are optional.
+ * @param value
+ * @returns
+ */
+export function UmbDataPathVariantQuery(value) {
+    // write a array of strings for each property, where culture must be present and segment is optional
+    const filters = [`@.culture = ${value.culture ? `'${value.culture}'` : 'null'}`];
+    if (value.segment !== undefined) {
+        filters.push(`@.segment = ${value.segment ? `'${value.segment}'` : 'null'}`);
+    }
+    return `?(${filters.join(' && ')})`;
+}

package/dist-cms/packages/core/validation/utils/index.d.ts

@@ -1 +1,3 @@
-export * from './data-path-property-value-filter.function.js';
+export * from './data-path-property-value-query.function.js';
+export * from './data-path-variant-query.function.js';
+export * from './json-path.function.js';

package/dist-cms/packages/core/validation/utils/index.js

@@ -1 +1,3 @@
-export * from './data-path-property-value-filter.function.js';
+export * from './data-path-property-value-query.function.js';
+export * from './data-path-variant-query.function.js';
+export * from './json-path.function.js';

package/dist-cms/packages/core/validation/utils/json-path.function.d.ts

@@ -0,0 +1,11 @@
+/**
+ *
+ * @param data
+ * @param path
+ */
+export declare function GetValueByJsonPath(data: any, path: string): any;
+/**
+ *
+ * @param path
+ */
+export declare function GetPropertyNameFromPath(path: string): string;

package/dist-cms/packages/core/validation/utils/json-path.function.js

@@ -0,0 +1,115 @@
+/**
+ *
+ * @param data
+ * @param path
+ */
+export function GetValueByJsonPath(data, path) {
+    // strip $ from the path:
+    const strippedPath = path.startsWith('$.') ? path.slice(2) : path;
+    // get value from the path:
+    return GetNextPropertyValueFromPath(data, strippedPath);
+}
+/**
+ *
+ * @param path
+ */
+export function GetPropertyNameFromPath(path) {
+    // find next '.' or '[' in the path, using regex:
+    const match = path.match(/\.|\[/);
+    // If no match is found, we assume its a single key so lets return the value of the key:
+    if (match === null || match.index === undefined)
+        return path;
+    // split the path at the first match:
+    return path.slice(0, match.index);
+}
+/**
+ *
+ * @param data
+ * @param path
+ * @returns {any}
+ */
+function GetNextPropertyValueFromPath(data, path) {
+    if (!data)
+        return undefined;
+    // find next '.' or '[' in the path, using regex:
+    const match = path.match(/\.|\[/);
+    // If no match is found, we assume its a single key so lets return the value of the key:
+    if (match === null || match.index === undefined)
+        return data[path];
+    // split the path at the first match:
+    const key = path.slice(0, match.index);
+    const rest = path.slice(match.index + 1);
+    if (!key)
+        return undefined;
+    // get the value of the key from the data:
+    const value = data[key];
+    // if there is no rest of the path, return the value:
+    if (rest === undefined)
+        return value;
+    // if the value is an array, get the value at the index:
+    if (Array.isArray(value)) {
+        // get the value until the next ']', the value can be anything in between the brackets:
+        const lookupEnd = rest.match(/\]/);
+        if (!lookupEnd)
+            return undefined;
+        // get everything before the match:
+        const entryPointer = rest.slice(0, lookupEnd.index);
+        // check if the entryPointer is a JSON Path Filter ( starting with ?( and ending with ) ):
+        if (entryPointer.startsWith('?(') && entryPointer.endsWith(')')) {
+            // get the filter from the entryPointer:
+            // get the filter as a function:
+            const jsFilter = JsFilterFromJsonPathFilter(entryPointer);
+            // find the index of the value that matches the filter:
+            const index = value.findIndex(jsFilter[0]);
+            // if the index is -1, return undefined:
+            if (index === -1)
+                return undefined;
+            // get the value at the index:
+            const data = value[index];
+            // Check for safety:
+            if (lookupEnd.index === undefined || lookupEnd.index + 1 >= rest.length) {
+                return data;
+            }
+            // continue with the rest of the path:
+            return GetNextPropertyValueFromPath(data, rest.slice(lookupEnd.index + 2)) ?? data;
+        }
+        else {
+            // get the value at the index:
+            const indexAsNumber = parseInt(entryPointer);
+            if (isNaN(indexAsNumber))
+                return undefined;
+            const data = value[indexAsNumber];
+            // Check for safety:
+            if (lookupEnd.index === undefined || lookupEnd.index + 1 >= rest.length) {
+                return data;
+            }
+            // continue with the rest of the path:
+            return GetNextPropertyValueFromPath(data, rest.slice(lookupEnd.index + 2)) ?? data;
+        }
+    }
+    else {
+        // continue with the rest of the path:
+        return GetNextPropertyValueFromPath(value, rest);
+    }
+}
+/**
+ * @param filter
+ * @returns {Array<(queryFilter: any) => boolean>} - array of methods that returns true if the given items property value matches the value of the query.
+ */
+function JsFilterFromJsonPathFilter(filter) {
+    // strip ?( and ) from the filter
+    const jsFilter = filter.slice(2, -1);
+    // split the filter into parts by splitting at ' && '
+    const parts = jsFilter.split(' && ');
+    // map each part to a function that returns true if the part is true
+    return parts.map((part) => {
+        // split the part into key and value
+        const [path, equal] = part.split(' = ');
+        // remove @.
+        const key = path.slice(2);
+        // remove quotes:
+        const value = equal.slice(1, -1);
+        // return a function that returns true if the key is equal to the value
+        return (item) => item[key] === value;
+    });
+}

package/dist-cms/packages/core/variant/variant-id.class.d.ts

@@ -28,5 +28,5 @@ export declare class UmbVariantId {
     isSegmentInvariant(): boolean;
     isInvariant(): boolean;
     toObject(): UmbObjectWithVariantProperties;
-    toDifferencesString(variantId: UmbVariantId): string;
+    toDifferencesString(variantId: UmbVariantId, invariantMessage?: string, unsegmentedMessage?: string): string;
 }

package/dist-cms/packages/core/variant/variant-id.class.js

@@ -60,13 +60,13 @@ export class UmbVariantId {
     }
     // TODO: needs localization option:
     // TODO: Consider if this should be handled else where, it does not seem like the responsibility of this class, since it contains wordings:
-    toDifferencesString(variantId) {
+    toDifferencesString(variantId, invariantMessage = 'Invariant', unsegmentedMessage = 'Unsegmented') {
         let r = '';
         if (variantId.culture !== this.culture) {
-            r = 'Invariant';
+            r = invariantMessage;
         }
         if (variantId.segment !== this.segment) {
-            r = (r !== '' ? ' ' : '') + 'Unsegmented';
+            r = (r !== '' ? ' ' : '') + unsegmentedMessage;
         }
         return r;
     }

package/dist-cms/packages/core/vite.config.js

@@ -31,7 +31,9 @@ export default defineConfig({
             'modal/index': './modal/index.ts',
             'models/index': './models/index.ts',
             'notification/index': './notification/index.ts',
+            'object-type/index': './object-type/index.ts',
             'picker-input/index': './picker-input/index.ts',
+            'picker/index': './picker/index.ts',
             'property-action/index': './property-action/index.ts',
             'property-editor/index': './property-editor/index.ts',
             'property-type/index': './property-type/index.ts',

package/dist-cms/packages/core/workspace/components/workspace-action/default/workspace-action.element.js

@@ -74,7 +74,7 @@ let UmbWorkspaceActionElement = class UmbWorkspaceActionElement extends UmbLitEl
             await this.#api.execute();
             this._buttonState = 'success';
         }
-        catch (error) {
+        catch {
             this._buttonState = 'failed';
         }
         this.dispatchEvent(new UmbActionExecutedEvent());
@@ -145,6 +145,7 @@ export default UmbWorkspaceActionElement;
 /**
  *
  * @param manifest
+ * @returns An array of arguments to pass to the extension API initializer.
  */
 function ExtensionApiArgsMethod(manifest) {
     return [{ meta: manifest.meta }];

package/dist-cms/packages/core/workspace/components/workspace-action/workspace-action-base.controller.d.ts

@@ -4,7 +4,6 @@ import { UmbBooleanState } from '../../../../../libs/observable-api/index.js';
 import { UmbActionBase } from '../../../action/index.js';
 /**
  * Base class for an workspace action.
- * @export
  * @abstract
  * @class UmbWorkspaceActionBase
  * @augments {UmbActionBase}

package/dist-cms/packages/core/workspace/components/workspace-action/workspace-action-base.controller.js

@@ -2,7 +2,6 @@ import { UmbBooleanState } from '../../../../../libs/observable-api/index.js';
 import { UmbActionBase } from '../../../action/index.js';
 /**
  * Base class for an workspace action.
- * @export
  * @abstract
  * @class UmbWorkspaceActionBase
  * @augments {UmbActionBase}

package/dist-cms/packages/core/workspace/components/workspace-action-menu/workspace-action-menu.element.js

@@ -68,8 +68,8 @@ let UmbWorkspaceActionMenuElement = class UmbWorkspaceActionMenuElement extends
 			}
 
 			#popover-trigger {
-				--uui-button-padding-top-factor: 0.5;
-				--uui-button-padding-bottom-factor: 0.1;
+				--uui-button-padding-top-factor: 0;
+				--uui-button-padding-bottom-factor: 0.125;
 			}
 		`,
     ]; }

package/dist-cms/packages/core/workspace/components/workspace-action-menu-item/workspace-action-menu-item-base.controller.d.ts

@@ -3,7 +3,6 @@ import type { UmbWorkspaceActionMenuItem } from './workspace-action-menu-item.in
 import { UmbActionBase } from '../../../action/index.js';
 /**
  * Base class for an workspace action.
- * @export
  * @abstract
  * @class UmbWorkspaceActionMenuItemBase
  * @augments {UmbActionBase}