@limetech/lime-crm-building-blocks 1.95.0 → 1.97.0

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,19 +4,21 @@ 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
+ * - **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.
- *
  * @exampleComponent limebb-example-lime-query-builder-basic
  * @private
  */
@@ -44,12 +46,32 @@ export declare class LimeQueryBuilder implements LimeWebComponent {
     private limetypes;
     private mode;
     private codeValue;
+    private limetype;
+    private filter;
+    private internalResponseFormat?;
+    private limit?;
+    private activeLimetype?;
     private get guiModeEnabled();
     componentWillLoad(): void;
     render(): any;
+    private handleLimetypeChange;
+    private handleFilterChange;
+    private handleResponseFormatChange;
+    private handleLimitChange;
+    private handleActiveLimetypeChange;
+    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

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

@@ -0,0 +1,57 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import { LimeWebComponent, LimeWebComponentContext, LimeWebComponentPlatform } from '@limetech/lime-web-components';
+import { ResponseFormat } from './lime-query.types';
+/**
+ * Response Format Editor Component
+ *
+ * Allows users to select which properties should be returned in the query response.
+ * Supports selecting properties on both the main limetype and related limetypes
+ * through belongsto relations.
+ *
+ * Features:
+ * - **Property selection**: Choose properties using dropdown navigation
+ * - **Nested properties**: Select properties on related objects (e.g., company.name)
+ * - **Property aliases**: Optionally rename properties in the response
+ * - **Dynamic list**: Add/remove property selections
+ * - **Real-time updates**: Changes immediately update the responseFormat
+ *
+ * The component generates a `ResponseFormat` object with the `object` field
+ * containing the selected properties.
+ *
+ * @private
+ */
+export declare class ResponseFormatEditor implements LimeWebComponent {
+    /**
+     * Platform service provider
+     */
+    platform: LimeWebComponentPlatform;
+    /**
+     * Component context
+     */
+    context: LimeWebComponentContext;
+    /**
+     * The limetype to select properties from
+     */
+    limetype: string;
+    /**
+     * Current response format
+     */
+    value: ResponseFormat;
+    /**
+     * Optional label
+     */
+    label: string;
+    private items;
+    /**
+     * Emitted when the response format changes
+     */
+    change: EventEmitter<ResponseFormat>;
+    componentWillLoad(): void;
+    componentWillUpdate(): void;
+    render(): any;
+    private renderItem;
+    private handleItemChange;
+    private handleAddProperty;
+    private emitChange;
+}
+//# sourceMappingURL=response-format-editor.d.ts.map

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

@@ -0,0 +1,46 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import { LimeWebComponent, LimeWebComponentContext, LimeWebComponentPlatform } from '@limetech/lime-web-components';
+import { PropertySelectionItem } from './property-selection-format';
+/**
+ * Response Format Property Item Component
+ *
+ * Represents a single property selection with optional alias and description
+ * Part of the response format editor
+ * @private
+ */
+export declare class ResponseFormatItem implements LimeWebComponent {
+    /**
+     * Platform service provider
+     */
+    platform: LimeWebComponentPlatform;
+    /**
+     * Component context
+     */
+    context: LimeWebComponentContext;
+    /**
+     * The limetype to select properties from
+     */
+    limetype: string;
+    /**
+     * The property selection item
+     */
+    item: PropertySelectionItem;
+    /**
+     * Emitted when the item changes
+     */
+    itemChange: EventEmitter<PropertySelectionItem | null>;
+    private showAliasInput;
+    private showDescriptionInput;
+    componentWillLoad(): void;
+    componentWillUpdate(): void;
+    render(): any[];
+    private handlePathChange;
+    private toggleAliasInput;
+    private toggleDescriptionInput;
+    private handleAliasChange;
+    private handleDescriptionChange;
+    private handleAliasBlur;
+    private handleDescriptionBlur;
+    private handleRemove;
+}
+//# sourceMappingURL=response-format-item.d.ts.map