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

package/angular/esm/components/dataset-selector-row.js

@@ -0,0 +1,197 @@
+import { booleanAttribute, ChangeDetectionStrategy, Component, DestroyRef, ElementRef, inject, Input, output, Renderer2 } from '@angular/core';
+import '@luzmo/analytics-components-kit/dataset-selector-row';
+import * as i0 from "@angular/core";
+const _c0 = ["*"];
+/**
+ * Angular wrapper component for <luzmo-dataset-selector-row>
+ */
+export class LuzmoDatasetSelectorRow {
+    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;
+    }
+    /** Array of selected datasets */
+    selectedDatasets;
+    /** The agent the chat is scoped to, or null */
+    selectedAgent;
+    /** When true, hides the Agents section and ignores `selectedAgent` */
+    hideAgents;
+    /** Accessible label and hover tooltip text for the search trigger */
+    buttonLabel;
+    /** Auth key for DataBroker authentication */
+    authKey;
+    /** Auth token for DataBroker authentication */
+    authToken;
+    /** API URL for DataBroker */
+    apiUrl;
+    /** The URL of the app server for thumbnails and assets */
+    appServer;
+    /** When true, shows public datasets alongside the user's other datasets. */
+    includePublicDatasets;
+    /** Alias for includePublicDatasets. */
+    flagOpendata;
+    /** When true, disables all interactions: disables the add button, removes dataset pill delete buttons, and makes tags non-interactive */
+    disabled;
+    /** When true, disables dataset search and removal while leaving informational controls interactive. */
+    disableDatasetModification;
+    /** When true, hides dataset icons in selected tags and search options */
+    hideDatasetIcons;
+    /** Maximum number of selected dataset tags shown before the overflow control; unset shows all tags. */
+    maxVisibleSelectedDatasets;
+    /** Fired when an agent is selected */
+    luzmoAgentSelected = output({ alias: 'luzmoAgentSelected' });
+    /** Fired when a dataset is selected */
+    datasetSelected = output({ alias: 'datasetSelected' });
+    /** Fired when a dataset is removed */
+    datasetRemoved = output({ alias: 'datasetRemoved' });
+    /** Fired when the selected agent is removed */
+    luzmoAgentRemoved = output({ alias: 'luzmoAgentRemoved' });
+    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 'selectedDatasets':
+                    this.setHostProperty('selectedDatasets', changes['selectedDatasets'].currentValue);
+                    break;
+                case 'selectedAgent':
+                    this.setHostProperty('selectedAgent', changes['selectedAgent'].currentValue);
+                    break;
+                case 'hideAgents':
+                    this.setHostProperty('hideAgents', changes['hideAgents'].currentValue);
+                    break;
+                case 'buttonLabel':
+                    this.setHostProperty('buttonLabel', changes['buttonLabel'].currentValue);
+                    break;
+                case 'authKey':
+                    this.setHostProperty('authKey', changes['authKey'].currentValue);
+                    break;
+                case 'authToken':
+                    this.setHostProperty('authToken', changes['authToken'].currentValue);
+                    break;
+                case 'apiUrl':
+                    this.setHostProperty('apiUrl', changes['apiUrl'].currentValue);
+                    break;
+                case 'appServer':
+                    this.setHostProperty('appServer', changes['appServer'].currentValue);
+                    break;
+                case 'includePublicDatasets':
+                    this.setHostProperty('includePublicDatasets', changes['includePublicDatasets'].currentValue);
+                    break;
+                case 'flagOpendata':
+                    this.setHostProperty('flagOpendata', changes['flagOpendata'].currentValue);
+                    break;
+                case 'disabled':
+                    this.setHostProperty('disabled', changes['disabled'].currentValue);
+                    break;
+                case 'disableDatasetModification':
+                    this.setHostProperty('disableDatasetModification', changes['disableDatasetModification'].currentValue);
+                    break;
+                case 'hideDatasetIcons':
+                    this.setHostProperty('hideDatasetIcons', changes['hideDatasetIcons'].currentValue);
+                    break;
+                case 'maxVisibleSelectedDatasets':
+                    this.setHostProperty('maxVisibleSelectedDatasets', changes['maxVisibleSelectedDatasets'].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-agent-selected', (event) => {
+            const typed = event;
+            this.luzmoAgentSelected.emit(typed);
+        }));
+        this.listenerCleanup.push(this.renderer.listen(this.host, 'dataset-selected', (event) => {
+            const typed = event;
+            this.datasetSelected.emit(typed);
+        }));
+        this.listenerCleanup.push(this.renderer.listen(this.host, 'dataset-removed', (event) => {
+            const typed = event;
+            this.datasetRemoved.emit(typed);
+        }));
+        this.listenerCleanup.push(this.renderer.listen(this.host, 'luzmo-agent-removed', (event) => {
+            const typed = event;
+            this.luzmoAgentRemoved.emit(typed);
+        }));
+    }
+    static ɵfac = function LuzmoDatasetSelectorRow_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || LuzmoDatasetSelectorRow)(); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: LuzmoDatasetSelectorRow, selectors: [["luzmo-dataset-selector-row"]], inputs: { selectedDatasets: "selectedDatasets", selectedAgent: "selectedAgent", hideAgents: [2, "hideAgents", "hideAgents", booleanAttribute], buttonLabel: "buttonLabel", authKey: "authKey", authToken: "authToken", apiUrl: "apiUrl", appServer: "appServer", includePublicDatasets: [2, "includePublicDatasets", "includePublicDatasets", booleanAttribute], flagOpendata: [2, "flagOpendata", "flagOpendata", booleanAttribute], disabled: [2, "disabled", "disabled", booleanAttribute], disableDatasetModification: [2, "disableDatasetModification", "disableDatasetModification", booleanAttribute], hideDatasetIcons: [2, "hideDatasetIcons", "hideDatasetIcons", booleanAttribute], maxVisibleSelectedDatasets: "maxVisibleSelectedDatasets" }, outputs: { luzmoAgentSelected: "luzmoAgentSelected", datasetSelected: "datasetSelected", datasetRemoved: "datasetRemoved", luzmoAgentRemoved: "luzmoAgentRemoved" }, exportAs: ["luzmoDatasetSelectorRow"], features: [i0.ɵɵNgOnChangesFeature], ngContentSelectors: _c0, decls: 1, vars: 0, template: function LuzmoDatasetSelectorRow_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2 });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LuzmoDatasetSelectorRow, [{
+        type: Component,
+        args: [{
+                selector: 'luzmo-dataset-selector-row',
+                exportAs: 'luzmoDatasetSelectorRow',
+                standalone: true,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content />'
+            }]
+    }], () => [], { selectedDatasets: [{
+            type: Input,
+            args: [{ alias: 'selectedDatasets' }]
+        }], selectedAgent: [{
+            type: Input,
+            args: [{ alias: 'selectedAgent' }]
+        }], hideAgents: [{
+            type: Input,
+            args: [{ alias: 'hideAgents', transform: booleanAttribute }]
+        }], buttonLabel: [{
+            type: Input,
+            args: [{ alias: 'buttonLabel' }]
+        }], authKey: [{
+            type: Input,
+            args: [{ alias: 'authKey' }]
+        }], authToken: [{
+            type: Input,
+            args: [{ alias: 'authToken' }]
+        }], apiUrl: [{
+            type: Input,
+            args: [{ alias: 'apiUrl' }]
+        }], appServer: [{
+            type: Input,
+            args: [{ alias: 'appServer' }]
+        }], includePublicDatasets: [{
+            type: Input,
+            args: [{ alias: 'includePublicDatasets', transform: booleanAttribute }]
+        }], flagOpendata: [{
+            type: Input,
+            args: [{ alias: 'flagOpendata', transform: booleanAttribute }]
+        }], disabled: [{
+            type: Input,
+            args: [{ alias: 'disabled', transform: booleanAttribute }]
+        }], disableDatasetModification: [{
+            type: Input,
+            args: [{ alias: 'disableDatasetModification', transform: booleanAttribute }]
+        }], hideDatasetIcons: [{
+            type: Input,
+            args: [{ alias: 'hideDatasetIcons', transform: booleanAttribute }]
+        }], maxVisibleSelectedDatasets: [{
+            type: Input,
+            args: [{ alias: 'maxVisibleSelectedDatasets' }]
+        }], luzmoAgentSelected: [{ type: i0.Output, args: ["luzmoAgentSelected"] }], datasetSelected: [{ type: i0.Output, args: ["datasetSelected"] }], datasetRemoved: [{ type: i0.Output, args: ["datasetRemoved"] }], luzmoAgentRemoved: [{ type: i0.Output, args: ["luzmoAgentRemoved"] }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(LuzmoDatasetSelectorRow, { className: "LuzmoDatasetSelectorRow", filePath: "components/dataset-selector-row.ts", lineNumber: 16 }); })();

package/angular/esm/components/display-settings-binning.d.ts

@@ -0,0 +1,37 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import '@luzmo/analytics-components-kit/display-settings-binning';
+import type { LuzmoDisplaySettingsBinning as LuzmoDisplaySettingsBinningHostElement, DisplaySettingsSlotContentChangedEventDetail } from '@luzmo/analytics-components-kit/display-settings-binning';
+import type { GenericSlotContent } from '@luzmo/dashboard-contents-types';
+import * as i0 from "@angular/core";
+export type { DisplaySettingsSlotContentChangedEventDetail } from '@luzmo/analytics-components-kit/display-settings-binning';
+export declare class LuzmoDisplaySettingsBinning 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(): LuzmoDisplaySettingsBinningHostElement;
+    /** The slot content whose binning configuration (enabled state and bin width) is edited. */
+    slotContent?: GenericSlotContent;
+    /** The language for UI labels. Supported values: 'en', 'nl', 'fr', 'de', 'es' */
+    language?: string;
+    /** The size of the element */
+    size?: 's' | 'm' | 'l' | 'xl';
+    /** Event that is fired when the slot content is changed */
+    readonly luzmoSlotContentChanged: import("@angular/core").OutputEmitterRef<CustomEvent<DisplaySettingsSlotContentChangedEventDetail>>;
+    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<LuzmoDisplaySettingsBinning, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuzmoDisplaySettingsBinning, "luzmo-display-settings-binning", ["luzmoDisplaySettingsBinning"], { "slotContent": { "alias": "slotContent"; "required": false; }; "language": { "alias": "language"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, { "luzmoSlotContentChanged": "luzmoSlotContentChanged"; }, never, ["*"], true, never>;
+}
+/** The underlying custom element type for LuzmoDisplaySettingsBinning */
+export type LuzmoDisplaySettingsBinningElement = LuzmoDisplaySettingsBinningHostElement;

package/angular/esm/components/display-settings-binning.js

@@ -0,0 +1,91 @@
+import { ChangeDetectionStrategy, Component, DestroyRef, ElementRef, inject, Input, output, Renderer2 } from '@angular/core';
+import '@luzmo/analytics-components-kit/display-settings-binning';
+import * as i0 from "@angular/core";
+const _c0 = ["*"];
+/**
+ * Angular wrapper component for <luzmo-display-settings-binning>
+ */
+export class LuzmoDisplaySettingsBinning {
+    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 slot content whose binning configuration (enabled state and bin width) is edited. */
+    slotContent;
+    /** The language for UI labels. Supported values: 'en', 'nl', 'fr', 'de', 'es' */
+    language;
+    /** The size of the element */
+    size;
+    /** Event that is fired when the slot content is changed */
+    luzmoSlotContentChanged = output({ alias: 'luzmoSlotContentChanged' });
+    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 'slotContent':
+                    this.setHostProperty('slotContent', changes['slotContent'].currentValue);
+                    break;
+                case 'language':
+                    this.setHostProperty('language', changes['language'].currentValue);
+                    break;
+                case 'size':
+                    this.setHostProperty('size', changes['size'].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-slot-content-changed', (event) => {
+            const typed = event;
+            this.luzmoSlotContentChanged.emit(typed);
+        }));
+    }
+    static ɵfac = function LuzmoDisplaySettingsBinning_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || LuzmoDisplaySettingsBinning)(); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: LuzmoDisplaySettingsBinning, selectors: [["luzmo-display-settings-binning"]], inputs: { slotContent: "slotContent", language: "language", size: "size" }, outputs: { luzmoSlotContentChanged: "luzmoSlotContentChanged" }, exportAs: ["luzmoDisplaySettingsBinning"], features: [i0.ɵɵNgOnChangesFeature], ngContentSelectors: _c0, decls: 1, vars: 0, template: function LuzmoDisplaySettingsBinning_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2 });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LuzmoDisplaySettingsBinning, [{
+        type: Component,
+        args: [{
+                selector: 'luzmo-display-settings-binning',
+                exportAs: 'luzmoDisplaySettingsBinning',
+                standalone: true,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content />'
+            }]
+    }], () => [], { slotContent: [{
+            type: Input,
+            args: [{ alias: 'slotContent' }]
+        }], language: [{
+            type: Input,
+            args: [{ alias: 'language' }]
+        }], size: [{
+            type: Input,
+            args: [{ alias: 'size' }]
+        }], luzmoSlotContentChanged: [{ type: i0.Output, args: ["luzmoSlotContentChanged"] }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(LuzmoDisplaySettingsBinning, { className: "LuzmoDisplaySettingsBinning", filePath: "components/display-settings-binning.ts", lineNumber: 17 }); })();

package/angular/esm/components/display-settings-datetime.d.ts

@@ -0,0 +1,40 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import '@luzmo/analytics-components-kit/display-settings-datetime';
+import type { LuzmoDisplaySettingsDatetime as LuzmoDisplaySettingsDatetimeHostElement, DisplaySettingsSlotContentChangedEventDetail } from '@luzmo/analytics-components-kit/display-settings-datetime';
+import type { ElementSize } from '@luzmo/analytics-components-kit/types';
+import type { GenericSlotContent } from '@luzmo/dashboard-contents-types';
+import * as i0 from "@angular/core";
+export type { DisplaySettingsSlotContentChangedEventDetail } from '@luzmo/analytics-components-kit/display-settings-datetime';
+export declare class LuzmoDisplaySettingsDatetime 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(): LuzmoDisplaySettingsDatetimeHostElement;
+    /** The language to use for locale-aware formatting */
+    contentLanguage?: string;
+    /** The size variant of the datetime settings controls (`s`, `m`, `l`, `xl`). */
+    size?: ElementSize;
+    /** The slot content whose datetime display mode and format options are edited. */
+    slotContent?: GenericSlotContent;
+    /** The language for UI labels. Supported values: 'en', 'nl', 'fr', 'de', 'es' */
+    language?: string;
+    /** Event that is fired when the slot content is changed */
+    readonly luzmoSlotContentChanged: import("@angular/core").OutputEmitterRef<CustomEvent<DisplaySettingsSlotContentChangedEventDetail>>;
+    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<LuzmoDisplaySettingsDatetime, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuzmoDisplaySettingsDatetime, "luzmo-display-settings-datetime", ["luzmoDisplaySettingsDatetime"], { "contentLanguage": { "alias": "contentLanguage"; "required": false; }; "size": { "alias": "size"; "required": false; }; "slotContent": { "alias": "slotContent"; "required": false; }; "language": { "alias": "language"; "required": false; }; }, { "luzmoSlotContentChanged": "luzmoSlotContentChanged"; }, never, ["*"], true, never>;
+}
+/** The underlying custom element type for LuzmoDisplaySettingsDatetime */
+export type LuzmoDisplaySettingsDatetimeElement = LuzmoDisplaySettingsDatetimeHostElement;

package/angular/esm/components/display-settings-datetime.js

@@ -0,0 +1,99 @@
+import { ChangeDetectionStrategy, Component, DestroyRef, ElementRef, inject, Input, output, Renderer2 } from '@angular/core';
+import '@luzmo/analytics-components-kit/display-settings-datetime';
+import * as i0 from "@angular/core";
+const _c0 = ["*"];
+/**
+ * Angular wrapper component for <luzmo-display-settings-datetime>
+ */
+export class LuzmoDisplaySettingsDatetime {
+    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 language to use for locale-aware formatting */
+    contentLanguage;
+    /** The size variant of the datetime settings controls (`s`, `m`, `l`, `xl`). */
+    size;
+    /** The slot content whose datetime display mode and format options are edited. */
+    slotContent;
+    /** The language for UI labels. Supported values: 'en', 'nl', 'fr', 'de', 'es' */
+    language;
+    /** Event that is fired when the slot content is changed */
+    luzmoSlotContentChanged = output({ alias: 'luzmoSlotContentChanged' });
+    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 'contentLanguage':
+                    this.setHostProperty('contentLanguage', changes['contentLanguage'].currentValue);
+                    break;
+                case 'size':
+                    this.setHostProperty('size', changes['size'].currentValue);
+                    break;
+                case 'slotContent':
+                    this.setHostProperty('slotContent', changes['slotContent'].currentValue);
+                    break;
+                case 'language':
+                    this.setHostProperty('language', changes['language'].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-slot-content-changed', (event) => {
+            const typed = event;
+            this.luzmoSlotContentChanged.emit(typed);
+        }));
+    }
+    static ɵfac = function LuzmoDisplaySettingsDatetime_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || LuzmoDisplaySettingsDatetime)(); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: LuzmoDisplaySettingsDatetime, selectors: [["luzmo-display-settings-datetime"]], inputs: { contentLanguage: "contentLanguage", size: "size", slotContent: "slotContent", language: "language" }, outputs: { luzmoSlotContentChanged: "luzmoSlotContentChanged" }, exportAs: ["luzmoDisplaySettingsDatetime"], features: [i0.ɵɵNgOnChangesFeature], ngContentSelectors: _c0, decls: 1, vars: 0, template: function LuzmoDisplaySettingsDatetime_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2 });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LuzmoDisplaySettingsDatetime, [{
+        type: Component,
+        args: [{
+                selector: 'luzmo-display-settings-datetime',
+                exportAs: 'luzmoDisplaySettingsDatetime',
+                standalone: true,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content />'
+            }]
+    }], () => [], { contentLanguage: [{
+            type: Input,
+            args: [{ alias: 'contentLanguage' }]
+        }], size: [{
+            type: Input,
+            args: [{ alias: 'size' }]
+        }], slotContent: [{
+            type: Input,
+            args: [{ alias: 'slotContent' }]
+        }], language: [{
+            type: Input,
+            args: [{ alias: 'language' }]
+        }], luzmoSlotContentChanged: [{ type: i0.Output, args: ["luzmoSlotContentChanged"] }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(LuzmoDisplaySettingsDatetime, { className: "LuzmoDisplaySettingsDatetime", filePath: "components/display-settings-datetime.ts", lineNumber: 18 }); })();

package/angular/esm/components/display-settings-grand-totals.d.ts

@@ -0,0 +1,37 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import '@luzmo/analytics-components-kit/display-settings-grand-totals';
+import type { LuzmoDisplaySettingsGrandTotals as LuzmoDisplaySettingsGrandTotalsHostElement, DisplaySettingsSlotContentChangedEventDetail } from '@luzmo/analytics-components-kit/display-settings-grand-totals';
+import type { GenericSlotContent } from '@luzmo/dashboard-contents-types';
+import * as i0 from "@angular/core";
+export type { DisplaySettingsSlotContentChangedEventDetail } from '@luzmo/analytics-components-kit/display-settings-grand-totals';
+export declare class LuzmoDisplaySettingsGrandTotals 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(): LuzmoDisplaySettingsGrandTotalsHostElement;
+    /** The slotContent that is passed to the settings */
+    slotContent?: GenericSlotContent;
+    /** The language for UI labels. Supported values: 'en', 'nl', 'fr', 'de', 'es' */
+    language?: string;
+    /** The size of the element */
+    size?: 's' | 'm' | 'l' | 'xl';
+    /** Event that is fired when the slot content is changed */
+    readonly luzmoSlotContentChanged: import("@angular/core").OutputEmitterRef<CustomEvent<DisplaySettingsSlotContentChangedEventDetail>>;
+    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<LuzmoDisplaySettingsGrandTotals, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuzmoDisplaySettingsGrandTotals, "luzmo-display-settings-grand-totals", ["luzmoDisplaySettingsGrandTotals"], { "slotContent": { "alias": "slotContent"; "required": false; }; "language": { "alias": "language"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, { "luzmoSlotContentChanged": "luzmoSlotContentChanged"; }, never, ["*"], true, never>;
+}
+/** The underlying custom element type for LuzmoDisplaySettingsGrandTotals */
+export type LuzmoDisplaySettingsGrandTotalsElement = LuzmoDisplaySettingsGrandTotalsHostElement;

package/angular/esm/components/display-settings-grand-totals.js

@@ -0,0 +1,91 @@
+import { ChangeDetectionStrategy, Component, DestroyRef, ElementRef, inject, Input, output, Renderer2 } from '@angular/core';
+import '@luzmo/analytics-components-kit/display-settings-grand-totals';
+import * as i0 from "@angular/core";
+const _c0 = ["*"];
+/**
+ * Angular wrapper component for <luzmo-display-settings-grand-totals>
+ */
+export class LuzmoDisplaySettingsGrandTotals {
+    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 slotContent that is passed to the settings */
+    slotContent;
+    /** The language for UI labels. Supported values: 'en', 'nl', 'fr', 'de', 'es' */
+    language;
+    /** The size of the element */
+    size;
+    /** Event that is fired when the slot content is changed */
+    luzmoSlotContentChanged = output({ alias: 'luzmoSlotContentChanged' });
+    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 'slotContent':
+                    this.setHostProperty('slotContent', changes['slotContent'].currentValue);
+                    break;
+                case 'language':
+                    this.setHostProperty('language', changes['language'].currentValue);
+                    break;
+                case 'size':
+                    this.setHostProperty('size', changes['size'].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-slot-content-changed', (event) => {
+            const typed = event;
+            this.luzmoSlotContentChanged.emit(typed);
+        }));
+    }
+    static ɵfac = function LuzmoDisplaySettingsGrandTotals_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || LuzmoDisplaySettingsGrandTotals)(); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: LuzmoDisplaySettingsGrandTotals, selectors: [["luzmo-display-settings-grand-totals"]], inputs: { slotContent: "slotContent", language: "language", size: "size" }, outputs: { luzmoSlotContentChanged: "luzmoSlotContentChanged" }, exportAs: ["luzmoDisplaySettingsGrandTotals"], features: [i0.ɵɵNgOnChangesFeature], ngContentSelectors: _c0, decls: 1, vars: 0, template: function LuzmoDisplaySettingsGrandTotals_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2 });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LuzmoDisplaySettingsGrandTotals, [{
+        type: Component,
+        args: [{
+                selector: 'luzmo-display-settings-grand-totals',
+                exportAs: 'luzmoDisplaySettingsGrandTotals',
+                standalone: true,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content />'
+            }]
+    }], () => [], { slotContent: [{
+            type: Input,
+            args: [{ alias: 'slotContent' }]
+        }], language: [{
+            type: Input,
+            args: [{ alias: 'language' }]
+        }], size: [{
+            type: Input,
+            args: [{ alias: 'size' }]
+        }], luzmoSlotContentChanged: [{ type: i0.Output, args: ["luzmoSlotContentChanged"] }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(LuzmoDisplaySettingsGrandTotals, { className: "LuzmoDisplaySettingsGrandTotals", filePath: "components/display-settings-grand-totals.ts", lineNumber: 17 }); })();

package/angular/esm/components/display-settings-numeric.d.ts

@@ -0,0 +1,45 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import '@luzmo/analytics-components-kit/display-settings-numeric';
+import type { LuzmoDisplaySettingsNumeric as LuzmoDisplaySettingsNumericHostElement, DisplaySettingsSlotContentChangedEventDetail } from '@luzmo/analytics-components-kit/display-settings-numeric';
+import type { MeasureColumnsItem } from '@luzmo/analytics-components-kit/slot-menu';
+import * as i0 from "@angular/core";
+export type { DisplaySettingsSlotContentChangedEventDetail } from '@luzmo/analytics-components-kit/display-settings-numeric';
+export declare class LuzmoDisplaySettingsNumeric 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(): LuzmoDisplaySettingsNumericHostElement;
+    /** The slotContent that is passed to the settings */
+    slotContent?: any;
+    /** The list of measure columns grouped by dataset that can be used for the rate aggregation. Shape: [{ datasetId, datasetName, columns: Column[] }] */
+    measureColumns?: MeasureColumnsItem[];
+    /** Whether or not to show the aggregation options */
+    isAggregationDisabled?: boolean;
+    /** Whether or not to show the cumulative sum options */
+    isCumulativeSumEnabled?: 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';
+    /** Event that is fired when the slot content is changed */
+    readonly luzmoSlotContentChanged: import("@angular/core").OutputEmitterRef<CustomEvent<DisplaySettingsSlotContentChangedEventDetail>>;
+    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<LuzmoDisplaySettingsNumeric, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuzmoDisplaySettingsNumeric, "luzmo-display-settings-numeric", ["luzmoDisplaySettingsNumeric"], { "slotContent": { "alias": "slotContent"; "required": false; }; "measureColumns": { "alias": "measureColumns"; "required": false; }; "isAggregationDisabled": { "alias": "isAggregationDisabled"; "required": false; }; "isCumulativeSumEnabled": { "alias": "isCumulativeSumEnabled"; "required": false; }; "language": { "alias": "language"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, { "luzmoSlotContentChanged": "luzmoSlotContentChanged"; }, never, ["*"], true, never>;
+    static ngAcceptInputType_isAggregationDisabled: unknown;
+    static ngAcceptInputType_isCumulativeSumEnabled: unknown;
+}
+/** The underlying custom element type for LuzmoDisplaySettingsNumeric */
+export type LuzmoDisplaySettingsNumericElement = LuzmoDisplaySettingsNumericHostElement;