@masterteam/dashboard-builder 0.0.1

package/fesm2022/masterteam-dashboard-builder-dashboard-dialog.component-D1JNWQMI.mjs

@@ -0,0 +1,595 @@
+import * as i0 from '@angular/core';
+import { inject, Injectable, input, signal, computed, Component } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { TranslocoService, TranslocoDirective } from '@jsverse/transloco';
+import { ModalService } from '@masterteam/components/modal';
+import { ModalRef } from '@masterteam/components/dialog';
+import { Button } from '@masterteam/components/button';
+import { DashboardItemStoreService, DashboardItem } from './masterteam-dashboard-builder.mjs';
+
+/**
+ * Filter Utilities Service
+ *
+ * Handles dynamic filter processing for dashboard charts.
+ * Replaces old handleFilters.ts functionality.
+ */
+class FilterUtilsService {
+    transloco = inject(TranslocoService);
+    // Registry of function placeholders
+    functionPlaceholders = {
+        startOfMonth: {
+            pattern: /^startOfMonth\((.+?),(.+?)\)$/,
+            handler: (args, params) => {
+                const month = parseInt(String(this.resolveValueForParam(args[0], params)), 10);
+                const year = parseInt(String(this.resolveValueForParam(args[1], params)), 10);
+                if (month && year) {
+                    return this.formatDateDMY(1, month, year);
+                }
+                return '';
+            },
+        },
+        endOfMonth: {
+            pattern: /^endOfMonth\((.+?),(.+?)\)$/,
+            handler: (args, params) => {
+                const month = parseInt(String(this.resolveValueForParam(args[0], params)), 10);
+                const year = parseInt(String(this.resolveValueForParam(args[1], params)), 10);
+                if (month && year) {
+                    const lastDay = this.getLastDayOfMonth(month, year);
+                    return this.formatDateDMY(lastDay, month, year);
+                }
+                return '';
+            },
+        },
+        monthRange: {
+            pattern: /^monthRange\((.+?),(.+?)\)$/,
+            handler: (args, params) => {
+                const month = parseInt(String(this.resolveValueForParam(args[0], params)), 10);
+                const year = parseInt(String(this.resolveValueForParam(args[1], params)), 10);
+                if (month && year) {
+                    const startDate = this.formatDateDMY(1, month, year);
+                    const lastDay = this.getLastDayOfMonth(month, year);
+                    const endDate = this.formatDateDMY(lastDay, month, year);
+                    return `${startDate},${endDate}`;
+                }
+                return '';
+            },
+        },
+    };
+    /**
+     * Handle filters for custom chart requests
+     */
+    handleFiltersForCustom(configItem, params, extraFilters) {
+        // Deep clone to avoid mutation
+        const config = JSON.parse(JSON.stringify(configItem));
+        // Process selections
+        config.selection?.forEach((selection) => {
+            // Replace placeholders in moduleId
+            if (typeof selection.moduleId === 'string') {
+                selection.moduleId = this.dynamicTextReplace(selection.moduleId, params);
+            }
+            // Add dynamic filters from extraFilters
+            if (extraFilters?.dynamicFilters?.length) {
+                extraFilters.dynamicFilters.forEach((dynamicFilter) => {
+                    const filterKey = dynamicFilter.key;
+                    const paramValue = params?.[filterKey];
+                    if (paramValue !== undefined &&
+                        paramValue !== null &&
+                        paramValue !== '') {
+                        const configuration = dynamicFilter.configuration;
+                        const templateFilter = configuration?.payload?.selection?.[0]?.filters?.[0];
+                        if (templateFilter) {
+                            const newFilter = {
+                                propertyKey: templateFilter.propertyKey,
+                                propertyValue: paramValue,
+                                operation: configuration?.isMultiple ? 'OneOf' : 'Equal',
+                                logical: 'And',
+                                operationLevel: null,
+                            };
+                            if (templateFilter.propertyData) {
+                                newFilter.propertyData = templateFilter.propertyData;
+                            }
+                            if (!selection.filters) {
+                                selection.filters = [];
+                            }
+                            selection.filters.push(newFilter);
+                        }
+                    }
+                });
+            }
+            // Process and filter existing filters
+            selection.filters = selection.filters?.filter((filter) => {
+                let shouldKeepFilter = true;
+                let newPropertyValue = filter.propertyValue;
+                // Handle placeholders in filter.propertyValue
+                if (typeof newPropertyValue === 'string') {
+                    const matches = newPropertyValue.match(/{{(.*?)}}(\?)?/g);
+                    if (matches) {
+                        for (const match of matches) {
+                            const processedValue = this.processCommaPlaceholders(match, params);
+                            if (processedValue === null) {
+                                shouldKeepFilter = false;
+                                break;
+                            }
+                            newPropertyValue = newPropertyValue.replace(match, processedValue);
+                        }
+                        if (shouldKeepFilter) {
+                            newPropertyValue =
+                                this.resolvePlaceholdersRecursively(newPropertyValue, params) ||
+                                    newPropertyValue;
+                            filter.propertyValue = newPropertyValue;
+                        }
+                    }
+                }
+                // Remove if propertyValue is 'ignoreFilter'
+                if (shouldKeepFilter && filter.propertyValue === 'ignoreFilter') {
+                    shouldKeepFilter = false;
+                }
+                // Check relations for conditional removal
+                if (shouldKeepFilter && Array.isArray(filter.relations)) {
+                    for (const relation of filter.relations) {
+                        if (relation.type === 'realationBetweenPageFilters') {
+                            const paramVal = params?.[relation.key];
+                            if (relation.value === 'deleteIfThereValue' && paramVal) {
+                                shouldKeepFilter = false;
+                                break;
+                            }
+                            else if (relation.value === 'deleteIfThereNoValue' &&
+                                !paramVal) {
+                                shouldKeepFilter = false;
+                                break;
+                            }
+                        }
+                    }
+                }
+                return shouldKeepFilter;
+            });
+            // Clean up empty properties on filters
+            selection.filters?.forEach((filter) => {
+                if (!filter?.operation)
+                    delete filter.operation;
+                if (!filter?.operationLevel)
+                    delete filter.operationLevel;
+                if (!filter?.logical)
+                    delete filter.logical;
+            });
+        });
+        return config;
+    }
+    /**
+     * Handle filters for card/overview requests
+     */
+    handleFilterForCard(filters, params) {
+        const filteredList = filters.filter((filter) => {
+            const propertyValue = filter.propertyValue;
+            const matches = propertyValue?.match(/{{(.*?)}}(\?)?/g);
+            let shouldKeepFilter = true;
+            let newPropertyValue = propertyValue;
+            if (matches) {
+                for (const match of matches) {
+                    const processedValue = this.processCommaPlaceholders(match, params);
+                    if (processedValue === null) {
+                        shouldKeepFilter = false;
+                        break;
+                    }
+                    newPropertyValue = newPropertyValue.replace(match, processedValue);
+                }
+                if (shouldKeepFilter) {
+                    newPropertyValue =
+                        this.resolvePlaceholdersRecursively(newPropertyValue, params) ||
+                            newPropertyValue;
+                    filter.propertyValue = newPropertyValue;
+                }
+            }
+            return shouldKeepFilter;
+        });
+        const result = {};
+        filteredList.forEach((filter) => {
+            result[filter.propertyKey] = filter.propertyValue;
+        });
+        return result;
+    }
+    /**
+     * Handle filter for snapshot requests
+     */
+    handleFilterForSnapshot(levelId, params) {
+        return this.dynamicTextReplace(levelId, params);
+    }
+    /**
+     * Replace dynamic placeholders in text
+     */
+    dynamicTextReplace(text, params, keepIfNotFound = false) {
+        if (!text)
+            return '';
+        const enrichedParams = {
+            ...params,
+            currentYear: new Date().getFullYear().toString(),
+            currentWeek: this.getCurrentWeekOfYear().toString(),
+            createdAt: new Date().toLocaleDateString('en-US', {
+                day: 'numeric',
+                month: 'long',
+                year: 'numeric',
+            }),
+        };
+        return text.replace(/\{\{([\w.]+)\}\}/g, (match, key) => {
+            let value = this.getNestedValue(enrichedParams, key);
+            // Case-insensitive fallback
+            if (value === undefined) {
+                const lowerKey = key.toLowerCase();
+                const foundKey = Object.keys(enrichedParams).find((k) => k.toLowerCase() === lowerKey);
+                if (foundKey) {
+                    value = this.getNestedValue(enrichedParams, foundKey);
+                }
+            }
+            return value !== undefined ? String(value) : keepIfNotFound ? match : '';
+        });
+    }
+    // ============================================
+    // Private Helper Methods
+    // ============================================
+    resolveValueForParam(value, params) {
+        const orParts = value.split('||').map((p) => p.trim());
+        for (const part of orParts) {
+            if (!isNaN(Number(part))) {
+                return Number(part);
+            }
+            const paramValue = this.getNestedValue(params, part);
+            if (paramValue !== undefined &&
+                paramValue !== null &&
+                paramValue !== '') {
+                return paramValue;
+            }
+        }
+        return null;
+    }
+    getLastDayOfMonth(month, year) {
+        return new Date(year, month, 0).getDate();
+    }
+    formatDateDMY(day, month, year) {
+        const dd = String(day).padStart(2, '0');
+        const mm = String(month).padStart(2, '0');
+        return `${dd}-${mm}-${year}`;
+    }
+    getCurrentWeekOfYear() {
+        const now = new Date();
+        const start = new Date(now.getFullYear(), 0, 1);
+        const diff = now.getTime() - start.getTime();
+        const oneWeek = 1000 * 60 * 60 * 24 * 7;
+        return Math.ceil(diff / oneWeek);
+    }
+    getNestedValue(obj, path) {
+        return path.split('.').reduce((current, key) => current?.[key], obj);
+    }
+    processFunctionPlaceholder(placeholder, params) {
+        for (const funcName in this.functionPlaceholders) {
+            const { pattern, handler } = this.functionPlaceholders[funcName];
+            const match = placeholder.match(pattern);
+            if (match) {
+                const args = match.slice(1).map((arg) => arg.trim());
+                return handler(args, params);
+            }
+        }
+        return null;
+    }
+    handleSpecialPlaceholders(placeholder, params) {
+        // Try function placeholders first
+        const functionResult = this.processFunctionPlaceholder(placeholder, params);
+        if (functionResult !== null) {
+            return functionResult;
+        }
+        const getCurrentDate = () => new Date();
+        const getFirstDateOfCurrentYear = () => {
+            const currentYear = new Date().getFullYear();
+            return new Date(Date.UTC(currentYear, 0, 1));
+        };
+        const getEndDateOfCurrentYear = () => {
+            const currentYear = new Date().getFullYear();
+            return new Date(Date.UTC(currentYear, 11, 31));
+        };
+        const adjustDate = (date, amount, unit) => {
+            const newDate = new Date(date);
+            switch (unit) {
+                case 'd':
+                    newDate.setUTCDate(newDate.getUTCDate() + amount);
+                    break;
+                case 'm':
+                    newDate.setUTCMonth(newDate.getUTCMonth() + amount);
+                    break;
+                case 'y':
+                    newDate.setUTCFullYear(newDate.getUTCFullYear() + amount);
+                    break;
+            }
+            return newDate;
+        };
+        // Date patterns
+        const datePattern = /^(currentDate|firstDateOfCurrentYear|startDateOfCurrentYear|endDateOfCurrentYear)([+-]\d+)?([dmy])?$/;
+        const dateMatches = placeholder.match(datePattern);
+        if (dateMatches) {
+            const [, baseDate, adjustment = '', unit = ''] = dateMatches;
+            let date;
+            switch (baseDate) {
+                case 'currentDate':
+                    date = getCurrentDate();
+                    break;
+                case 'firstDateOfCurrentYear':
+                case 'startDateOfCurrentYear':
+                    date = getFirstDateOfCurrentYear();
+                    break;
+                case 'endDateOfCurrentYear':
+                    date = getEndDateOfCurrentYear();
+                    break;
+                default:
+                    date = getCurrentDate();
+            }
+            if (adjustment) {
+                const amount = parseInt(adjustment, 10);
+                const timeUnit = unit || 'd';
+                date = adjustDate(date, amount, timeUnit);
+            }
+            return date.toISOString().split('T')[0];
+        }
+        // Number patterns
+        const numberPattern = /^(\d+)([+-]\d+)?$/;
+        const numberMatches = placeholder.match(numberPattern);
+        if (numberMatches) {
+            const [, baseNumber, adjustment = ''] = numberMatches;
+            let resultNumber = parseInt(baseNumber, 10);
+            if (adjustment) {
+                resultNumber += parseInt(adjustment, 10);
+            }
+            return resultNumber.toString();
+        }
+        // Fallback to params
+        return this.getNestedValue(params, placeholder) || '';
+    }
+    resolveValue(value, params) {
+        // String literal
+        if ((value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))) {
+            return value.slice(1, -1);
+        }
+        // Number
+        if (!isNaN(Number(value))) {
+            return Number(value);
+        }
+        // Boolean/null/undefined
+        if (value === 'true')
+            return true;
+        if (value === 'false')
+            return false;
+        if (value === 'null')
+            return null;
+        if (value === 'undefined')
+            return undefined;
+        // Parameter key
+        return this.getNestedValue(params, value);
+    }
+    evaluateConditionalExpression(expression, params) {
+        const ternaryPattern = /^(.+?)\s*\?\s*(.+?)\s*:\s*(.+?)$/;
+        const match = expression.match(ternaryPattern);
+        if (!match) {
+            return null;
+        }
+        const [, condition, trueValue, falseValue] = match;
+        let conditionResult = false;
+        const comparisonPattern = /^(.+?)\s*(==|===|!=|!==|>|<|>=|<=)\s*(.+?)$/;
+        const compMatch = condition.match(comparisonPattern);
+        if (compMatch) {
+            const [, left, operator, right] = compMatch;
+            const leftValue = this.resolveValue(left.trim(), params);
+            const rightValue = this.resolveValue(right.trim(), params);
+            switch (operator) {
+                case '==':
+                case '===':
+                    conditionResult = leftValue == rightValue;
+                    break;
+                case '!=':
+                case '!==':
+                    conditionResult = leftValue != rightValue;
+                    break;
+                case '>':
+                    conditionResult = leftValue > rightValue;
+                    break;
+                case '<':
+                    conditionResult = leftValue < rightValue;
+                    break;
+                case '>=':
+                    conditionResult = leftValue >= rightValue;
+                    break;
+                case '<=':
+                    conditionResult = leftValue <= rightValue;
+                    break;
+            }
+        }
+        else {
+            const value = this.resolveValue(condition.trim(), params);
+            conditionResult = !!value;
+        }
+        const resultValue = conditionResult ? trueValue.trim() : falseValue.trim();
+        if (resultValue === 'null')
+            return null;
+        if (resultValue === 'undefined')
+            return '';
+        return String(this.resolveValue(resultValue, params));
+    }
+    resolvePlaceholdersRecursively(value, params) {
+        if (!value.match(/{{(.*?)}}/)) {
+            return value;
+        }
+        const replaced = this.dynamicTextReplace(value, params);
+        if (replaced === value && replaced.match(/{{(.*?)}}/)) {
+            return null;
+        }
+        if (replaced.match(/{{(.*?)}}/)) {
+            return this.resolvePlaceholdersRecursively(replaced, params);
+        }
+        return replaced;
+    }
+    processCommaPlaceholders(match, params) {
+        const rawContent = match.replace(/{{|}}/g, '');
+        // Try function placeholders
+        const functionResult = this.processFunctionPlaceholder(rawContent, params);
+        if (functionResult !== null) {
+            return functionResult;
+        }
+        // Try conditional expression
+        if (rawContent.includes('?') && rawContent.includes(':')) {
+            const conditionalResult = this.evaluateConditionalExpression(rawContent, params);
+            if (conditionalResult !== null) {
+                return conditionalResult;
+            }
+        }
+        // Remove optional marker and process comma-separated params
+        const cleanContent = rawContent.replace(/\?/g, '');
+        const paramNames = cleanContent.split(',');
+        const paramValues = [];
+        for (const paramName of paramNames) {
+            const trimmedName = paramName.trim();
+            const orParts = trimmedName.split('||').map((p) => p.trim());
+            let resolvedValueForThisPart = null;
+            for (const orPart of orParts) {
+                const resolvedName = this.resolvePlaceholdersRecursively(orPart, params);
+                if (resolvedName) {
+                    const finalValue = this.handleSpecialPlaceholders(resolvedName, params);
+                    if (finalValue !== '') {
+                        resolvedValueForThisPart = String(finalValue);
+                        break;
+                    }
+                }
+            }
+            if (!resolvedValueForThisPart) {
+                return null;
+            }
+            paramValues.push(resolvedValueForThisPart);
+        }
+        const hasEmptyValues = paramValues.some((value) => value === '' || value === undefined);
+        if (hasEmptyValues) {
+            return null;
+        }
+        return paramValues.join(',');
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.3", ngImport: i0, type: FilterUtilsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.3", ngImport: i0, type: FilterUtilsService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.3", ngImport: i0, type: FilterUtilsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+/**
+ * Dashboard Dialog Component
+ *
+ * A flexible dialog wrapper that renders a DashboardItem inside.
+ * Uses the same ItemConfig structure - maximum code reuse.
+ *
+ * The dialog simply wraps DashboardItem, so any chart/table/card
+ * that works inline will work in a dialog too.
+ */
+/**
+ * Dashboard Dialog Component
+ *
+ * Opened via ModalService, renders a DashboardItem inside.
+ * Usage:
+ *   this.modalService.open(DashboardDialogComponent, {
+ *     data: { config: itemConfig, params: queryParams }
+ *   });
+ */
+class DashboardDialogComponent {
+    itemStore = inject(DashboardItemStoreService);
+    filterUtils = inject(FilterUtilsService);
+    transloco = inject(TranslocoService);
+    modal = inject(ModalService);
+    ref = inject(ModalRef);
+    // Inputs from modal data
+    configInput = input(null, { ...(ngDevMode ? { debugName: "configInput" } : {}), alias: 'config' });
+    paramsInput = input({}, { ...(ngDevMode ? { debugName: "paramsInput" } : {}), alias: 'params' });
+    titleInput = input(null, { ...(ngDevMode ? { debugName: "titleInput" } : {}), alias: 'title' });
+    // State
+    dialogConfig = signal(null, ...(ngDevMode ? [{ debugName: "dialogConfig" }] : []));
+    actionParams = signal({}, ...(ngDevMode ? [{ debugName: "actionParams" }] : []));
+    // Computed
+    mergedParams = computed(() => ({
+        ...this.paramsInput(),
+        ...this.actionParams(),
+    }), ...(ngDevMode ? [{ debugName: "mergedParams" }] : []));
+    processedConfig = computed(() => {
+        debugger;
+        const config = this.dialogConfig();
+        if (!config)
+            return null;
+        // Deep clone and process filters
+        const cloned = JSON.parse(JSON.stringify(config));
+        // Apply filter processing if service config exists
+        if (cloned.serviceConfig) {
+            const processed = this.filterUtils.handleFiltersForCustom(cloned.serviceConfig, this.mergedParams());
+            cloned.serviceConfig = processed;
+        }
+        return cloned;
+    }, ...(ngDevMode ? [{ debugName: "processedConfig" }] : []));
+    ngOnInit() {
+        // Set config from input
+        const config = this.configInput();
+        if (config) {
+            this.dialogConfig.set(config);
+        }
+        // Set params from input
+        const params = this.paramsInput();
+        if (params) {
+            this.actionParams.set(params);
+        }
+    }
+    /**
+     * Close dialog
+     */
+    close(result) {
+        this.ref.close(result);
+    }
+    /**
+     * Handle actions from the inner DashboardItem
+     */
+    onItemAction(event) {
+        // If it's a close action, close the dialog
+        if (event?.type === 'closeDialog') {
+            this.close(event?.data);
+            return;
+        }
+        // For navigation actions, close dialog and let parent handle
+        if (event?.type === 'navigate' || event?.type === 'navigateTo') {
+            this.close(event);
+            return;
+        }
+        // For other actions, could emit to parent or handle internally
+        console.log('Dialog action:', event);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.3", ngImport: i0, type: DashboardDialogComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.0.3", type: DashboardDialogComponent, isStandalone: true, selector: "db-dashboard-dialog", inputs: { configInput: { classPropertyName: "configInput", publicName: "config", isSignal: true, isRequired: false, transformFunction: null }, paramsInput: { classPropertyName: "paramsInput", publicName: "params", isSignal: true, isRequired: false, transformFunction: null }, titleInput: { classPropertyName: "titleInput", publicName: "title", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: "<div\r\n  [class]=\"modal.contentClass + ' p-0 min-h-[300px] max-h-[80vh] overflow-auto'\"\r\n  *transloco=\"let t; prefix: 'dashboard'\"\r\n>\r\n  <!-- Dashboard Item renders whatever the config specifies -->\r\n  @if (processedConfig()) {\r\n    <mt-dashboard-item\r\n      [config]=\"processedConfig()!\"\r\n      [queryParams]=\"mergedParams()\"\r\n      [isDialog]=\"true\"\r\n      (actionTriggered)=\"onItemAction($event)\"\r\n    />\r\n  } @else {\r\n    <!-- Loading state while config is being processed -->\r\n    <div class=\"flex items-center justify-center min-h-[200px]\">\r\n      <i class=\"pi pi-spin pi-spinner text-4xl text-primary\"></i>\r\n    </div>\r\n  }\r\n</div>\r\n<!--\r\n<div [class]=\"modal.footerClass\" *transloco=\"let t; prefix: 'dashboard'\">\r\n  <mt-button [label]=\"t('close')\" severity=\"secondary\" (onClick)=\"close()\" />\r\n</div> -->\r\n", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: TranslocoDirective, selector: "[transloco]", inputs: ["transloco", "translocoParams", "translocoScope", "translocoRead", "translocoPrefix", "translocoLang", "translocoLoadingTpl"] }, { kind: "component", type: DashboardItem, selector: "mt-dashboard-item", inputs: ["config", "chartTypeId", "readonly", "inGroup", "isDialog", "queryParams"], outputs: ["actionTriggered"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.3", ngImport: i0, type: DashboardDialogComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'db-dashboard-dialog', standalone: true, imports: [CommonModule, TranslocoDirective, Button, DashboardItem], template: "<div\r\n  [class]=\"modal.contentClass + ' p-0 min-h-[300px] max-h-[80vh] overflow-auto'\"\r\n  *transloco=\"let t; prefix: 'dashboard'\"\r\n>\r\n  <!-- Dashboard Item renders whatever the config specifies -->\r\n  @if (processedConfig()) {\r\n    <mt-dashboard-item\r\n      [config]=\"processedConfig()!\"\r\n      [queryParams]=\"mergedParams()\"\r\n      [isDialog]=\"true\"\r\n      (actionTriggered)=\"onItemAction($event)\"\r\n    />\r\n  } @else {\r\n    <!-- Loading state while config is being processed -->\r\n    <div class=\"flex items-center justify-center min-h-[200px]\">\r\n      <i class=\"pi pi-spin pi-spinner text-4xl text-primary\"></i>\r\n    </div>\r\n  }\r\n</div>\r\n<!--\r\n<div [class]=\"modal.footerClass\" *transloco=\"let t; prefix: 'dashboard'\">\r\n  <mt-button [label]=\"t('close')\" severity=\"secondary\" (onClick)=\"close()\" />\r\n</div> -->\r\n" }]
+        }], propDecorators: { configInput: [{ type: i0.Input, args: [{ isSignal: true, alias: "config", required: false }] }], paramsInput: [{ type: i0.Input, args: [{ isSignal: true, alias: "params", required: false }] }], titleInput: [{ type: i0.Input, args: [{ isSignal: true, alias: "title", required: false }] }] } });
+/**
+ * Helper service for opening dashboard dialogs
+ */
+function openDashboardDialog(modalService, config, params, options) {
+    const sizeClass = {
+        sm: 'max-w-md',
+        md: 'max-w-2xl',
+        lg: 'max-w-4xl',
+        xl: 'max-w-6xl',
+        full: 'max-w-[95vw]',
+    }[options?.size || 'lg'];
+    return modalService.openModal(DashboardDialogComponent, 'dialog', {
+        header: options?.title || '',
+        styleClass: sizeClass,
+        data: {
+            config,
+            params: params || {},
+            title: options?.title,
+        },
+    });
+}
+
+export { DashboardDialogComponent, openDashboardDialog };
+//# sourceMappingURL=masterteam-dashboard-builder-dashboard-dialog.component-D1JNWQMI.mjs.map