@limetech/lime-crm-building-blocks 1.96.0 → 1.98.0

package/dist/types/components/lime-query-builder/expressions/lime-query-filter-and.d.ts

@@ -0,0 +1,56 @@
+import { EventEmitter } from '../../../stencil-public-runtime';
+import { LimeWebComponent, LimeWebComponentContext, LimeWebComponentPlatform } from '@limetech/lime-web-components';
+import { LimeQueryFilterAnd, LimeQueryFilterMissing } from '../lime-query.types';
+/**
+ * Lime Query Filter AND Component
+ *
+ * Renders a group of filter expressions where **all conditions must be true**.
+ * Users can add multiple child expressions, and a record must match all of them
+ * to be included in the result set.
+ *
+ * This component displays:
+ * - A header with "All of these conditions are true" when there are multiple conditions
+ * - A list of child expressions (which can be comparisons or nested AND/OR/NOT groups)
+ * - An "Add another condition" button to add more expressions
+ *
+ * Clicking the trash icon on a child expression removes it from the AND group.
+ *
+ * @private
+ */
+export declare class LimeQueryFilterAndComponent implements LimeWebComponent {
+    /**
+     * Platform service provider
+     */
+    platform: LimeWebComponentPlatform;
+    /**
+     * Component context
+     */
+    context: LimeWebComponentContext;
+    /**
+     * Optional label for the AND group
+     */
+    label: string;
+    /**
+     * The limetype being queried (e.g., "deal", "company")
+     */
+    limetype: string;
+    /**
+     * The limetype of the active object (for %activeObject% placeholders)
+     */
+    activeLimetype?: string;
+    /**
+     * The AND expression containing child expressions
+     */
+    expression: LimeQueryFilterAnd;
+    /**
+     * Emitted when the AND expression changes (expressions added/removed/modified)
+     */
+    expressionChange: EventEmitter<LimeQueryFilterAnd | LimeQueryFilterMissing>;
+    render(): any;
+    private renderChildExpression;
+    private renderAddChildExpression;
+    private getAddButtonLabel;
+    private handleAddChildExpression;
+    private handleExpressionChange;
+}
+//# sourceMappingURL=lime-query-filter-and.d.ts.map

package/dist/types/components/lime-query-builder/expressions/lime-query-filter-comparison.d.ts

@@ -0,0 +1,64 @@
+import { LimeWebComponentContext, LimeWebComponentPlatform } from '@limetech/lime-web-components';
+import { EventEmitter } from '../../../stencil-public-runtime';
+import { LimeQueryFilterComparison, LimeQueryFilterMissing } from '../lime-query.types';
+/**
+ * Lime Query Filter Comparison Component
+ *
+ * Renders a single comparison expression with three parts:
+ * 1. **Property** - The field to compare (e.g., "dealstatus", "company.name")
+ * 2. **Operator** - The comparison operator (=, !=, >, <, >=, <=, IN, ?, =?, =$)
+ * 3. **Value** - The value to compare against
+ *
+ * This is the most basic building block of a filter. Examples:
+ * - dealstatus = "won"
+ * - value > 100000
+ * - name ? "Big" (contains "Big")
+ * - dealstatus IN ["won", "tender"]
+ *
+ * The component displays:
+ * - A text input for the property (Phase 0 - will be replaced with property-path in Phase 1)
+ * - A dropdown for the operator
+ * - A value input (text/number based on operator)
+ * - A trash icon button to remove this condition
+ *
+ * @private
+ */
+export declare class LimeQueryFilterComparisonComponent {
+    /**
+     * Platform service provider
+     */
+    platform: LimeWebComponentPlatform;
+    /**
+     * Component context
+     */
+    context: LimeWebComponentContext;
+    /**
+     * Optional label for the comparison
+     */
+    label: string;
+    /**
+     * The limetype being queried (e.g., "deal", "company")
+     */
+    limetype: string;
+    /**
+     * The limetype of the active object (for %activeObject% placeholders)
+     */
+    activeLimetype?: string;
+    /**
+     * The comparison expression to render
+     */
+    expression: LimeQueryFilterComparison;
+    /**
+     * Emitted when the comparison expression changes (property/operator/value modified)
+     */
+    expressionChange: EventEmitter<LimeQueryFilterComparison | LimeQueryFilterMissing>;
+    render(): any;
+    private renderPropertySelector;
+    private renderOperator;
+    private renderValueInput;
+    private handlePropertyChange;
+    private handleOperatorChange;
+    private handleValueChange;
+    private removeExpression;
+}
+//# sourceMappingURL=lime-query-filter-comparison.d.ts.map

package/dist/types/components/lime-query-builder/expressions/lime-query-filter-expression.d.ts

@@ -0,0 +1,53 @@
+import { EventEmitter } from '../../../stencil-public-runtime';
+import { LimeQueryFilterExpression } from '../lime-query.types';
+import { LimeWebComponent, LimeWebComponentContext, LimeWebComponentPlatform } from '@limetech/lime-web-components';
+/**
+ * Lime Query Filter Expression Router
+ *
+ * This is the main entry point for rendering Lime Query filters.
+ * It routes to the appropriate sub-component based on the filter type:
+ * - `'AND'` → limebb-lime-query-filter-and
+ * - `'OR'` → limebb-lime-query-filter-or
+ * - `'NOT'` → limebb-lime-query-filter-not
+ * - `'comparison'` → limebb-lime-query-filter-comparison
+ * - `''` (missing) → limebb-lime-query-filter-comparison (default)
+ *
+ * Use this component when you need to render a complete filter expression
+ * that may contain nested AND/OR/NOT logic.
+ *
+ * @private
+ */
+export declare class LimeQueryFilterExpressionComponent implements LimeWebComponent {
+    /**
+     * Platform service provider
+     */
+    platform: LimeWebComponentPlatform;
+    /**
+     * Component context
+     */
+    context: LimeWebComponentContext;
+    /**
+     * Optional label for the expression
+     */
+    label: string;
+    /**
+     * The limetype being queried (e.g., "deal", "company")
+     * Used for property validation and type-aware inputs
+     */
+    limetype: string;
+    /**
+     * The limetype of the active object (for %activeObject% placeholders)
+     * Optional - used for validation and property suggestions
+     */
+    activeLimetype?: string;
+    /**
+     * The filter expression to render
+     */
+    expression: LimeQueryFilterExpression;
+    /**
+     * Emitted when the filter expression changes
+     */
+    expressionChange: EventEmitter<LimeQueryFilterExpression>;
+    render(): any;
+}
+//# sourceMappingURL=lime-query-filter-expression.d.ts.map

package/dist/types/components/lime-query-builder/expressions/lime-query-filter-not.d.ts

@@ -0,0 +1,54 @@
+import { EventEmitter } from '../../../stencil-public-runtime';
+import { LimeWebComponent, LimeWebComponentContext, LimeWebComponentPlatform } from '@limetech/lime-web-components';
+import { LimeQueryFilterNot, LimeQueryFilterMissing } from '../lime-query.types';
+/**
+ * Lime Query Filter NOT Component
+ *
+ * Renders a negated filter expression. This inverts the logic of the child expression,
+ * so records that would normally match will be excluded, and vice versa.
+ *
+ * For example:
+ * - NOT (status = "won") → Include all records where status is NOT "won"
+ * - NOT (value > 100000) → Include all records where value is NOT greater than 100000
+ *
+ * This component displays:
+ * - A "Not" label
+ * - A single child expression (which can be a comparison or nested AND/OR group)
+ *
+ * Clicking the trash icon removes the entire NOT expression.
+ *
+ * @private
+ */
+export declare class LimeQueryFilterNotComponent implements LimeWebComponent {
+    /**
+     * Platform service provider
+     */
+    platform: LimeWebComponentPlatform;
+    /**
+     * Component context
+     */
+    context: LimeWebComponentContext;
+    /**
+     * Optional label for the NOT expression
+     */
+    label: string;
+    /**
+     * The limetype being queried (e.g., "deal", "company")
+     */
+    limetype: string;
+    /**
+     * The limetype of the active object (for %activeObject% placeholders)
+     */
+    activeLimetype?: string;
+    /**
+     * The NOT expression containing the child expression to negate
+     */
+    expression: LimeQueryFilterNot;
+    /**
+     * Emitted when the NOT expression changes (child expression modified or removed)
+     */
+    expressionChange: EventEmitter<LimeQueryFilterNot | LimeQueryFilterMissing>;
+    render(): any;
+    private handleExpressionChange;
+}
+//# sourceMappingURL=lime-query-filter-not.d.ts.map

package/dist/types/components/lime-query-builder/expressions/lime-query-filter-or.d.ts

@@ -0,0 +1,55 @@
+import { EventEmitter } from '../../../stencil-public-runtime';
+import { LimeWebComponent, LimeWebComponentContext, LimeWebComponentPlatform } from '@limetech/lime-web-components';
+import { LimeQueryFilterOr, LimeQueryFilterMissing } from '../lime-query.types';
+/**
+ * Lime Query Filter OR Component
+ *
+ * Renders a group of filter expressions where **at least one condition must be true**.
+ * Users can add multiple alternative expressions, and a record only needs to match
+ * one of them to be included in the result set.
+ *
+ * This component displays:
+ * - A header with "Any of these conditions is true" when there are multiple conditions
+ * - A list of child expressions (which can be comparisons or nested AND/OR/NOT groups)
+ * - An "Add alternative" button to add more options
+ *
+ * Clicking the trash icon on a child expression removes it from the OR group.
+ *
+ * @private
+ */
+export declare class LimeQueryFilterOrComponent implements LimeWebComponent {
+    /**
+     * Platform service provider
+     */
+    platform: LimeWebComponentPlatform;
+    /**
+     * Component context
+     */
+    context: LimeWebComponentContext;
+    /**
+     * Optional label for the OR group
+     */
+    label: string;
+    /**
+     * The limetype being queried (e.g., "deal", "company")
+     */
+    limetype: string;
+    /**
+     * The limetype of the active object (for %activeObject% placeholders)
+     */
+    activeLimetype?: string;
+    /**
+     * The OR expression containing child expressions
+     */
+    expression: LimeQueryFilterOr;
+    /**
+     * Emitted when the OR expression changes (expressions added/removed/modified)
+     */
+    expressionChange: EventEmitter<LimeQueryFilterOr | LimeQueryFilterMissing>;
+    render(): any;
+    private renderChildExpression;
+    private handleExpressionChange;
+    private renderAddChildExpression;
+    private handleAddChildExpression;
+}
+//# sourceMappingURL=lime-query-filter-or.d.ts.map

package/dist/types/components/lime-query-builder/expressions/lime-query-value-input.d.ts

@@ -0,0 +1,92 @@
+import { EventEmitter } from '../../../stencil-public-runtime';
+import { LimeWebComponentContext, LimeWebComponentPlatform } from '@limetech/lime-web-components';
+import { FilterOperator } from '../lime-query.types';
+/**
+ * Query Value Input Component
+ *
+ * Renders an appropriate input control based on the property type and operator.
+ * This component automatically adapts its UI to match the data type of the selected
+ * property, providing a better user experience and data validation.
+ *
+ * Supported input types:
+ * - **String/Text**: Standard text input field
+ * - **Integer/Decimal**: Number input with appropriate step values
+ * - **Date**: Date picker returning ISO date strings
+ * - **Time**: Time input field
+ * - **Boolean (yesno)**: True/False dropdown
+ * - **Option**: Dropdown populated with valid options from property definition
+ * - **IN operator**: Comma-separated input for multiple values (any type)
+ * - **Placeholder mode**: Select properties from active object using %activeObject%
+ *
+ * The component handles type conversions automatically:
+ * - Numbers are parsed from string inputs
+ * - Dates are converted to/from ISO strings
+ * - Booleans are converted to/from strings for dropdown compatibility
+ *
+ * @private
+ */
+export declare class LimeQueryValueInput {
+    /**
+     * Platform service provider
+     */
+    platform: LimeWebComponentPlatform;
+    /**
+     * Component context
+     */
+    context: LimeWebComponentContext;
+    /**
+     * The limetype being queried
+     */
+    limetype: string;
+    /**
+     * The limetype of the active object (for %activeObject% placeholders)
+     */
+    activeLimetype?: string;
+    /**
+     * The property path (e.g., "dealstatus", "company.name")
+     */
+    propertyPath: string;
+    /**
+     * The operator being used
+     */
+    operator: FilterOperator;
+    /**
+     * The current value
+     */
+    value: any;
+    /**
+     * Optional label for the input
+     */
+    label: string;
+    private limetypes;
+    private inputMode;
+    /**
+     * Emitted when the value changes
+     */
+    change: EventEmitter<any>;
+    componentWillLoad(): void;
+    componentWillUpdate(): void;
+    private isPlaceholder;
+    private parsePlaceholderPath;
+    private buildPlaceholderValue;
+    render(): any;
+    private renderModeToggle;
+    private renderPlaceholderInput;
+    private renderValueInputByType;
+    private renderTextInput;
+    private renderNumberInput;
+    private renderBooleanInput;
+    private renderOptionInput;
+    private renderDateInput;
+    private renderTimeInput;
+    private renderMultiValueInput;
+    private handleTextChange;
+    private handleSelectChange;
+    private handleBooleanChange;
+    private handleDateChange;
+    private handleMultiValueChange;
+    private handleModeToggle;
+    private handlePlaceholderPropertyChange;
+    private getProperty;
+}
+//# sourceMappingURL=lime-query-value-input.d.ts.map

package/dist/types/components/lime-query-builder/filter-conversion.d.ts

@@ -10,4 +10,22 @@ export declare function guiFilterToLimeQuery(filter: LimeQueryFilterExpression):
  * @param filter
  */
 export declare function limeQueryToGuiFilter(filter: FilterExpression | FilterGroup | undefined): LimeQueryFilterExpression;
+/**
+ * Normalize filter for GUI mode by ensuring proper AND/OR wrapper structure.
+ * GUI mode requires filters to be wrapped in AND([OR(...)]) so users have
+ * access to add/remove buttons on the AND and OR components.
+ *
+ * This function ensures that:
+ * - Single comparisons are wrapped in AND([OR([comparison])])
+ * - OR groups are wrapped in AND([OR group])
+ * - AND groups have their comparison children wrapped in OR
+ * - Empty/undefined filters become AND([])
+ *
+ * When converting back to Lime Query JSON, limeQueryFilterToLimeQuery()
+ * automatically unwraps single-item AND/OR groups.
+ *
+ * @param filter The filter expression from limeQueryToLimeQueryFilter
+ * @returns Normalized filter suitable for GUI editing
+ */
+export declare function normalizeLimeQueryFilterForGui(filter: LimeQueryFilterExpression): LimeQueryFilterExpression;
 //# sourceMappingURL=filter-conversion.d.ts.map

package/dist/types/components/lime-query-builder/lime-query-builder.d.ts

@@ -4,18 +4,27 @@ import { LimeQuery } from './lime-query.types';
 /**
  * Lime Query Builder Component
  *
- * A code editor for constructing Lime Query DSL queries in JSON format.
+ * A comprehensive query builder for constructing Lime Query DSL queries.
+ * This is the main component that combines limetype selection with the filter builder.
  *
  * Features:
- * - **JSON code editor**: Write queries using the Lime Query DSL
- * - **Syntax validation**: Real-time validation of query structure
- * - **Feature flag support**: GUI mode placeholder (not yet implemented)
+ * - **Limetype selection**: Choose which object type to query
+ * - **Filter builder**: Build complex filters with AND/OR/NOT logic
+ * - **Property path selection**: Navigate through relations
+ * - **Type-aware inputs**: Automatic input types based on property type
+ * - **Response format**: Select which properties to return
+ * - **Query options**: Configure limit and other query parameters
+ * - **Placeholder support**: Use `%activeObject%` placeholders in filter values
+ * - **Real-time output**: See the Lime Query JSON as you build
  *
- * The component allows editing of complete `LimeQuery` objects that can be sent
+ * The component produces a complete `LimeQuery` object that can be sent
  * directly to the Lime CRM backend.
  *
- * When the feature flag `useLimeQueryBuilderGuiMode` is enabled, a mode toggle
- * becomes available, but GUI mode currently shows a placeholder message.
+ * **Active Object Placeholders**:
+ * When the `activeLimetype` prop is provided, the component enables validation
+ * and UI support for `%activeObject%` placeholders in filter expressions.
+ * These placeholders reference properties of a contextual "active object"
+ * (e.g., `%activeObject%.company` references the company of the active object).
  *
  * @exampleComponent limebb-example-lime-query-builder-basic
  * @private
@@ -44,12 +53,36 @@ export declare class LimeQueryBuilder implements LimeWebComponent {
     private limetypes;
     private mode;
     private codeValue;
+    private limetype;
+    private filter;
+    private internalResponseFormat?;
+    private limit?;
+    /**
+     * The limetype of the active object (for %activeObject% placeholder validation).
+     * When provided, enables placeholder validation and the placeholder input mode.
+     * When omitted, placeholders are accepted without validation.
+     */
+    activeLimetype?: string;
     private get guiModeEnabled();
     componentWillLoad(): void;
     render(): any;
+    private handleLimetypeChange;
+    private handleFilterChange;
+    private handleResponseFormatChange;
+    private handleLimitChange;
+    private emitChange;
+    private updateCodeValue;
     private checkGuiSupport;
     private renderModeSwitch;
     private renderCodeEditor;
+    private renderLimetypeSection;
+    private renderResponseFormatSection;
+    private renderFilterSection;
+    private renderQueryOptionsSection;
+    private renderGuiMode;
+    private renderLabel;
+    private renderModeControls;
+    private renderCodeMode;
     private switchToGui;
     private switchToCode;
     private handleCodeChange;

package/dist/types/components/lime-query-builder/limetype-field/limetype-field.d.ts

@@ -0,0 +1,96 @@
+import { EventEmitter } from '../../../stencil-public-runtime';
+import { FormComponent, FormInfo } from '@limetech/lime-elements';
+import { LimeWebComponentPlatform, LimeWebComponentContext, LimeWebComponent, PropertyType } from '@limetech/lime-web-components';
+type DependentPropertyField = {
+    limetype: string;
+    allowedPropertyTypes?: PropertyType[];
+};
+/**
+ * Limetype Field Component
+ *
+ * A dropdown selector for choosing a limetype (object type) from the available
+ * limetypes in the system.
+ *
+ * This component:
+ * - Displays all limetypes with their icons and localized names
+ * - Supports restricting to a specific list of limetypes
+ * - Can update dependent property-path fields when selection changes
+ * - Implements the FormComponent interface for use in forms
+ *
+ * Common use cases:
+ * - Selecting which object type to query in a lime query builder
+ * - Choosing target limetype for relations
+ * - Configuring limetype-dependent settings
+ *
+ * @private
+ */
+export declare class LimetypeField implements LimeWebComponent, FormComponent<string> {
+    /**
+     * @inheritdoc
+     */
+    platform: LimeWebComponentPlatform;
+    /**
+     * @inheritdoc
+     */
+    context: LimeWebComponentContext;
+    /**
+     * @inheritdoc
+     */
+    label: string;
+    /**
+     * @inheritdoc
+     */
+    required: boolean;
+    /**
+     * @inheritdoc
+     */
+    readonly: boolean;
+    /**
+     * @inheritdoc
+     */
+    disabled: boolean;
+    /**
+     * @inheritdoc
+     */
+    value: string;
+    /**
+     * @inheritdoc
+     */
+    helperText: string;
+    /**
+     * @inheritdoc
+     */
+    invalid: boolean;
+    /**
+     * The limetypes to choose from
+     */
+    limetypes?: string[];
+    /**
+     * A list of property fields that should be updated when the selected limetype changes.
+     */
+    propertyFields: DependentPropertyField[];
+    /**
+     * The name of this field. May be used as reference when a property mapping
+     * depends on the selected limetype.
+     */
+    fieldName: string;
+    /**
+     * @inheritdoc
+     */
+    formInfo?: FormInfo;
+    /**
+     * @inheritdoc
+     */
+    change: EventEmitter<string>;
+    private collator;
+    componentWillLoad(): void;
+    componentShouldUpdate(newValue: FormInfo | undefined, oldValue: FormInfo | undefined, property: string): boolean;
+    render(): any;
+    componentWillRender(): void;
+    private getLimeTypes;
+    private handleChange;
+    private updatePropertyFields;
+    private get limeTypeRepository();
+}
+export {};
+//# sourceMappingURL=limetype-field.d.ts.map

package/dist/types/components/lime-query-builder/property-selection-format.d.ts

@@ -0,0 +1,23 @@
+import { PropertySelection } from './lime-query.types';
+/**
+ * Represents a single property selection item in the UI
+ */
+export interface PropertySelectionItem {
+    path: string;
+    alias?: string;
+    description?: string;
+}
+/**
+ * Convert a nested PropertySelection to a flat list of property items
+ * @param selection The nested PropertySelection object
+ * @param prefix Current path prefix (used for recursion)
+ * @returns Flat array of PropertySelectionItem objects
+ */
+export declare function propertySelectionToItems(selection: PropertySelection | undefined | null, prefix?: string): PropertySelectionItem[];
+/**
+ * Convert a flat list of property items to a nested PropertySelection structure
+ * @param items Array of PropertySelectionItem objects
+ * @returns Nested PropertySelection object
+ */
+export declare function itemsToPropertySelection(items: PropertySelectionItem[]): PropertySelection;
+//# sourceMappingURL=property-selection-format.d.ts.map

package/dist/types/components/lime-query-builder/property-selector/property-selector.d.ts

@@ -0,0 +1,71 @@
+import { EventEmitter } from '../../../stencil-public-runtime';
+import { LimeWebComponent, LimeWebComponentContext, LimeWebComponentPlatform } from '@limetech/lime-web-components';
+/**
+ * Property Selector Component
+ *
+ * A menu-based property selector that allows users to navigate through properties
+ * and relations, only emitting complete property paths (not intermediate relations).
+ *
+ * Similar to limec-context-expression but specifically for selecting properties
+ * with dot-notation paths.
+ *
+ * Features:
+ * - Menu-based navigation through properties
+ * - Submenu support for drilling into relations
+ * - Internal state management during navigation
+ * - Only emits complete paths (leaf properties)
+ * - Chip-set display showing current path
+ * @private
+ */
+export declare class PropertySelector implements LimeWebComponent {
+    /**
+     * Platform service provider
+     */
+    platform: LimeWebComponentPlatform;
+    /**
+     * Component context
+     */
+    context: LimeWebComponentContext;
+    /**
+     * The limetype to select properties from
+     */
+    limetype: string;
+    /**
+     * Current complete property path value
+     */
+    value: string;
+    /**
+     * Label for the input
+     */
+    label: string;
+    /**
+     * Whether the field is required
+     */
+    required: boolean;
+    /**
+     * Helper text to display
+     */
+    helperText: string;
+    private limetypes;
+    private isOpen;
+    private navigationPath;
+    /**
+     * Emitted when a complete property path is selected
+     */
+    change: EventEmitter<string>;
+    private menuItems;
+    render(): any;
+    private handleChipSetWrapperClick;
+    private handleChipSetFocus;
+    private handleSelect;
+    private handleNavigateMenu;
+    private handleCancel;
+    private handleChipSetChange;
+    private loadMenuItems;
+    private getCurrentLimetype;
+    private createMenuItems;
+    private getSecondaryText;
+    private getIconForProperty;
+    private getChipsForPath;
+}
+//# sourceMappingURL=property-selector.d.ts.map