@luzmo/analytics-components-kit 1.0.8-beta.5 → 1.0.8-beta.6

package/angular/esm/components/filter-expression-picker.js

@@ -0,0 +1,179 @@
+import { booleanAttribute, ChangeDetectionStrategy, Component, DestroyRef, ElementRef, inject, Input, output, Renderer2 } from '@angular/core';
+import '@luzmo/analytics-components-kit/filter-expression-picker';
+import * as i0 from "@angular/core";
+const _c0 = ["*"];
+/**
+ * Angular wrapper component for <luzmo-filter-expression-picker>
+ */
+export class LuzmoFilterExpressionPicker {
+    elementRef = inject(ElementRef);
+    renderer = inject(Renderer2);
+    destroyRef = inject(DestroyRef);
+    host = this.elementRef.nativeElement;
+    listenerCleanup = [];
+    /** The underlying custom element instance. Use to call imperative methods. */
+    get nativeElement() {
+        return this.host;
+    }
+    /** The filter object */
+    filter;
+    /** Whether the picker has a label */
+    hasLabel;
+    /** The label for the picker, if hasLabel is true */
+    label;
+    /** Allow no selection. If true, the picker will not show a value when no item is selected. Else if no value is provided it will pick the first item. */
+    allowEmpty;
+    /** The placeholder text for the picker is no value selected. If allowEmpty is true, this will be used as the label. */
+    placeholder;
+    /** Whether the picker is disabled */
+    disabled;
+    /** The type of the column */
+    type;
+    /** The subtype of the column */
+    subtype;
+    /** Whether the expression is invalid */
+    invalid;
+    /** Whether the column is a formula */
+    isFormula;
+    /** The language for UI labels. Supported values: 'en', 'nl', 'fr', 'de', 'es' */
+    language;
+    /** The size of the element */
+    size;
+    /** When this control is rendered, focus it automatically */
+    autofocus;
+    /** The tab index to apply to this control. See general documentation about the tabindex HTML property */
+    tabIndex;
+    /** Fired when the user selects a filter expression (operator); `detail.expression` holds the chosen expression. */
+    luzmoExpressionSelected = output({ alias: 'luzmoExpressionSelected' });
+    constructor() {
+        this.bindEvents();
+        this.destroyRef.onDestroy(() => {
+            for (const cleanup of this.listenerCleanup) {
+                cleanup();
+            }
+        });
+    }
+    ngOnChanges(changes) {
+        for (const key of Object.keys(changes)) {
+            switch (key) {
+                case 'filter':
+                    this.setHostProperty('filter', changes['filter'].currentValue);
+                    break;
+                case 'hasLabel':
+                    this.setHostProperty('hasLabel', changes['hasLabel'].currentValue);
+                    break;
+                case 'label':
+                    this.setHostProperty('label', changes['label'].currentValue);
+                    break;
+                case 'allowEmpty':
+                    this.setHostProperty('allowEmpty', changes['allowEmpty'].currentValue);
+                    break;
+                case 'placeholder':
+                    this.setHostProperty('placeholder', changes['placeholder'].currentValue);
+                    break;
+                case 'disabled':
+                    this.setHostProperty('disabled', changes['disabled'].currentValue);
+                    break;
+                case 'type':
+                    this.setHostProperty('type', changes['type'].currentValue);
+                    break;
+                case 'subtype':
+                    this.setHostProperty('subtype', changes['subtype'].currentValue);
+                    break;
+                case 'invalid':
+                    this.setHostProperty('invalid', changes['invalid'].currentValue);
+                    break;
+                case 'isFormula':
+                    this.setHostProperty('isFormula', changes['isFormula'].currentValue);
+                    break;
+                case 'language':
+                    this.setHostProperty('language', changes['language'].currentValue);
+                    break;
+                case 'size':
+                    this.setHostProperty('size', changes['size'].currentValue);
+                    break;
+                case 'autofocus':
+                    this.setHostProperty('autofocus', changes['autofocus'].currentValue);
+                    break;
+                case 'tabIndex':
+                    this.setHostProperty('tabIndex', changes['tabIndex'].currentValue);
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+    /**
+     * Forward a wrapper @Input to the underlying host element via Renderer2 so
+     * the wrapper stays compatible with non-DOM Angular platforms (SSR, tests).
+     * Unlike a "skip undefined" guard, this lets consumers reset values back to
+     * undefined / null by clearing their bindings.
+     */
+    setHostProperty(key, value) {
+        this.renderer.setProperty(this.host, key, value);
+    }
+    bindEvents() {
+        this.listenerCleanup.push(this.renderer.listen(this.host, 'luzmo-expression-selected', (event) => {
+            const typed = event;
+            this.luzmoExpressionSelected.emit(typed);
+        }));
+    }
+    static ɵfac = function LuzmoFilterExpressionPicker_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || LuzmoFilterExpressionPicker)(); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: LuzmoFilterExpressionPicker, selectors: [["luzmo-filter-expression-picker"]], inputs: { filter: "filter", hasLabel: [2, "hasLabel", "hasLabel", booleanAttribute], label: "label", allowEmpty: [2, "allowEmpty", "allowEmpty", booleanAttribute], placeholder: "placeholder", disabled: [2, "disabled", "disabled", booleanAttribute], type: "type", subtype: "subtype", invalid: [2, "invalid", "invalid", booleanAttribute], isFormula: [2, "isFormula", "isFormula", booleanAttribute], language: "language", size: "size", autofocus: [2, "autofocus", "autofocus", booleanAttribute], tabIndex: "tabIndex" }, outputs: { luzmoExpressionSelected: "luzmoExpressionSelected" }, exportAs: ["luzmoFilterExpressionPicker"], features: [i0.ɵɵNgOnChangesFeature], ngContentSelectors: _c0, decls: 1, vars: 0, template: function LuzmoFilterExpressionPicker_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2 });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LuzmoFilterExpressionPicker, [{
+        type: Component,
+        args: [{
+                selector: 'luzmo-filter-expression-picker',
+                exportAs: 'luzmoFilterExpressionPicker',
+                standalone: true,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content />'
+            }]
+    }], () => [], { filter: [{
+            type: Input,
+            args: [{ alias: 'filter' }]
+        }], hasLabel: [{
+            type: Input,
+            args: [{ alias: 'hasLabel', transform: booleanAttribute }]
+        }], label: [{
+            type: Input,
+            args: [{ alias: 'label' }]
+        }], allowEmpty: [{
+            type: Input,
+            args: [{ alias: 'allowEmpty', transform: booleanAttribute }]
+        }], placeholder: [{
+            type: Input,
+            args: [{ alias: 'placeholder' }]
+        }], disabled: [{
+            type: Input,
+            args: [{ alias: 'disabled', transform: booleanAttribute }]
+        }], type: [{
+            type: Input,
+            args: [{ alias: 'type' }]
+        }], subtype: [{
+            type: Input,
+            args: [{ alias: 'subtype' }]
+        }], invalid: [{
+            type: Input,
+            args: [{ alias: 'invalid', transform: booleanAttribute }]
+        }], isFormula: [{
+            type: Input,
+            args: [{ alias: 'isFormula', transform: booleanAttribute }]
+        }], language: [{
+            type: Input,
+            args: [{ alias: 'language' }]
+        }], size: [{
+            type: Input,
+            args: [{ alias: 'size' }]
+        }], autofocus: [{
+            type: Input,
+            args: [{ alias: 'autofocus', transform: booleanAttribute }]
+        }], tabIndex: [{
+            type: Input,
+            args: [{ alias: 'tabIndex' }]
+        }], luzmoExpressionSelected: [{ type: i0.Output, args: ["luzmoExpressionSelected"] }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(LuzmoFilterExpressionPicker, { className: "LuzmoFilterExpressionPicker", filePath: "components/filter-expression-picker.ts", lineNumber: 16 }); })();

package/angular/esm/components/filter-item.d.ts

@@ -0,0 +1,63 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import '@luzmo/analytics-components-kit/filter-item';
+import type { LuzmoFilterItem as LuzmoFilterItemHostElement } from '@luzmo/analytics-components-kit/filter-item';
+import type { FilterParameter } from '@luzmo/analytics-components-kit/filters';
+import * as i0 from "@angular/core";
+export declare class LuzmoFilterItem implements OnChanges {
+    private readonly elementRef;
+    private readonly renderer;
+    private readonly destroyRef;
+    private readonly host;
+    private readonly listenerCleanup;
+    /** The underlying custom element instance. Use to call imperative methods. */
+    get nativeElement(): LuzmoFilterItemHostElement;
+    /** The API URL of the databroker */
+    apiUrl?: string;
+    /** The auth key of the databroker */
+    authKey?: string;
+    /** The auth token of the databroker */
+    authToken?: string;
+    /** The cache time of the databroker */
+    cacheTime?: number;
+    /** The language of the content */
+    contentLanguage?: string;
+    /** The time zone to use for the date picker */
+    timeZone?: string;
+    /** The dataset ids to fetch columns & formulas */
+    datasetIds?: string[];
+    /** The filter to display */
+    filter?: any;
+    /** Whether parameter-backed filter values can be created and selected. */
+    allowParameters?: boolean;
+    /** Consumer-owned parameter definitions available for selection. */
+    parameters?: FilterParameter[];
+    /** The language for UI labels. Supported values: 'en', 'nl', 'fr', 'de', 'es' */
+    language?: string;
+    /** The size of the element */
+    size?: 's' | 'm' | 'l' | 'xl';
+    /** Disable this control. It will not receive focus or events */
+    disabled?: boolean;
+    /** When this control is rendered, focus it automatically */
+    autofocus?: boolean;
+    /** The tab index to apply to this control. See general documentation about the tabindex HTML property */
+    tabIndex?: number;
+    /** Fired when any part of the filter changes; `detail.filter` holds the updated filter. */
+    readonly luzmoFilterChanged: import("@angular/core").OutputEmitterRef<CustomEvent<unknown>>;
+    constructor();
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * Forward a wrapper @Input to the underlying host element via Renderer2 so
+     * the wrapper stays compatible with non-DOM Angular platforms (SSR, tests).
+     * Unlike a "skip undefined" guard, this lets consumers reset values back to
+     * undefined / null by clearing their bindings.
+     */
+    private setHostProperty;
+    private bindEvents;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuzmoFilterItem, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuzmoFilterItem, "luzmo-filter-item", ["luzmoFilterItem"], { "apiUrl": { "alias": "apiUrl"; "required": false; }; "authKey": { "alias": "authKey"; "required": false; }; "authToken": { "alias": "authToken"; "required": false; }; "cacheTime": { "alias": "cacheTime"; "required": false; }; "contentLanguage": { "alias": "contentLanguage"; "required": false; }; "timeZone": { "alias": "timeZone"; "required": false; }; "datasetIds": { "alias": "datasetIds"; "required": false; }; "filter": { "alias": "filter"; "required": false; }; "allowParameters": { "alias": "allowParameters"; "required": false; }; "parameters": { "alias": "parameters"; "required": false; }; "language": { "alias": "language"; "required": false; }; "size": { "alias": "size"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "autofocus": { "alias": "autofocus"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; }, { "luzmoFilterChanged": "luzmoFilterChanged"; }, never, ["*"], true, never>;
+    static ngAcceptInputType_allowParameters: unknown;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_autofocus: unknown;
+}
+/** The underlying custom element type for LuzmoFilterItem */
+export type LuzmoFilterItemElement = LuzmoFilterItemHostElement;

package/angular/esm/components/filter-item.js

@@ -0,0 +1,187 @@
+import { booleanAttribute, ChangeDetectionStrategy, Component, DestroyRef, ElementRef, inject, Input, output, Renderer2 } from '@angular/core';
+import '@luzmo/analytics-components-kit/filter-item';
+import * as i0 from "@angular/core";
+const _c0 = ["*"];
+/**
+ * Angular wrapper component for <luzmo-filter-item>
+ */
+export class LuzmoFilterItem {
+    elementRef = inject(ElementRef);
+    renderer = inject(Renderer2);
+    destroyRef = inject(DestroyRef);
+    host = this.elementRef.nativeElement;
+    listenerCleanup = [];
+    /** The underlying custom element instance. Use to call imperative methods. */
+    get nativeElement() {
+        return this.host;
+    }
+    /** The API URL of the databroker */
+    apiUrl;
+    /** The auth key of the databroker */
+    authKey;
+    /** The auth token of the databroker */
+    authToken;
+    /** The cache time of the databroker */
+    cacheTime;
+    /** The language of the content */
+    contentLanguage;
+    /** The time zone to use for the date picker */
+    timeZone;
+    /** The dataset ids to fetch columns & formulas */
+    datasetIds;
+    /** The filter to display */
+    filter;
+    /** Whether parameter-backed filter values can be created and selected. */
+    allowParameters;
+    /** Consumer-owned parameter definitions available for selection. */
+    parameters;
+    /** The language for UI labels. Supported values: 'en', 'nl', 'fr', 'de', 'es' */
+    language;
+    /** The size of the element */
+    size;
+    /** Disable this control. It will not receive focus or events */
+    disabled;
+    /** When this control is rendered, focus it automatically */
+    autofocus;
+    /** The tab index to apply to this control. See general documentation about the tabindex HTML property */
+    tabIndex;
+    /** Fired when any part of the filter changes; `detail.filter` holds the updated filter. */
+    luzmoFilterChanged = output({ alias: 'luzmoFilterChanged' });
+    constructor() {
+        this.bindEvents();
+        this.destroyRef.onDestroy(() => {
+            for (const cleanup of this.listenerCleanup) {
+                cleanup();
+            }
+        });
+    }
+    ngOnChanges(changes) {
+        for (const key of Object.keys(changes)) {
+            switch (key) {
+                case 'apiUrl':
+                    this.setHostProperty('apiUrl', changes['apiUrl'].currentValue);
+                    break;
+                case 'authKey':
+                    this.setHostProperty('authKey', changes['authKey'].currentValue);
+                    break;
+                case 'authToken':
+                    this.setHostProperty('authToken', changes['authToken'].currentValue);
+                    break;
+                case 'cacheTime':
+                    this.setHostProperty('cacheTime', changes['cacheTime'].currentValue);
+                    break;
+                case 'contentLanguage':
+                    this.setHostProperty('contentLanguage', changes['contentLanguage'].currentValue);
+                    break;
+                case 'timeZone':
+                    this.setHostProperty('timeZone', changes['timeZone'].currentValue);
+                    break;
+                case 'datasetIds':
+                    this.setHostProperty('datasetIds', changes['datasetIds'].currentValue);
+                    break;
+                case 'filter':
+                    this.setHostProperty('filter', changes['filter'].currentValue);
+                    break;
+                case 'allowParameters':
+                    this.setHostProperty('allowParameters', changes['allowParameters'].currentValue);
+                    break;
+                case 'parameters':
+                    this.setHostProperty('parameters', changes['parameters'].currentValue);
+                    break;
+                case 'language':
+                    this.setHostProperty('language', changes['language'].currentValue);
+                    break;
+                case 'size':
+                    this.setHostProperty('size', changes['size'].currentValue);
+                    break;
+                case 'disabled':
+                    this.setHostProperty('disabled', changes['disabled'].currentValue);
+                    break;
+                case 'autofocus':
+                    this.setHostProperty('autofocus', changes['autofocus'].currentValue);
+                    break;
+                case 'tabIndex':
+                    this.setHostProperty('tabIndex', changes['tabIndex'].currentValue);
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+    /**
+     * Forward a wrapper @Input to the underlying host element via Renderer2 so
+     * the wrapper stays compatible with non-DOM Angular platforms (SSR, tests).
+     * Unlike a "skip undefined" guard, this lets consumers reset values back to
+     * undefined / null by clearing their bindings.
+     */
+    setHostProperty(key, value) {
+        this.renderer.setProperty(this.host, key, value);
+    }
+    bindEvents() {
+        this.listenerCleanup.push(this.renderer.listen(this.host, 'luzmo-filter-changed', (event) => {
+            const typed = event;
+            this.luzmoFilterChanged.emit(typed);
+        }));
+    }
+    static ɵfac = function LuzmoFilterItem_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || LuzmoFilterItem)(); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: LuzmoFilterItem, selectors: [["luzmo-filter-item"]], inputs: { apiUrl: "apiUrl", authKey: "authKey", authToken: "authToken", cacheTime: "cacheTime", contentLanguage: "contentLanguage", timeZone: "timeZone", datasetIds: "datasetIds", filter: "filter", allowParameters: [2, "allowParameters", "allowParameters", booleanAttribute], parameters: "parameters", language: "language", size: "size", disabled: [2, "disabled", "disabled", booleanAttribute], autofocus: [2, "autofocus", "autofocus", booleanAttribute], tabIndex: "tabIndex" }, outputs: { luzmoFilterChanged: "luzmoFilterChanged" }, exportAs: ["luzmoFilterItem"], features: [i0.ɵɵNgOnChangesFeature], ngContentSelectors: _c0, decls: 1, vars: 0, template: function LuzmoFilterItem_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2 });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LuzmoFilterItem, [{
+        type: Component,
+        args: [{
+                selector: 'luzmo-filter-item',
+                exportAs: 'luzmoFilterItem',
+                standalone: true,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content />'
+            }]
+    }], () => [], { apiUrl: [{
+            type: Input,
+            args: [{ alias: 'apiUrl' }]
+        }], authKey: [{
+            type: Input,
+            args: [{ alias: 'authKey' }]
+        }], authToken: [{
+            type: Input,
+            args: [{ alias: 'authToken' }]
+        }], cacheTime: [{
+            type: Input,
+            args: [{ alias: 'cacheTime' }]
+        }], contentLanguage: [{
+            type: Input,
+            args: [{ alias: 'contentLanguage' }]
+        }], timeZone: [{
+            type: Input,
+            args: [{ alias: 'timeZone' }]
+        }], datasetIds: [{
+            type: Input,
+            args: [{ alias: 'datasetIds' }]
+        }], filter: [{
+            type: Input,
+            args: [{ alias: 'filter' }]
+        }], allowParameters: [{
+            type: Input,
+            args: [{ alias: 'allowParameters', transform: booleanAttribute }]
+        }], parameters: [{
+            type: Input,
+            args: [{ alias: 'parameters' }]
+        }], language: [{
+            type: Input,
+            args: [{ alias: 'language' }]
+        }], size: [{
+            type: Input,
+            args: [{ alias: 'size' }]
+        }], disabled: [{
+            type: Input,
+            args: [{ alias: 'disabled', transform: booleanAttribute }]
+        }], autofocus: [{
+            type: Input,
+            args: [{ alias: 'autofocus', transform: booleanAttribute }]
+        }], tabIndex: [{
+            type: Input,
+            args: [{ alias: 'tabIndex' }]
+        }], luzmoFilterChanged: [{ type: i0.Output, args: ["luzmoFilterChanged"] }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(LuzmoFilterItem, { className: "LuzmoFilterItem", filePath: "components/filter-item.ts", lineNumber: 16 }); })();

package/angular/esm/components/filter-parameter-picker.d.ts

@@ -0,0 +1,56 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import '@luzmo/analytics-components-kit/filter-parameter-picker';
+import type { LuzmoFilterParameterPicker as LuzmoFilterParameterPickerHostElement, FilterParameterPickerEventDetail } from '@luzmo/analytics-components-kit/filter-parameter-picker';
+import type { FilterParameterType } from '@luzmo/analytics-components-kit/filters';
+import type { ItemFilterParameterDefinition } from '@luzmo/dashboard-contents-types';
+import * as i0 from "@angular/core";
+export type { FilterParameterPickerEventDetail } from '@luzmo/analytics-components-kit/filter-parameter-picker';
+export declare class LuzmoFilterParameterPicker implements OnChanges {
+    private readonly elementRef;
+    private readonly renderer;
+    private readonly destroyRef;
+    private readonly host;
+    private readonly listenerCleanup;
+    /** The underlying custom element instance. Use to call imperative methods. */
+    get nativeElement(): LuzmoFilterParameterPickerHostElement;
+    /** Parameter definitions available for selection. */
+    parameters?: ItemFilterParameterDefinition[];
+    /** Parameter types compatible with the active field and expression. */
+    allowedTypes?: FilterParameterType[];
+    /** The parameter currently attached to the filter. */
+    selectedParameter?: ItemFilterParameterDefinition;
+    /** The current literal filter value used as the default for a new parameter. */
+    currentValue?: unknown;
+    /** Whether parameter selection is disabled. */
+    disabled?: boolean;
+    /** The language for UI labels. Supported values: 'en', 'nl', 'fr', 'de', 'es' */
+    language?: string;
+    /** The size of the element */
+    size?: 's' | 'm' | 'l' | 'xl';
+    /** When this control is rendered, focus it automatically */
+    autofocus?: boolean;
+    /** The tab index to apply to this control. See general documentation about the tabindex HTML property */
+    tabIndex?: number;
+    /** Fired when a parameter is selected. */
+    readonly luzmoParameterSelected: import("@angular/core").OutputEmitterRef<CustomEvent<FilterParameterPickerEventDetail>>;
+    /** Fired when a parameter is created. */
+    readonly luzmoParameterCreated: import("@angular/core").OutputEmitterRef<CustomEvent<FilterParameterPickerEventDetail>>;
+    /** Fired when a parameter is detached from the filter. */
+    readonly luzmoParameterRemoved: import("@angular/core").OutputEmitterRef<CustomEvent<FilterParameterPickerEventDetail>>;
+    constructor();
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * Forward a wrapper @Input to the underlying host element via Renderer2 so
+     * the wrapper stays compatible with non-DOM Angular platforms (SSR, tests).
+     * Unlike a "skip undefined" guard, this lets consumers reset values back to
+     * undefined / null by clearing their bindings.
+     */
+    private setHostProperty;
+    private bindEvents;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuzmoFilterParameterPicker, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuzmoFilterParameterPicker, "luzmo-filter-parameter-picker", ["luzmoFilterParameterPicker"], { "parameters": { "alias": "parameters"; "required": false; }; "allowedTypes": { "alias": "allowedTypes"; "required": false; }; "selectedParameter": { "alias": "selectedParameter"; "required": false; }; "currentValue": { "alias": "currentValue"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "language": { "alias": "language"; "required": false; }; "size": { "alias": "size"; "required": false; }; "autofocus": { "alias": "autofocus"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; }, { "luzmoParameterSelected": "luzmoParameterSelected"; "luzmoParameterCreated": "luzmoParameterCreated"; "luzmoParameterRemoved": "luzmoParameterRemoved"; }, never, ["*"], true, never>;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_autofocus: unknown;
+}
+/** The underlying custom element type for LuzmoFilterParameterPicker */
+export type LuzmoFilterParameterPickerElement = LuzmoFilterParameterPickerHostElement;

package/angular/esm/components/filter-parameter-picker.js

@@ -0,0 +1,151 @@
+import { booleanAttribute, ChangeDetectionStrategy, Component, DestroyRef, ElementRef, inject, Input, output, Renderer2 } from '@angular/core';
+import '@luzmo/analytics-components-kit/filter-parameter-picker';
+import * as i0 from "@angular/core";
+const _c0 = ["*"];
+/**
+ * Angular wrapper component for <luzmo-filter-parameter-picker>
+ */
+export class LuzmoFilterParameterPicker {
+    elementRef = inject(ElementRef);
+    renderer = inject(Renderer2);
+    destroyRef = inject(DestroyRef);
+    host = this.elementRef.nativeElement;
+    listenerCleanup = [];
+    /** The underlying custom element instance. Use to call imperative methods. */
+    get nativeElement() {
+        return this.host;
+    }
+    /** Parameter definitions available for selection. */
+    parameters;
+    /** Parameter types compatible with the active field and expression. */
+    allowedTypes;
+    /** The parameter currently attached to the filter. */
+    selectedParameter;
+    /** The current literal filter value used as the default for a new parameter. */
+    currentValue;
+    /** Whether parameter selection is disabled. */
+    disabled;
+    /** The language for UI labels. Supported values: 'en', 'nl', 'fr', 'de', 'es' */
+    language;
+    /** The size of the element */
+    size;
+    /** When this control is rendered, focus it automatically */
+    autofocus;
+    /** The tab index to apply to this control. See general documentation about the tabindex HTML property */
+    tabIndex;
+    /** Fired when a parameter is selected. */
+    luzmoParameterSelected = output({ alias: 'luzmoParameterSelected' });
+    /** Fired when a parameter is created. */
+    luzmoParameterCreated = output({ alias: 'luzmoParameterCreated' });
+    /** Fired when a parameter is detached from the filter. */
+    luzmoParameterRemoved = output({ alias: 'luzmoParameterRemoved' });
+    constructor() {
+        this.bindEvents();
+        this.destroyRef.onDestroy(() => {
+            for (const cleanup of this.listenerCleanup) {
+                cleanup();
+            }
+        });
+    }
+    ngOnChanges(changes) {
+        for (const key of Object.keys(changes)) {
+            switch (key) {
+                case 'parameters':
+                    this.setHostProperty('parameters', changes['parameters'].currentValue);
+                    break;
+                case 'allowedTypes':
+                    this.setHostProperty('allowedTypes', changes['allowedTypes'].currentValue);
+                    break;
+                case 'selectedParameter':
+                    this.setHostProperty('selectedParameter', changes['selectedParameter'].currentValue);
+                    break;
+                case 'currentValue':
+                    this.setHostProperty('currentValue', changes['currentValue'].currentValue);
+                    break;
+                case 'disabled':
+                    this.setHostProperty('disabled', changes['disabled'].currentValue);
+                    break;
+                case 'language':
+                    this.setHostProperty('language', changes['language'].currentValue);
+                    break;
+                case 'size':
+                    this.setHostProperty('size', changes['size'].currentValue);
+                    break;
+                case 'autofocus':
+                    this.setHostProperty('autofocus', changes['autofocus'].currentValue);
+                    break;
+                case 'tabIndex':
+                    this.setHostProperty('tabIndex', changes['tabIndex'].currentValue);
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+    /**
+     * Forward a wrapper @Input to the underlying host element via Renderer2 so
+     * the wrapper stays compatible with non-DOM Angular platforms (SSR, tests).
+     * Unlike a "skip undefined" guard, this lets consumers reset values back to
+     * undefined / null by clearing their bindings.
+     */
+    setHostProperty(key, value) {
+        this.renderer.setProperty(this.host, key, value);
+    }
+    bindEvents() {
+        this.listenerCleanup.push(this.renderer.listen(this.host, 'luzmo-parameter-selected', (event) => {
+            const typed = event;
+            this.luzmoParameterSelected.emit(typed);
+        }));
+        this.listenerCleanup.push(this.renderer.listen(this.host, 'luzmo-parameter-created', (event) => {
+            const typed = event;
+            this.luzmoParameterCreated.emit(typed);
+        }));
+        this.listenerCleanup.push(this.renderer.listen(this.host, 'luzmo-parameter-removed', (event) => {
+            const typed = event;
+            this.luzmoParameterRemoved.emit(typed);
+        }));
+    }
+    static ɵfac = function LuzmoFilterParameterPicker_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || LuzmoFilterParameterPicker)(); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: LuzmoFilterParameterPicker, selectors: [["luzmo-filter-parameter-picker"]], inputs: { parameters: "parameters", allowedTypes: "allowedTypes", selectedParameter: "selectedParameter", currentValue: "currentValue", disabled: [2, "disabled", "disabled", booleanAttribute], language: "language", size: "size", autofocus: [2, "autofocus", "autofocus", booleanAttribute], tabIndex: "tabIndex" }, outputs: { luzmoParameterSelected: "luzmoParameterSelected", luzmoParameterCreated: "luzmoParameterCreated", luzmoParameterRemoved: "luzmoParameterRemoved" }, exportAs: ["luzmoFilterParameterPicker"], features: [i0.ɵɵNgOnChangesFeature], ngContentSelectors: _c0, decls: 1, vars: 0, template: function LuzmoFilterParameterPicker_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2 });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LuzmoFilterParameterPicker, [{
+        type: Component,
+        args: [{
+                selector: 'luzmo-filter-parameter-picker',
+                exportAs: 'luzmoFilterParameterPicker',
+                standalone: true,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content />'
+            }]
+    }], () => [], { parameters: [{
+            type: Input,
+            args: [{ alias: 'parameters' }]
+        }], allowedTypes: [{
+            type: Input,
+            args: [{ alias: 'allowedTypes' }]
+        }], selectedParameter: [{
+            type: Input,
+            args: [{ alias: 'selectedParameter' }]
+        }], currentValue: [{
+            type: Input,
+            args: [{ alias: 'currentValue' }]
+        }], disabled: [{
+            type: Input,
+            args: [{ alias: 'disabled', transform: booleanAttribute }]
+        }], language: [{
+            type: Input,
+            args: [{ alias: 'language' }]
+        }], size: [{
+            type: Input,
+            args: [{ alias: 'size' }]
+        }], autofocus: [{
+            type: Input,
+            args: [{ alias: 'autofocus', transform: booleanAttribute }]
+        }], tabIndex: [{
+            type: Input,
+            args: [{ alias: 'tabIndex' }]
+        }], luzmoParameterSelected: [{ type: i0.Output, args: ["luzmoParameterSelected"] }], luzmoParameterCreated: [{ type: i0.Output, args: ["luzmoParameterCreated"] }], luzmoParameterRemoved: [{ type: i0.Output, args: ["luzmoParameterRemoved"] }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(LuzmoFilterParameterPicker, { className: "LuzmoFilterParameterPicker", filePath: "components/filter-parameter-picker.ts", lineNumber: 18 }); })();