@limetech/lime-crm-building-blocks 1.105.1 → 1.105.3

package/dist/collection/components/info-tile/info-tile.js

@@ -9,7 +9,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { h } from "@stencil/core";
-import { AggregateOperator, PlatformServiceName, SelectFilters, SelectConfig, } from "@limetech/lime-web-components";
+import { AggregateOperator, PlatformServiceName, SelectFilters, SelectConfig, Operator, SelectLimeTypes, } from "@limetech/lime-web-components";
 import { isEmpty } from "lodash-es";
 import { InfoTileLoader } from "./loader";
 import { InfoTileFormatterFactory } from "./format/factory";
@@ -92,7 +92,7 @@ export class InfoTile {
         const errorProps = Object.assign(Object.assign({}, baseProps), { icon: 'error', prefix: 'ERROR', loading: true, label: this.getLabel(filter) });
         const normalProps = Object.assign(Object.assign({}, baseProps), { label: this.getLabel(filter), link: this.getLink(filter), loading: this.loading, value: value === null || value === void 0 ? void 0 : value.value.trim() });
         const props = !filter || this.error ? errorProps : normalProps;
-        return (h("limel-info-tile", Object.assign({ key: 'bb8b9eede8bdd3fdd17934753e463d134c46f7df', class: { error: !filter || this.error } }, props)));
+        return (h("limel-info-tile", Object.assign({ key: '2f234d921ab8b45f9ce00f1830fb782bd9d9aa72', class: { error: !filter || this.error } }, props)));
     }
     getFormattedValue() {
         if (!this.value && this.value !== 0) {
@@ -137,8 +137,32 @@ export class InfoTile {
         if (!filter) {
             return { href: '#' };
         }
+        const baseHref = ['explorer', filter.limetype, filter.id].join('/');
+        const relationPropertyName = this.getRelationPropertyName(this.limetypes[filter.limetype]);
+        const contextAwareFilter = this.buildContextAwareFilter(filter.filter, relationPropertyName);
+        if (!contextAwareFilter) {
+            return { href: baseHref };
+        }
+        const filterQuery = encodeURIComponent(JSON.stringify(contextAwareFilter));
+        return { href: `${baseHref}?filter=${filterQuery}` };
+    }
+    buildContextAwareFilter(filter, relationPropertyName) {
+        if (!relationPropertyName) {
+            return filter;
+        }
+        const relationFilter = {
+            key: relationPropertyName,
+            op: Operator.EQUALS,
+            exp: this.context.id,
+        };
+        if (!filter) {
+            return {
+                relationFilter,
+            };
+        }
         return {
-            href: ['explorer', filter.limetype, filter.id].join('/'),
+            op: Operator.AND,
+            exp: [relationFilter, filter],
         };
     }
     getFilter() {
@@ -148,6 +172,23 @@ export class InfoTile {
     getFormatter(value) {
         return new InfoTileFormatterFactory(this.language).createFormatter(this.format, value);
     }
+    getRelationPropertyName(limetype) {
+        var _a, _b, _c;
+        if (!limetype || !this.context.limetype || !this.context.id) {
+            return;
+        }
+        if (this.propertyName) {
+            const currentLimeType = this.limetypes[this.context.limetype];
+            const backReference = (_b = (_a = currentLimeType === null || currentLimeType === void 0 ? void 0 : currentLimeType.getProperty(this.propertyName)) === null || _a === void 0 ? void 0 : _a.relation) === null || _b === void 0 ? void 0 : _b.getBackreference();
+            if (backReference) {
+                return backReference.name;
+            }
+        }
+        return (_c = Object.values(limetype.properties).find((property) => {
+            var _a;
+            return (((_a = property.relation) === null || _a === void 0 ? void 0 : _a.getLimetype().name) === this.context.limetype);
+        })) === null || _c === void 0 ? void 0 : _c.name;
+    }
     get translator() {
         return this.platform.get(PlatformServiceName.Translate);
     }
@@ -422,7 +463,8 @@ export class InfoTile {
             "filters": {},
             "value": {},
             "loading": {},
-            "error": {}
+            "error": {},
+            "limetypes": {}
         };
     }
     static get watchers() {
@@ -444,3 +486,6 @@ __decorate([
 __decorate([
     SelectFilters()
 ], InfoTile.prototype, "filters", void 0);
+__decorate([
+    SelectLimeTypes()
+], InfoTile.prototype, "limetypes", void 0);

package/dist/collection/components/kanban/kanban-group/kanban-group.css

@@ -67,6 +67,9 @@
 * of some components, to demonstrate how the component
 * behaves in a resizable container.
 */
+/**
+ * Drag to reorder mixins
+ */
 /**
  * The breakpoints below are used to create responsive designs
  * in Lime's products. Therefore, they are here to get distributed

package/dist/collection/components/kanban/kanban-item/kanban-item.css

@@ -67,6 +67,9 @@
 * of some components, to demonstrate how the component
 * behaves in a resizable container.
 */
+/**
+ * Drag to reorder mixins
+ */
 /**
  * The breakpoints below are used to create responsive designs
  * in Lime's products. Therefore, they are here to get distributed

package/dist/collection/components/lime-query-builder/expressions/lime-query-filter-expression.css

@@ -67,6 +67,9 @@
 * of some components, to demonstrate how the component
 * behaves in a resizable container.
 */
+/**
+ * Drag to reorder mixins
+ */
 /**
  * The breakpoints below are used to create responsive designs
  * in Lime's products. Therefore, they are here to get distributed

package/dist/collection/components/lime-query-builder/expressions/lime-query-filter-group.css

@@ -67,6 +67,9 @@
 * of some components, to demonstrate how the component
 * behaves in a resizable container.
 */
+/**
+ * Drag to reorder mixins
+ */
 /**
  * The breakpoints below are used to create responsive designs
  * in Lime's products. Therefore, they are here to get distributed

package/dist/collection/components/lime-query-builder/expressions/lime-query-filter-not.css

@@ -67,6 +67,9 @@
 * of some components, to demonstrate how the component
 * behaves in a resizable container.
 */
+/**
+ * Drag to reorder mixins
+ */
 /**
  * The breakpoints below are used to create responsive designs
  * in Lime's products. Therefore, they are here to get distributed

package/dist/collection/components/lime-query-builder/lime-query-validation.js

@@ -1,6 +1,5 @@
 import { Operator } from "@limetech/lime-web-components";
-import { getNormalizedProperties } from "./property-resolution";
-import { getPropertyFromPath } from "./property-resolution";
+import { getNormalizedProperties, getPropertyFromPath, validatePropertyPath, } from "./property-resolution";
 /**
  * Dynamic filter values and placeholders that are valid in Lime Query
  */
@@ -85,6 +84,46 @@ export function validatePlaceholder(value, activeLimetype, limetypes) {
         };
     }
 }
+/**
+ * Validates a filter expression key (property path).
+ * Supports both regular property paths and placeholders.
+ *
+ * @param key - Property path to validate (e.g., "name", "company.name", "%activeObject%.name")
+ * @param limetypes - All limetype definitions
+ * @param limetype - The limetype being filtered
+ * @param activeLimetype - Active limetype for placeholder resolution
+ * @returns Validation result with error message if invalid
+ */
+export function validateFilterKey(key, limetypes, limetype, activeLimetype) {
+    // 1. Handle empty/missing keys
+    if (!key) {
+        return { valid: false, error: 'Filter key cannot be empty' };
+    }
+    // 2. Check if key is a placeholder
+    if (key.startsWith('%activeObject%')) {
+        const placeholderResult = validatePlaceholder(key, activeLimetype, limetypes);
+        if (!placeholderResult.valid) {
+            return placeholderResult;
+        }
+        // Extract property path after the placeholder and validate for hasMany/hasAndBelongsToMany
+        const propertyPath = key.replace(/^%activeObject%\.?/, '');
+        if (propertyPath && activeLimetype) {
+            const { error } = validatePropertyPath(limetypes, activeLimetype, propertyPath);
+            if (error) {
+                return { valid: false, error };
+            }
+        }
+        return placeholderResult;
+    }
+    // 3. Validate regular property path (including intermediate properties)
+    const { error } = validatePropertyPath(limetypes, limetype, key);
+    if (error) {
+        return { valid: false, error };
+    }
+    // validatePropertyPath always returns an error if property is undefined,
+    // so if we reach here, the property exists and is valid
+    return { valid: true };
+}
 /**
  * Validate a response format against limetype schemas
  * Throws errors for invalid property references
@@ -253,13 +292,19 @@ export function validatePropertySelection(selection, limetypes, limetype, visual
  * @param filter
  * @param activeLimetype
  * @param limetypes
+ * @param limetype
  */
-function validateComparisonExpression(filter, activeLimetype, limetypes) {
+function validateComparisonExpression(filter, activeLimetype, limetypes, limetype) {
     // Validate operator
     const allValidOperators = Object.values(Operator);
     if (!allValidOperators.includes(filter.op)) {
         throw new Error(`Unsupported filter operator: ${filter.op}`);
     }
+    // Validate filter key
+    const keyResult = validateFilterKey(filter.key, limetypes, limetype, activeLimetype);
+    if (!keyResult.valid) {
+        throw new Error(`Invalid filter key '${filter.key}': ${keyResult.error}`);
+    }
     // Validate placeholder
     const result = validatePlaceholder(filter.exp, activeLimetype, limetypes);
     if (!result.valid) {
@@ -271,9 +316,10 @@ function validateComparisonExpression(filter, activeLimetype, limetypes) {
  * @param filter
  * @param activeLimetype
  * @param limetypes
+ * @param limetype
  * @param visualModeEnabled
  */
-function validateGroupExpression(filter, activeLimetype, limetypes, visualModeEnabled) {
+function validateGroupExpression(filter, activeLimetype, limetypes, limetype, visualModeEnabled) {
     // Validate operator
     if (filter.op !== Operator.AND &&
         filter.op !== Operator.OR &&
@@ -282,12 +328,12 @@ function validateGroupExpression(filter, activeLimetype, limetypes, visualModeEn
     }
     // Recursively validate children
     if (filter.op === Operator.NOT) {
-        validateFilterPlaceholders(filter.exp, activeLimetype, limetypes, visualModeEnabled);
+        validateFilterPlaceholders(filter.exp, activeLimetype, limetypes, limetype, visualModeEnabled);
     }
     else if (filter.op === Operator.AND || filter.op === Operator.OR) {
         const expressions = filter.exp;
         for (const expr of expressions) {
-            validateFilterPlaceholders(expr, activeLimetype, limetypes, visualModeEnabled);
+            validateFilterPlaceholders(expr, activeLimetype, limetypes, limetype, visualModeEnabled);
         }
     }
 }
@@ -296,37 +342,51 @@ function validateGroupExpression(filter, activeLimetype, limetypes, visualModeEn
  * @param filter Filter expression to validate
  * @param activeLimetype The limetype of the active object
  * @param limetypes Record of all available limetypes
+ * @param limetype The limetype being filtered
  * @param visualModeEnabled Whether visual mode is enabled (affects validation)
  */
-function validateFilterPlaceholders(filter, activeLimetype, limetypes, visualModeEnabled = true) {
+function validateFilterPlaceholders(filter, activeLimetype, limetypes, limetype, visualModeEnabled = true) {
     if (!filter) {
         return;
     }
     if ('key' in filter) {
-        validateComparisonExpression(filter, activeLimetype, limetypes);
+        validateComparisonExpression(filter, activeLimetype, limetypes, limetype);
         return;
     }
     if ('exp' in filter) {
-        validateGroupExpression(filter, activeLimetype, limetypes, visualModeEnabled);
+        validateGroupExpression(filter, activeLimetype, limetypes, limetype, visualModeEnabled);
     }
 }
 /**
- * Validate Lime Query filter and collect errors
+ * Validate Lime Query filter and collect errors and visual mode limitations
  * @param filter The filter expression or group to validate
  * @param activeLimetype Optional active object limetype for placeholder validation
  * @param limetypes Record of all available limetypes
+ * @param limetype The limetype being filtered
  * @param visualModeEnabled Whether visual mode is enabled
- * @returns Array of validation error messages
+ * @returns Object with validation errors and visual mode limitations
  */
-function validateLimeQueryFilterInternal(filter, activeLimetype, limetypes, visualModeEnabled) {
+function validateLimeQueryFilterInternal(filter, activeLimetype, limetypes, limetype, visualModeEnabled) {
     const errors = [];
+    const limitations = [];
     try {
-        validateFilterPlaceholders(filter, activeLimetype, limetypes, visualModeEnabled);
+        validateFilterPlaceholders(filter, activeLimetype, limetypes, limetype, visualModeEnabled);
     }
     catch (error) {
-        errors.push(`Invalid filter: ${error.message}`);
+        const errorMessage = error.message;
+        // Invalid keys are BOTH spec violations AND rendering limitations:
+        // - Backend will reject them (validation error)
+        // - Visual mode can't show them in property selector (visual limitation)
+        if (errorMessage.includes('Invalid filter key') ||
+            errorMessage.includes('Cannot filter on many-relation')) {
+            errors.push(`Invalid filter: ${errorMessage}`);
+            limitations.push(errorMessage);
+        }
+        else {
+            errors.push(`Invalid filter: ${errorMessage}`);
+        }
     }
-    return errors;
+    return { errors, limitations };
 }
 /**
  * Validate orderBy specification
@@ -495,8 +555,9 @@ export function isLimeQuerySupported(limeQuery, limetypes, activeLimetype, visua
     }
     // Validate filter
     if (limeQuery.filter) {
-        const filterErrors = validateLimeQueryFilterInternal(limeQuery.filter, activeLimetype, limetypes, visualModeEnabled);
-        validationErrors.push(...filterErrors);
+        const { errors, limitations } = validateLimeQueryFilterInternal(limeQuery.filter, activeLimetype, limetypes, limeQuery.limetype, visualModeEnabled);
+        validationErrors.push(...errors);
+        visualModeLimitations.push(...limitations);
     }
     // Validate responseFormat
     if (limeQuery.responseFormat) {

package/dist/collection/components/lime-query-builder/property-resolution.js

@@ -59,3 +59,49 @@ export function getPropertyFromPath(limetypes, limetype, path) {
     }
     return property;
 }
+/**
+ * Validates a property path to ensure no intermediate properties are hasMany or hasAndBelongsToMany relations.
+ * These relation types cannot be traversed in filter expressions.
+ * @param limetypes All limetype definitions
+ * @param limetype The starting limetype
+ * @param path The property path to validate (e.g., "company.name")
+ * @returns The property at the end of the path if valid, or undefined with error if invalid
+ */
+export function validatePropertyPath(limetypes, limetype, path) {
+    if (!path || !limetype || !limetypes) {
+        return { property: undefined };
+    }
+    const parts = path.split('.');
+    let currentType = limetypes[limetype];
+    let property;
+    for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        if (!currentType) {
+            return { property: undefined };
+        }
+        const normalizedProperties = getNormalizedProperties(currentType);
+        property = normalizedProperties[part];
+        if (!property) {
+            return {
+                property: undefined,
+                error: `Property '${part}' does not exist on limetype '${currentType.name}'`,
+            };
+        }
+        // Check if this property is a hasMany/hasAndBelongsToMany relation
+        // These cannot be traversed in filter expressions
+        if (property.type === 'hasmany' ||
+            property.type === 'hasandbelongstomany') {
+            // Build the path up to this point for the error message
+            const invalidPath = parts.slice(0, i + 1).join('.');
+            return {
+                property: undefined,
+                error: `Cannot filter on many-relation '${invalidPath}'. Use a related limetype's filter instead.`,
+            };
+        }
+        // If this is a relation, get the related limetype for next iteration
+        if (property.relation) {
+            currentType = property.relation.getLimetype();
+        }
+    }
+    return { property };
+}

package/dist/collection/components/lime-query-builder/response-format/response-format-item.css

@@ -67,6 +67,9 @@
 * of some components, to demonstrate how the component
 * behaves in a resizable container.
 */
+/**
+ * Drag to reorder mixins
+ */
 /**
  * The breakpoints below are used to create responsive designs
  * in Lime's products. Therefore, they are here to get distributed

package/dist/collection/components/navigation-button/navigation-button.css

@@ -67,6 +67,9 @@
 * of some components, to demonstrate how the component
 * behaves in a resizable container.
 */
+/**
+ * Drag to reorder mixins
+ */
 /**
  * The breakpoints below are used to create responsive designs
  * in Lime's products. Therefore, they are here to get distributed

package/dist/collection/components/notification-list/notification-item/notification-item.css

@@ -67,6 +67,9 @@
 * of some components, to demonstrate how the component
 * behaves in a resizable container.
 */
+/**
+ * Drag to reorder mixins
+ */
 /**
  * The breakpoints below are used to create responsive designs
  * in Lime's products. Therefore, they are here to get distributed

package/dist/collection/components/notification-list/notification-list.css

@@ -67,6 +67,9 @@
 * of some components, to demonstrate how the component
 * behaves in a resizable container.
 */
+/**
+ * Drag to reorder mixins
+ */
 /**
  * The breakpoints below are used to create responsive designs
  * in Lime's products. Therefore, they are here to get distributed

package/dist/collection/components/percentage-visualizer/percentage-visualizer.css

@@ -70,6 +70,9 @@
 * of some components, to demonstrate how the component
 * behaves in a resizable container.
 */
+/**
+ * Drag to reorder mixins
+ */
 /**
  * The breakpoints below are used to create responsive designs
  * in Lime's products. Therefore, they are here to get distributed

package/dist/collection/components/trend-indicator/trend-indicator.css

@@ -67,6 +67,9 @@
 * of some components, to demonstrate how the component
 * behaves in a resizable container.
 */
+/**
+ * Drag to reorder mixins
+ */
 /**
  * The breakpoints below are used to create responsive designs
  * in Lime's products. Therefore, they are here to get distributed

package/dist/components/lime-query-validation.js

@@ -1,5 +1,5 @@
 import { Z as Zt } from './index.esm.js';
-import { g as getPropertyFromPath, a as getNormalizedProperties } from './property-selector.js';
+import { g as getPropertyFromPath, a as getNormalizedProperties, v as validatePropertyPath } from './property-selector.js';
 
 /**
  * Dynamic filter values and placeholders that are valid in Lime Query
@@ -85,6 +85,46 @@ function validatePlaceholder(value, activeLimetype, limetypes) {
         };
     }
 }
+/**
+ * Validates a filter expression key (property path).
+ * Supports both regular property paths and placeholders.
+ *
+ * @param key - Property path to validate (e.g., "name", "company.name", "%activeObject%.name")
+ * @param limetypes - All limetype definitions
+ * @param limetype - The limetype being filtered
+ * @param activeLimetype - Active limetype for placeholder resolution
+ * @returns Validation result with error message if invalid
+ */
+function validateFilterKey(key, limetypes, limetype, activeLimetype) {
+    // 1. Handle empty/missing keys
+    if (!key) {
+        return { valid: false, error: 'Filter key cannot be empty' };
+    }
+    // 2. Check if key is a placeholder
+    if (key.startsWith('%activeObject%')) {
+        const placeholderResult = validatePlaceholder(key, activeLimetype, limetypes);
+        if (!placeholderResult.valid) {
+            return placeholderResult;
+        }
+        // Extract property path after the placeholder and validate for hasMany/hasAndBelongsToMany
+        const propertyPath = key.replace(/^%activeObject%\.?/, '');
+        if (propertyPath && activeLimetype) {
+            const { error } = validatePropertyPath(limetypes, activeLimetype, propertyPath);
+            if (error) {
+                return { valid: false, error };
+            }
+        }
+        return placeholderResult;
+    }
+    // 3. Validate regular property path (including intermediate properties)
+    const { error } = validatePropertyPath(limetypes, limetype, key);
+    if (error) {
+        return { valid: false, error };
+    }
+    // validatePropertyPath always returns an error if property is undefined,
+    // so if we reach here, the property exists and is valid
+    return { valid: true };
+}
 /**
  * Validate a response format against limetype schemas
  * Throws errors for invalid property references
@@ -253,13 +293,19 @@ function validatePropertySelection(selection, limetypes, limetype, visualModeEna
  * @param filter
  * @param activeLimetype
  * @param limetypes
+ * @param limetype
  */
-function validateComparisonExpression(filter, activeLimetype, limetypes) {
+function validateComparisonExpression(filter, activeLimetype, limetypes, limetype) {
     // Validate operator
     const allValidOperators = Object.values(Zt);
     if (!allValidOperators.includes(filter.op)) {
         throw new Error(`Unsupported filter operator: ${filter.op}`);
     }
+    // Validate filter key
+    const keyResult = validateFilterKey(filter.key, limetypes, limetype, activeLimetype);
+    if (!keyResult.valid) {
+        throw new Error(`Invalid filter key '${filter.key}': ${keyResult.error}`);
+    }
     // Validate placeholder
     const result = validatePlaceholder(filter.exp, activeLimetype, limetypes);
     if (!result.valid) {
@@ -271,9 +317,10 @@ function validateComparisonExpression(filter, activeLimetype, limetypes) {
  * @param filter
  * @param activeLimetype
  * @param limetypes
+ * @param limetype
  * @param visualModeEnabled
  */
-function validateGroupExpression(filter, activeLimetype, limetypes, visualModeEnabled) {
+function validateGroupExpression(filter, activeLimetype, limetypes, limetype, visualModeEnabled) {
     // Validate operator
     if (filter.op !== Zt.AND &&
         filter.op !== Zt.OR &&
@@ -282,12 +329,12 @@ function validateGroupExpression(filter, activeLimetype, limetypes, visualModeEn
     }
     // Recursively validate children
     if (filter.op === Zt.NOT) {
-        validateFilterPlaceholders(filter.exp, activeLimetype, limetypes, visualModeEnabled);
+        validateFilterPlaceholders(filter.exp, activeLimetype, limetypes, limetype, visualModeEnabled);
     }
     else if (filter.op === Zt.AND || filter.op === Zt.OR) {
         const expressions = filter.exp;
         for (const expr of expressions) {
-            validateFilterPlaceholders(expr, activeLimetype, limetypes, visualModeEnabled);
+            validateFilterPlaceholders(expr, activeLimetype, limetypes, limetype, visualModeEnabled);
         }
     }
 }
@@ -296,37 +343,51 @@ function validateGroupExpression(filter, activeLimetype, limetypes, visualModeEn
  * @param filter Filter expression to validate
  * @param activeLimetype The limetype of the active object
  * @param limetypes Record of all available limetypes
+ * @param limetype The limetype being filtered
  * @param visualModeEnabled Whether visual mode is enabled (affects validation)
  */
-function validateFilterPlaceholders(filter, activeLimetype, limetypes, visualModeEnabled = true) {
+function validateFilterPlaceholders(filter, activeLimetype, limetypes, limetype, visualModeEnabled = true) {
     if (!filter) {
         return;
     }
     if ('key' in filter) {
-        validateComparisonExpression(filter, activeLimetype, limetypes);
+        validateComparisonExpression(filter, activeLimetype, limetypes, limetype);
         return;
     }
     if ('exp' in filter) {
-        validateGroupExpression(filter, activeLimetype, limetypes, visualModeEnabled);
+        validateGroupExpression(filter, activeLimetype, limetypes, limetype, visualModeEnabled);
     }
 }
 /**
- * Validate Lime Query filter and collect errors
+ * Validate Lime Query filter and collect errors and visual mode limitations
  * @param filter The filter expression or group to validate
  * @param activeLimetype Optional active object limetype for placeholder validation
  * @param limetypes Record of all available limetypes
+ * @param limetype The limetype being filtered
  * @param visualModeEnabled Whether visual mode is enabled
- * @returns Array of validation error messages
+ * @returns Object with validation errors and visual mode limitations
  */
-function validateLimeQueryFilterInternal(filter, activeLimetype, limetypes, visualModeEnabled) {
+function validateLimeQueryFilterInternal(filter, activeLimetype, limetypes, limetype, visualModeEnabled) {
     const errors = [];
+    const limitations = [];
     try {
-        validateFilterPlaceholders(filter, activeLimetype, limetypes, visualModeEnabled);
+        validateFilterPlaceholders(filter, activeLimetype, limetypes, limetype, visualModeEnabled);
     }
     catch (error) {
-        errors.push(`Invalid filter: ${error.message}`);
+        const errorMessage = error.message;
+        // Invalid keys are BOTH spec violations AND rendering limitations:
+        // - Backend will reject them (validation error)
+        // - Visual mode can't show them in property selector (visual limitation)
+        if (errorMessage.includes('Invalid filter key') ||
+            errorMessage.includes('Cannot filter on many-relation')) {
+            errors.push(`Invalid filter: ${errorMessage}`);
+            limitations.push(errorMessage);
+        }
+        else {
+            errors.push(`Invalid filter: ${errorMessage}`);
+        }
     }
-    return errors;
+    return { errors, limitations };
 }
 /**
  * Validate orderBy specification
@@ -495,8 +556,9 @@ function isLimeQuerySupported(limeQuery, limetypes, activeLimetype, visualModeEn
     }
     // Validate filter
     if (limeQuery.filter) {
-        const filterErrors = validateLimeQueryFilterInternal(limeQuery.filter, activeLimetype, limetypes, visualModeEnabled);
-        validationErrors.push(...filterErrors);
+        const { errors, limitations } = validateLimeQueryFilterInternal(limeQuery.filter, activeLimetype, limetypes, limeQuery.limetype, visualModeEnabled);
+        validationErrors.push(...errors);
+        visualModeLimitations.push(...limitations);
     }
     // Validate responseFormat
     if (limeQuery.responseFormat) {