@limetech/lime-crm-building-blocks 1.135.0 → 1.136.0

package/dist/lime-crm-building-blocks/{p-DjwVpKf5.js → p-xIXgZHrE.js}

@@ -1 +1 @@
-import{n}from"./p-BVxuJgRM.js";function e(e){return e.op===n.NOT?e.exp.op===n.AND?"NOT_AND":"NOT_OR":e.op===n.AND?"AND":"OR"}function t(e){return e.op===n.NOT?e.exp:e}function r(e,r){const o=t(e),p={op:"AND"===r||"NOT_AND"===r?n.AND:n.OR,exp:[...o.exp]};return"NOT_AND"===r||"NOT_OR"===r?{op:n.NOT,exp:p}:p}function o(e){if(e.op===n.AND||e.op===n.OR)return!0;if(e.op===n.NOT){const t=e.exp;return t.op===n.AND||t.op===n.OR}return!1}function p(n){return o(n)?n:void 0}function u(){return{key:"",op:n.EQUALS,exp:""}}function s(e){return{op:e===n.AND?n.OR:n.AND,exp:[u()]}}function i(n,e){return{op:n.op,exp:[...n.exp,e]}}function a(n,e,t){const r=[...n.exp];return t?(r[e]=t,{type:"updated",expression:{op:n.op,exp:r}}):(r.splice(e,1),0===r.length?{type:"removed",expression:void 0}:{type:"updated",expression:{op:n.op,exp:r}})}export{p as a,i as b,t as c,s as d,u as e,e as g,o as i,r as s,a as u}
+import{n}from"./p-Dtg8KAQt.js";function e(e){return e.op===n.NOT?e.exp.op===n.AND?"NOT_AND":"NOT_OR":e.op===n.AND?"AND":"OR"}function t(e){return e.op===n.NOT?e.exp:e}function r(e,r){const o=t(e),p={op:"AND"===r||"NOT_AND"===r?n.AND:n.OR,exp:[...o.exp]};return"NOT_AND"===r||"NOT_OR"===r?{op:n.NOT,exp:p}:p}function o(e){if(e.op===n.AND||e.op===n.OR)return!0;if(e.op===n.NOT){const t=e.exp;return t.op===n.AND||t.op===n.OR}return!1}function p(n){return o(n)?n:void 0}function u(){return{key:"",op:n.EQUALS,exp:""}}function s(e){return{op:e===n.AND?n.OR:n.AND,exp:[u()]}}function i(n,e){return{op:n.op,exp:[...n.exp,e]}}function a(n,e,t){const r=[...n.exp];return t?(r[e]=t,{type:"updated",expression:{op:n.op,exp:r}}):(r.splice(e,1),0===r.length?{type:"removed",expression:void 0}:{type:"updated",expression:{op:n.op,exp:r}})}export{p as a,i as b,t as c,s as d,u as e,e as g,o as i,r as s,a as u}

package/dist/types/components/filter-chip/filter-chip.d.ts

@@ -0,0 +1,173 @@
+import { IconName } from '@limetech/lime-elements';
+import { LimeWebComponentPlatform, PropertyType } from '@limetech/lime-web-components';
+import { EventEmitter } from '../../stencil-public-runtime';
+import { FilterChipConjunction, FilterCondition } from './filter-chip.types';
+/**
+ * Filter chip
+ *
+ * A compact, static chip that visualizes a single filter condition: a
+ * floating label (the property/column the filter applies to), an icon that
+ * describes the kind of condition (equals, contains, is between, …), and
+ * the filter value.
+ *
+ * It is presentational: it understands the shared Lime filter vocabulary
+ * (the `condition` and `propertyType`, from which it derives the icon and
+ * wording) but nothing about how a consumer models or stores its filters.
+ * Consumers feed it strings and pick a `condition`, and wire up their own
+ * editor by listening to the chip's `click`/`remove` events (for example by
+ * slotting the chip as the trigger of a popover).
+ *
+ * @exampleComponent limebb-example-filter-chip-basic
+ * @exampleComponent limebb-example-filter-chip-states
+ * @exampleComponent limebb-example-filter-chip-conditions
+ * @exampleComponent limebb-example-filter-chip-property-types
+ * @exampleComponent limebb-example-filter-chip-multiple-values
+ * @beta
+ */
+export declare class FilterChip {
+    /**
+     * The label of the chip, typically the name of the property or column
+     * the filter applies to. Rendered as a small floating label above the
+     * chip and used as the primary line of the tooltip.
+     */
+    label: string;
+    /**
+     * The filter value to display.
+     *
+     * Pass a single string for a single value, or an array of strings for
+     * multiple values. When an array is given, the values are joined by the
+     * `conjunction` and any that do not fit are collapsed into a `+N` badge.
+     */
+    value?: string | string[];
+    /**
+     * How multiple values are joined: `"or"` (any of) or `"and"` (all of).
+     * The chip renders the localized join word muted between the values —
+     * `and` is shown compactly as `&`. Only used when `value` is an array.
+     */
+    conjunction?: FilterChipConjunction;
+    /**
+     * The kind of condition the filter represents. The chip maps it to a
+     * standard icon (via the shared filter-condition vocabulary), so the same
+     * condition shows the same icon across every consumer.
+     */
+    condition?: FilterCondition;
+    /**
+     * The data type of the filtered property (e.g. `string`, `integer`,
+     * `date`, `option`, `yesno`). The chip combines it with `condition` to
+     * pick the type-specific icon and wording: a `greater-than` on a date
+     * shows as "After" (▶) rather than `>`, and equality reads as "Is" for
+     * text and options, "Equals" for numbers, and "On" for dates. Leave unset
+     * for types where the standard condition presentation already applies.
+     */
+    propertyType?: PropertyType;
+    /**
+     * An explicit icon for the chip.
+     *
+     * Normally you do not set this — the chip picks the standard icon for the
+     * `condition` automatically. Use `icon` to override that: for a condition
+     * outside the standard set, or when you have already resolved a
+     * context-dependent icon yourself (for example when the same condition
+     * uses a different icon depending on the property type, as in the CRM's
+     * date vs. number filters).
+     */
+    icon?: IconName;
+    /**
+     * The secondary line of the tooltip, typically the full, untruncated
+     * condition (e.g. `"Equals «full value»"`). Defaults to the joined
+     * value when not provided.
+     */
+    helperLabel?: string;
+    /**
+     * Set to `true` to render a remove button on the chip.
+     */
+    removable: boolean;
+    /**
+     * Set to `true` to make the chip readonly.
+     */
+    readonly: boolean;
+    /**
+     * Set to `true` to make the chip disabled. Like `readonly`, this
+     * neutralizes clicks and the remove shortcut, but still lets the tooltip
+     * show on hover so the full filter stays readable.
+     */
+    disabled: boolean;
+    /**
+     * Set to `true` to visualize the chip as invalid, for example when the
+     * filter cannot be resolved.
+     */
+    invalid: boolean;
+    /**
+     * Set to `true` to visualize the chip as active/pressed, for example
+     * while its editor is open.
+     */
+    selected: boolean;
+    /**
+     * A unique identifier for the chip, emitted as the payload of the
+     * `remove` event.
+     */
+    identifier?: string | number;
+    /**
+     * Reference to the platform, used to translate the chip's built-in
+     * labels — currently the remove button's accessible label
+     * (`webclient.remove-filter`). When omitted, a non-localized fallback is
+     * used. This is the only platform dependency; the chip is otherwise
+     * purely presentational.
+     */
+    platform?: LimeWebComponentPlatform;
+    /**
+     * The maximum number of characters of value text to show before
+     * collapsing the remainder into a `+N` badge.
+     */
+    maxLength: number;
+    /**
+     * Emitted when the chip is removed, either by clicking the remove button
+     * or by pressing `Backspace`/`Delete` while the chip is focused. The
+     * payload is the chip's `identifier`.
+     */
+    remove: EventEmitter<string | number | undefined>;
+    private randomId;
+    private get chipId();
+    render(): any;
+    /**
+     * `aria-pressed` only makes sense for an interactive toggle. A readonly
+     * or disabled chip is not a toggle, so we omit the attribute entirely
+     * rather than announce a pressed state the user cannot change.
+     */
+    private getAriaPressed;
+    private renderLabel;
+    private renderIcon;
+    private getIconName;
+    /**
+     * Whether the value is a raw pattern rather than a normal value — true
+     * for a `matches` filter, whose regex-like value is rendered muted (the
+     * same muted/italic styling used for blank values).
+     */
+    private get hasRawValue();
+    private renderValue;
+    private renderValueItems;
+    private renderValueItem;
+    private renderBadge;
+    private renderRemoveButton;
+    private getTranslator;
+    private getRemoveButtonLabel;
+    private getConditionLabel;
+    private getConjunctionText;
+    private getFilterLabel;
+    private getValueItems;
+    private getDisplayItems;
+    private getEmptyLabel;
+    private separatorFor;
+    private getHelperLabel;
+    private truncateItems;
+    /**
+     * Neutralize interactions when the chip is not interactive, without
+     * blocking pointer events (so the tooltip still works on hover). Runs in
+     * the capture phase so a click never reaches the consumer's own handler
+     * while the chip is `disabled` or `readonly`.
+     * @param event
+     */
+    protected filterClickWhenInactive(event: MouseEvent): void;
+    private handleKeyDown;
+    private handleRemoveClick;
+}
+//# sourceMappingURL=filter-chip.d.ts.map

package/dist/types/components/filter-chip/filter-chip.types.d.ts

@@ -0,0 +1,32 @@
+/**
+ * How a filter chip joins multiple values.
+ *
+ * - `or` — any of the values (e.g. `A or B`)
+ * - `and` — all of the values (rendered compactly as `A & B`)
+ *
+ * The chip translates this itself; it is not a pre-localized string. The
+ * union can be extended if more joiners are ever needed.
+ *
+ * @public
+ */
+export type FilterChipConjunction = 'and' | 'or';
+/**
+ * The kind of condition a filter represents.
+ *
+ * This is the canonical, UI-agnostic vocabulary of *logical* filter
+ * conditions used across Lime CRM. A `limebb-filter-chip` maps a condition to
+ * the right icon and wording automatically, so that every consumer (query
+ * builders, filter visualizers, condition editors, …) shows the same glyph
+ * and label for the same condition. Consumers map their own domain operators
+ * onto these values.
+ *
+ * Presentation can additionally depend on the property's data type: the chip
+ * resolves the type-specific variant from `(condition, propertyType)`. For
+ * example `greater-than` shows as `>` for a number but as "After" (▶) for a
+ * date, and `equals` reads as "Equals", "Is", or "On" depending on the type.
+ * Those variants are therefore *not* separate conditions here.
+ *
+ * @public
+ */
+export type FilterCondition = 'equals' | 'not-equals' | 'greater-than' | 'greater-than-or-equal' | 'less-than' | 'less-than-or-equal' | 'between' | 'not-between' | 'contains' | 'not-contains' | 'begins-with' | 'not-begins-with' | 'ends-with' | 'not-ends-with' | 'empty' | 'not-empty' | 'previous' | 'current' | 'next' | 'connected-to' | 'not-connected-to' | 'in-filter-set' | 'not-in-filter-set' | 'matches';
+//# sourceMappingURL=filter-chip.types.d.ts.map

package/dist/types/components/filter-chip/filter-condition-icons.d.ts

@@ -0,0 +1,64 @@
+import { IconName } from '@limetech/lime-elements';
+import { PropertyType } from '@limetech/lime-web-components';
+import { FilterCondition } from './filter-chip.types';
+/**
+ * Icon shown when a condition is unknown or not provided.
+ */
+export declare const FALLBACK_CONDITION_ICON: IconName;
+/**
+ * Maps each {@link FilterCondition} to the icon name that visualizes it.
+ *
+ * The icons are filenames in the shared `lime-icons8` set and are resolved
+ * at runtime by `limel-icon` from the host application's configured
+ * `iconPath`, so nothing needs to be bundled here.
+ *
+ * Some comparison conditions take a different icon for date properties; those
+ * variants are resolved by {@link getFilterConditionIcon} and live in
+ * {@link DATE_CONDITION_PRESENTATION} rather than here.
+ */
+export declare const FILTER_CONDITION_ICONS: Record<FilterCondition, IconName>;
+/**
+ * Resolve the icon name for a filter condition.
+ *
+ * Useful anywhere a condition needs a consistent icon — not only in the
+ * filter chip (e.g. operator dropdowns or condition editors). When a
+ * `propertyType` is given, the type-specific variant is used; for example a
+ * `greater-than` on a date resolves to the "After" icon rather than `>`.
+ *
+ * @param condition - the condition to get an icon for
+ * @param propertyType - the data type of the filtered property, used to pick
+ * the type-specific variant (e.g. date comparisons)
+ * @returns the matching icon name, or the fallback icon when the condition
+ * is unknown or undefined
+ */
+export declare function getFilterConditionIcon(condition?: FilterCondition, propertyType?: PropertyType): IconName;
+/**
+ * Maps each {@link FilterCondition} to the translation key that names it.
+ *
+ * These are the same `webclient.operator.*` keys (plus `webclient.empty` /
+ * `webclient.not-empty`) used across Lime CRM — the wording shown beside each
+ * icon in the condition dropdown. Reusing them keeps the chip's tooltip and
+ * accessible name consistent with the rest of the product, in every language.
+ *
+ * Some conditions take different wording depending on the property type (e.g.
+ * "After" for a date `greater-than`, or "Is" for an option `equals`); those
+ * variants are resolved by {@link getFilterConditionLabelKey}.
+ */
+export declare const FILTER_CONDITION_LABEL_KEYS: Record<FilterCondition, string>;
+/**
+ * Resolve the translation key that names a filter condition.
+ *
+ * Useful anywhere a condition needs a consistent, localized name — not only
+ * in the filter chip's tooltip (e.g. operator dropdowns or condition editors).
+ * When a `propertyType` is given, the type-specific wording is used; for
+ * example a `greater-than` on a date resolves to "After", and `equals` on an
+ * option resolves to "Is".
+ *
+ * @param condition - the condition to get a label key for
+ * @param propertyType - the data type of the filtered property, used to pick
+ * the type-specific wording
+ * @returns the matching translation key, or `undefined` when the condition is
+ * unknown or undefined
+ */
+export declare function getFilterConditionLabelKey(condition?: FilterCondition, propertyType?: PropertyType): string | undefined;
+//# sourceMappingURL=filter-condition-icons.d.ts.map

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

@@ -15,11 +15,11 @@ import { ComparisonExpression } from './lime-query-operators';
  * - 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
+ * The comparison is shown as the shared, presentational `limebb-filter-chip`
+ * (slotted as the trigger of the edit popover): this component resolves the
+ * property label, maps the operator to a `FilterCondition`, resolves the
+ * property type, and formats the value — and lets the chip render the icon,
+ * wording, tooltip, and remove button.
  *
  * @private
  */
@@ -56,16 +56,23 @@ export declare class LimeQueryFilterComparisonComponent {
     private isOpen;
     componentWillLoad(): void;
     render(): any;
-    private summaryText;
     private getPropertyLabel;
-    private summaryIcon;
-    private getOperatorLabel;
+    private getPropertyType;
+    /**
+     * Walk a (possibly nested) property path like `company.name`, descending
+     * through relations one segment at a time. Returns the leaf property (for
+     * type resolution) and the localized label of each segment (joined into
+     * the chip label). A segment that cannot be resolved falls back to its
+     * raw name so the label still reads sensibly.
+     * @param key
+     */
+    private resolveProperty;
+    private chipValue;
     private formatValue;
     private handleOpen;
     private handleClose;
     private renderHeader;
     private handleEditorChange;
     private removeExpression;
-    private get translator();
 }
 //# sourceMappingURL=lime-query-filter-comparison.d.ts.map