@nexterajs/app-kit 0.0.1

package/fesm2022/nexterajs-app-kit.mjs

@@ -0,0 +1,1012 @@
+import { FormGroup, FormControl } from '@angular/forms';
+import * as i0 from '@angular/core';
+import { computed, Pipe, Input, Directive, HostListener, inject, Injector, EnvironmentInjector, ApplicationRef, RendererFactory2, createComponent, Injectable } from '@angular/core';
+import { TemplatePortal } from '@angular/cdk/portal';
+import * as i1 from '@angular/cdk/overlay';
+import { Subject } from 'rxjs';
+
+class BooleanOperator {
+    static NOT_INCLUDE = 'NIN';
+    static INCLUDE = 'IN';
+    static EQUALS = '=';
+    static NOT_EQUAL = '!=';
+}
+class ValueOperator {
+    static NOT_INCLUDE = 'NIN';
+    static INCLUDE = 'IN';
+    static EQUALS = '=';
+    static NOT_EQUAL = '!=';
+}
+class ConditionType {
+    static GROUP = 'GROUP';
+    static SINGLE = 'SINGLE';
+}
+class ConditionOperator {
+    static AND = 'AND';
+    static OR = 'OR';
+}
+class ConditionEvaluator {
+    static evaluate(data, condition) {
+        if (condition.type === ConditionType.SINGLE) {
+            return this.evaluateSingle(data, condition);
+        }
+        if (condition.type === ConditionType.GROUP && condition.children) {
+            return this.evaluateGroup(data, condition);
+        }
+        return false;
+    }
+    static evaluateSingle(data, condition) {
+        const { key, valueOperator, value } = condition;
+        if (!key || !valueOperator)
+            return false;
+        const actualValue = data[key];
+        switch (valueOperator) {
+            case ValueOperator.EQUALS:
+                return actualValue === value;
+            case ValueOperator.NOT_EQUAL:
+                return actualValue !== value;
+            case ValueOperator.INCLUDE:
+                return Array.isArray(value) ? value.includes(actualValue) : false;
+            case ValueOperator.NOT_INCLUDE:
+                return Array.isArray(value) ? !value.includes(actualValue) : false;
+            default:
+                return false;
+        }
+    }
+    static evaluateGroup(data, condition) {
+        const { children = [], groupOperator } = condition;
+        if (groupOperator === ConditionOperator.AND) {
+            return children.every(child => this.evaluate(data, child));
+        }
+        if (groupOperator === ConditionOperator.OR) {
+            return children.some(child => this.evaluate(data, child));
+        }
+        return false;
+    }
+}
+
+class MappedLov {
+    map = {};
+    constructor(initial) {
+        if (initial) {
+            this.map = initial;
+        }
+    }
+    get(key) {
+        return this.map[key] ?? [];
+    }
+    set(key, value) {
+        this.map[key] = value;
+    }
+    has(key) {
+        return key in this.map;
+    }
+    getRawMap() {
+        return Object.fromEntries(this.keys.map(k => [k, this.get(k)]));
+    }
+    constructorKeys;
+    get keys() {
+        return [...this.constructorKeys];
+    }
+}
+
+class ValueChangeEvent {
+    static ADD_DAYS = 'ADD_DAYS';
+    static ADD_MONTHS = 'ADD_MONTHS';
+    static ADD_YEARS = 'ADD_YEARS';
+    static GET_DEFAULT_VALUE_REINS = 'GET_DEFAULT_VALUE_REINS';
+}
+class LayoutType {
+    static DIVIDER = 'DIVIDER';
+    static CONTAINER = 'CONTAINER';
+    static GRID_ITEM = 'GRID_ITEM';
+    static GRID_CONTAINER = 'GRID_CONTAINER';
+}
+
+class DataType {
+    static TXT = 'TXT';
+    static TXM = 'TXM';
+    static NUM = 'NUM';
+    static DTE = 'DTE';
+    static LNK = 'LNK';
+    static TXA = 'TXA';
+    static ACT = 'ACT';
+    static LOV = 'LOV';
+    static LOM = 'LOM';
+    static CHK = 'CHK';
+    static HTM = 'HTM';
+    static GRD = 'GRD';
+    static IMG = 'IMG';
+    static DRD = 'DRD';
+    static DYN = 'DYN';
+}
+
+class ActionCode {
+    static LIST = 'LST';
+    static VIEW = 'VIE';
+    static CREATE = 'CRT';
+    static VALIDATE = 'VAL';
+    static FINALIZE = 'FIN';
+    static APPROVAL = 'APP';
+    static MODIFY = 'MOD';
+    static DELETE = 'DEL';
+    static CANCEL = 'CAN';
+    static EXTEND_DUE_DATE = 'EXD';
+    static CONFIRM = 'CON';
+    static BINDING = 'BIN';
+    static REVERSE = 'REV';
+    static CALCULATE = 'CAL';
+    static SEND_FOR_APPROVAL = 'STA';
+    static PLACEMENT = 'PLA';
+    static DIVIDER = 'divider';
+    static RUN = 'RUN';
+    static ACTIVATED = 'ACT';
+    static TERMINATED = 'TRM';
+    static RESET_PASS = 'RST';
+    static LOCK = 'LOC';
+    static UNLOCK = 'UNL';
+    static POSTING = 'POS';
+    static UNPOSTING = 'UNP';
+    static EXTRACT = 'EXT';
+    static BIND = 'BND';
+    static NEW = 'NEW';
+    static ADD_SUB_TREATY = 'ADD_SUB_TREATY';
+    static CORRECTION = 'COR';
+    static CONVERT_TO_PROPOSAL = 'PRO';
+    static DOWNLOAD = 'PRV';
+    static SEND = 'SND';
+    static ISSUE = 'ISS';
+    static REACTIVATE = 'RAC';
+    static PRINT = 'PRT';
+    static TERMINATE = 'TRM';
+    static ADD_TO_PAYMENT = 'ADD_TO_PAYMENT';
+    static ROLLBACK = 'ROL';
+}
+const ACTION_MAPPER = {
+    [ActionCode.CREATE]: getActionNew,
+    [ActionCode.VIEW]: getActionView,
+    [ActionCode.MODIFY]: getActionModify,
+    [ActionCode.DELETE]: getActionDelete,
+    [ActionCode.VALIDATE]: getActionValidate,
+    [ActionCode.EXTRACT]: getActionExtract,
+    [ActionCode.ADD_TO_PAYMENT]: getActionAddToPayment,
+    [ActionCode.ACTIVATED]: getActionActivated,
+    [ActionCode.TERMINATED]: getActionTerminate,
+    [ActionCode.RESET_PASS]: getActionResetPassword,
+    [ActionCode.LOCK]: getActionLock,
+    [ActionCode.UNLOCK]: getActionUnlock,
+};
+function getActionView(disabled = false) {
+    return {
+        value: ActionCode.VIEW,
+        text: 'View',
+        icon: 'eye',
+        disabled,
+    };
+}
+function getActionRollback(disabled = false) {
+    return {
+        value: ActionCode.ROLLBACK,
+        text: 'Rollback',
+        icon: 'undo',
+        disabled,
+    };
+}
+function getActionNew(disabled = false) {
+    return {
+        value: ActionCode.NEW,
+        text: 'New',
+        icon: 'add',
+        disabled,
+    };
+}
+function getActionSend(disabled = false) {
+    return {
+        value: ActionCode.SEND,
+        text: 'Send to Ceding',
+        icon: 'swap_horiz',
+        disabled,
+    };
+}
+function getActionAddSubTreaty(disabled = false) {
+    return {
+        value: ActionCode.ADD_SUB_TREATY,
+        text: 'Add Sub Treaty',
+        icon: 'add',
+        disabled,
+    };
+}
+function getActionCorrection(disabled = false) {
+    return {
+        value: ActionCode.CORRECTION,
+        text: 'Correction',
+        icon: 'list',
+        disabled,
+    };
+}
+function getActionConvertToProposal(disabled = false) {
+    return {
+        value: ActionCode.CONVERT_TO_PROPOSAL,
+        text: 'Convert to Proposal',
+        icon: 'published_with_changes',
+        disabled,
+    };
+}
+function getActionBind(disabled = false) {
+    return {
+        value: ActionCode.BIND,
+        text: 'Bind',
+        icon: 'done',
+        disabled,
+    };
+}
+function getActionPosting(disabled = false) {
+    return {
+        value: ActionCode.POSTING,
+        text: 'Posting',
+        icon: 'redo',
+        disabled,
+    };
+}
+function getActionExtract(disabled = false) {
+    return {
+        value: ActionCode.EXTRACT,
+        text: 'Extract',
+        icon: 'functions',
+        disabled,
+    };
+}
+function getActionUnposting(disabled = false) {
+    return {
+        value: ActionCode.UNPOSTING,
+        text: 'UnPosting',
+        icon: 'undo',
+        disabled,
+    };
+}
+function getActionRun(disabled = false) {
+    return {
+        value: ActionCode.RUN,
+        text: 'Run',
+        icon: 'done',
+        disabled,
+    };
+}
+function getActionValidate(disabled = false) {
+    return {
+        value: ActionCode.VALIDATE,
+        text: 'Validate',
+        icon: 'done',
+        disabled,
+    };
+}
+function getActionAddToPayment(disabled = false) {
+    return {
+        value: ActionCode.ADD_TO_PAYMENT,
+        text: 'Add to Payment',
+        icon: 'done',
+        disabled,
+    };
+}
+function getActionIssue(disabled = false) {
+    return {
+        value: ActionCode.ISSUE,
+        text: 'Issue',
+        icon: 'done',
+        disabled,
+    };
+}
+function getActionReactivate(disabled = false) {
+    return {
+        value: ActionCode.REACTIVATE,
+        text: 'Reactivate',
+        icon: 'done',
+        disabled,
+    };
+}
+function getActionDownload(disabled = false) {
+    return {
+        value: ActionCode.DOWNLOAD,
+        text: 'Preview',
+        icon: 'download',
+        disabled,
+    };
+}
+function getActionFinalize(disabled = false) {
+    return {
+        value: ActionCode.FINALIZE,
+        text: 'Finalize',
+        icon: 'timeline',
+        disabled,
+    };
+}
+function getActionSendForApproval(disabled = false, text = 'Send for Approval') {
+    return {
+        value: ActionCode.SEND_FOR_APPROVAL,
+        text,
+        icon: 'send',
+        disabled,
+    };
+}
+function getActionPlacement(disabled = false, text = 'Placement') {
+    return {
+        value: ActionCode.PLACEMENT,
+        text,
+        icon: 'swap_horiz',
+        disabled,
+    };
+}
+function getActionCalculate(disabled = false) {
+    return {
+        value: ActionCode.CALCULATE,
+        text: 'Calculate',
+        icon: 'calculate',
+        disabled,
+    };
+}
+function getActionConfirm(disabled = false) {
+    return {
+        value: ActionCode.CONFIRM,
+        text: 'Confirmation',
+        icon: 'star',
+        disabled,
+    };
+}
+function getActionBinding(disabled = false) {
+    return {
+        value: ActionCode.BINDING,
+        text: 'Binding',
+        icon: 'star',
+        disabled,
+    };
+}
+function getActionReverse(disabled = false) {
+    return {
+        value: ActionCode.REVERSE,
+        text: 'Reverse',
+        icon: 'undo',
+        disabled,
+    };
+}
+function getActionDelete(disabled = false) {
+    return {
+        value: ActionCode.DELETE,
+        text: 'Delete',
+        icon: 'delete',
+        disabled,
+    };
+}
+function getActionCancel(disabled = false) {
+    return {
+        value: ActionCode.CANCEL,
+        text: 'Cancel',
+        icon: 'close',
+        disabled,
+    };
+}
+function getActionExtendDueDate(disabled = false) {
+    return {
+        value: ActionCode.EXTEND_DUE_DATE,
+        text: 'Extend Due Date',
+        icon: 'autorenew',
+        disabled,
+    };
+}
+function getActionApproval(disabled = false) {
+    return {
+        value: ActionCode.APPROVAL,
+        text: 'Approval',
+        icon: 'done_all',
+        disabled,
+    };
+}
+function getActionPrint(disabled = false) {
+    return {
+        value: ActionCode.PRINT,
+        text: 'Print',
+        icon: 'print',
+        disabled,
+    };
+}
+function getActionDivider() {
+    return {
+        value: ActionCode.VALIDATE,
+        text: 'Validate',
+        icon: 'done',
+        disabled: true,
+    };
+}
+function getActionModify(disabled = false) {
+    return {
+        value: ActionCode.MODIFY,
+        text: 'Modify',
+        icon: 'edit',
+        disabled,
+    };
+}
+function getActionActivated(disabled = false) {
+    return {
+        value: ActionCode.ACTIVATED,
+        text: 'Activate',
+        icon: 'done',
+        disabled,
+    };
+}
+function getActionTerminated(disabled = false) {
+    return {
+        value: ActionCode.TERMINATED,
+        text: 'Terminate',
+        icon: 'close',
+        disabled,
+    };
+}
+function getActionResetPassword(disabled = false) {
+    return {
+        value: ActionCode.RESET_PASS,
+        text: 'Reset Password',
+        icon: 'settings_backup_restore',
+        disabled,
+    };
+}
+function getActionLock(disabled = false) {
+    return {
+        value: ActionCode.LOCK,
+        text: 'Lock',
+        icon: 'lock',
+        disabled,
+    };
+}
+function getActionUnlock(disabled = false) {
+    return {
+        value: ActionCode.UNLOCK,
+        text: 'Unlock',
+        icon: 'done',
+        disabled,
+    };
+}
+function getActionTerminate(disabled = false, text = 'Terminate') {
+    return {
+        value: ActionCode.TERMINATE,
+        text,
+        icon: 'close',
+        disabled,
+    };
+}
+
+class PageMode {
+    static VIEW = 'View';
+    static MODIFY = 'Modify';
+    static ADD = 'New';
+}
+
+function extractGridItems(layoutItems, existingGridItems = []) {
+    layoutItems.forEach((item) => {
+        if (item.gridItem) {
+            existingGridItems.push(item.gridItem);
+        }
+        if (item.children?.length > 0) {
+            extractGridItems(item.children, existingGridItems);
+        }
+    });
+    return existingGridItems;
+}
+function createFormGroup(gridItems, module, lov) {
+    const formGroup = new FormGroup({});
+    gridItems.forEach(gridItem => {
+        const validators = [];
+        // if (gridItem.required) {
+        //   validators.push(Validators.required);
+        // }
+        let value = null;
+        if (gridItem.dataType === DataType.CHK) {
+            value = false;
+        }
+        const formControl = new FormControl(value, validators);
+        if (gridItem.fixedValue !== null && gridItem.fixedValue !== undefined) {
+            formControl.setValue(gridItem.fixedValue);
+            // formControl.removeValidators(Validators.required);
+        }
+        formGroup.addControl(gridItem.id, formControl);
+    });
+    gridItems.forEach(gridItem => {
+        if (gridItem?.lovDependency) {
+            const dependencies = Array.isArray(gridItem.lovDependency) ? gridItem.lovDependency : [gridItem.lovDependency];
+            lov[gridItem.lov] = [];
+            dependencies.forEach(dep => {
+                const depControl = formGroup.get(dep.dependentTo);
+                if (!depControl)
+                    return;
+                depControl.valueChanges
+                    .subscribe(() => {
+                    lov[gridItem.lov] = lov['all'].filter((l) => {
+                        if (l.lovType !== gridItem.lov)
+                            return false;
+                        return dependencies.every(d => {
+                            const depValue = formGroup.get(d.dependentTo)?.value;
+                            return depValue == null || l[d.filterKey]?.split(',').includes(depValue);
+                        });
+                    });
+                    const currentFormControl = formGroup.get(gridItem.id);
+                    const currentValue = currentFormControl.value;
+                    const currentLov = lov[gridItem.lov];
+                    if (gridItem.dataType === DataType.LOM) {
+                        const newValue = currentValue?.filter(v => currentLov.some(l => l.lovCode === v));
+                        currentFormControl.setValue(newValue);
+                    }
+                    else {
+                        if (!currentLov.find(l => l.lovCode === currentValue)) {
+                            currentFormControl.patchValue(null);
+                        }
+                    }
+                });
+            });
+        }
+    });
+    if (module.id) {
+        const idValue = module.id.endsWith("ID") ? 0 : null;
+        formGroup.addControl(module.id, new FormControl(idValue));
+    }
+    return formGroup;
+}
+
+function removeEmptyObject(obj) {
+    const result = {};
+    Object.entries(obj).forEach(([k, v]) => {
+        if (v !== null && v !== '') {
+            result[k] = v;
+        }
+    });
+    return result;
+}
+function filterQueryParams(obj) {
+    obj = cloneDeep(obj);
+    obj = removeEmptyObject(obj);
+    const result = {};
+    Object.entries(obj).forEach(([k, v]) => {
+        if (isArray(v)) {
+            let temp = '';
+            v.forEach((e, i) => {
+                temp += e;
+                if (v.length - 1 !== i) {
+                    temp += `,`;
+                }
+            });
+            result[k] = temp;
+        }
+        else if (v instanceof Date) {
+            result[k] = toDateString(v);
+        }
+        else {
+            result[k] = v;
+        }
+    });
+    return result;
+}
+function cloneDeep(value, visited = new WeakMap()) {
+    // Handle primitive types and functions
+    if (value === null || typeof value !== 'object')
+        return value;
+    // Handle circular references
+    if (visited.has(value))
+        return visited.get(value);
+    // Clone array
+    if (isArray(value)) {
+        const arrCopy = [];
+        visited.set(value, arrCopy);
+        for (let i = 0; i < value.length; i++) {
+            arrCopy[i] = cloneDeep(value[i], visited);
+        }
+        return arrCopy;
+    }
+    // Clone object
+    const objCopy = {};
+    visited.set(value, objCopy);
+    for (const key in value) {
+        if (value.hasOwnProperty(key)) {
+            objCopy[key] = cloneDeep(value[key], visited);
+        }
+    }
+    return objCopy;
+}
+function isArray(value) {
+    return Object.prototype.toString.call(value) === '[object Array]';
+}
+function arrayToString(input) {
+    let temp = '';
+    input.forEach((e, i) => {
+        temp += e;
+        if (input.length - 1 !== i) {
+            temp += `,`;
+        }
+    });
+    return temp;
+}
+function downloadFile(data, fileName = 'excel.xlsx') {
+    let blob = new Blob([data]);
+    let url = window.URL.createObjectURL(blob);
+    const a = document.createElement('a');
+    a.href = url;
+    a.download = fileName;
+    a.click();
+}
+function previewPDF(data, fileName = 'report.pdf') {
+    let blob = new Blob([data], { type: 'application/pdf' });
+    let url = window.URL.createObjectURL(blob);
+    window.open(url, '_blank');
+}
+function constructUrlWithQueryParams(baseUrl, queryParams) {
+    const queryString = Object.keys(queryParams).map((key) => key + '=' + queryParams[key]).join('&');
+    return `${baseUrl}?${queryString}`;
+}
+function toDateString(date) {
+    return date.toDateString();
+}
+
+function mapLov(input, lov) {
+    const result = {};
+    Object.keys(input).forEach(key => {
+        result[key] = lov.filter(l => l.lovType === input[key]);
+    });
+    result['all'] = lov;
+    return result;
+}
+function mapOriginalLov(lov) {
+    const result = lov.reduce((acc, item) => {
+        const key = item.lovType; // The property to group by
+        if (!acc[key]) {
+            acc[key] = []; // Initialize the group if it doesn't exist
+        }
+        acc[key].push(item); // Add the current item to the group
+        return acc;
+    }, {});
+    result['all'] = lov;
+    return result;
+}
+
+class ModeSignalHelper {
+    isView;
+    isModify;
+    isAdd;
+    constructor(mode) {
+        // Destructuring the returned object from the helper method
+        const { isView, isModify, isAdd } = ModeSignalHelper.createModeSignals(mode);
+        this.isView = isView;
+        this.isModify = isModify;
+        this.isAdd = isAdd;
+    }
+    /**
+     * Generates computed signals for the provided mode signal.
+     */
+    static createModeSignals(mode) {
+        const isView = computed(() => mode() === PageMode.VIEW || mode() === 'detail', /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "isView" }] : /* istanbul ignore next */ []));
+        const isModify = computed(() => mode() === PageMode.MODIFY || mode() === 'modify', /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "isModify" }] : /* istanbul ignore next */ []));
+        const isAdd = computed(() => mode() === PageMode.ADD, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "isAdd" }] : /* istanbul ignore next */ []));
+        return { isView: isView, isModify, isAdd };
+    }
+}
+
+function sortSequence(a, b) {
+    // First compare by sequenceNo
+    if (a.sequenceNo < b.sequenceNo)
+        return -1;
+    if (a.sequenceNo > b.sequenceNo)
+        return 1;
+    // If sequenceNo is the same, compare by lovName
+    if (a.lovName < b.lovName)
+        return -1;
+    if (a.lovName > b.lovName)
+        return 1;
+    // If both sequenceNo and lovName are the same
+    return 0;
+}
+
+function trackChanges(oldArray, newArray, keysToCompare, idKey) {
+    let result = [];
+    // Helper function to create a unique key based on specific fields
+    function createKey(item, keys) {
+        return keys
+            .map(key => {
+            let value = item[key];
+            if (Array.isArray(value)) {
+                return value.slice().sort().join('+'); // Sort and join array elements using '+'
+            }
+            return value;
+        })
+            .join('|');
+    }
+    // Convert old and new arrays to maps for easier comparison
+    let oldMap = new Map(oldArray.map(item => [createKey(item, keysToCompare), item]));
+    let newMap = new Map(newArray.map(item => [createKey(item, keysToCompare), item]));
+    // Track deleted and unchanged/modified items
+    for (let [key, oldItem] of oldMap) {
+        const modifiedValue = checkExist(newMap, idKey, oldItem[idKey]);
+        if (!newMap.has(key)) {
+            if (modifiedValue) {
+                result.push({ ...modifiedValue, action: 'MOD' }); // Deleted
+            }
+            else {
+                result.push({ ...oldItem, action: 'DEL' }); // Deleted
+            }
+        }
+    }
+    // Track created items
+    for (let [key, newItem] of newMap) {
+        if (!oldMap.has(key) && !newItem[idKey]) {
+            result.push({ ...newItem, action: 'CRT' }); // Created
+        }
+    }
+    return result;
+}
+function checkExist(myMap, idKey, value) {
+    if (!value) {
+        return false;
+    }
+    for (let [key, myItem] of myMap) {
+        if (myItem[idKey] === value) {
+            return myItem;
+        }
+    }
+    return false;
+}
+
+class ActionCodePipe {
+    actionMapper = ACTION_MAPPER;
+    transform(value) {
+        if (this.actionMapper.hasOwnProperty(value)) {
+            return this.actionMapper[value].text;
+        }
+        return value;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.5", ngImport: i0, type: ActionCodePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "22.1.5", ngImport: i0, type: ActionCodePipe, isStandalone: true, name: "actionCode" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.5", ngImport: i0, type: ActionCodePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'actionCode'
+                }]
+        }] });
+
+class NullPipe {
+    transform(value) {
+        try {
+            if (value === null || value === undefined || (Array.isArray(value) && value.length === 0) || value === '') {
+                return "-";
+            }
+            else {
+                return value;
+            }
+        }
+        catch (e) {
+            return '-';
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.5", ngImport: i0, type: NullPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "22.1.5", ngImport: i0, type: NullPipe, isStandalone: true, name: "null" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.5", ngImport: i0, type: NullPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'null',
+                    standalone: true
+                }]
+        }] });
+
+class BadgeDirective {
+    el;
+    renderer;
+    nxeBadge = ''; // Badge text
+    badgeColor = 'red'; // Default badge color
+    badgePosition = 'top-right';
+    badgeElement = null;
+    constructor(el, renderer) {
+        this.el = el;
+        this.renderer = renderer;
+    }
+    ngOnChanges() {
+        this.updateBadge();
+    }
+    updateBadge() {
+        if (this.badgeElement) {
+            this.renderer.removeChild(this.el.nativeElement, this.badgeElement);
+        }
+        if (!this.nxeBadge)
+            return;
+        this.badgeElement = this.renderer.createElement('div');
+        this.renderer.addClass(this.badgeElement, 'nxe-badge');
+        this.renderer.setStyle(this.badgeElement, 'z-index', 999);
+        this.renderer.setStyle(this.badgeElement, 'background', this.badgeColor);
+        this.renderer.setProperty(this.badgeElement, 'innerText', this.nxeBadge.toString());
+        this.applyPosition();
+        this.renderer.appendChild(this.el.nativeElement, this.badgeElement);
+    }
+    applyPosition() {
+        const positionStyles = {
+            'top-right': 'top: 0; right: 0;',
+            'top-left': 'top: 0; left: 0;',
+            'bottom-right': 'bottom: 0; right: 0;',
+            'bottom-left': 'bottom: 0; left: 0;',
+        };
+        if (this.badgeElement) {
+            this.renderer.setStyle(this.badgeElement, 'position', 'absolute');
+            this.renderer.setStyle(this.badgeElement, 'transform', 'translate(50%, -50%)');
+            this.renderer.setAttribute(this.badgeElement, 'style', positionStyles[this.badgePosition]);
+        }
+    }
+    ngAfterViewInit() {
+        if (this.el) {
+            this.renderer.setStyle(this.el.nativeElement, 'position', 'relative');
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.5", ngImport: i0, type: BadgeDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.1.5", type: BadgeDirective, isStandalone: true, selector: "[nxeBadge]", inputs: { nxeBadge: "nxeBadge", badgeColor: "badgeColor", badgePosition: "badgePosition" }, usesOnChanges: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.5", ngImport: i0, type: BadgeDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[nxeBadge]'
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }], propDecorators: { nxeBadge: [{
+                type: Input
+            }], badgeColor: [{
+                type: Input
+            }], badgePosition: [{
+                type: Input
+            }] } });
+
+class NxeMenu {
+    el;
+    overlay;
+    viewContainerRef;
+    menuTemplate;
+    overlayRef = null;
+    constructor(el, overlay, viewContainerRef) {
+        this.el = el;
+        this.overlay = overlay;
+        this.viewContainerRef = viewContainerRef;
+    }
+    toggleMenu(event) {
+        event.stopPropagation();
+        if (this.overlayRef) {
+            this.closeMenu();
+        }
+        else {
+            this.openMenu();
+        }
+    }
+    onClickOutside(event) {
+        if (this.overlayRef && !this.el.nativeElement.contains(event.target)) {
+            this.closeMenu();
+        }
+    }
+    openMenu() {
+        const positionStrategy = this.overlay
+            .position()
+            .flexibleConnectedTo(this.el.nativeElement)
+            .withPositions([
+            { originX: 'start', originY: 'bottom', overlayX: 'start', overlayY: 'top' },
+            { originX: 'start', originY: 'top', overlayX: 'start', overlayY: 'bottom' },
+        ]);
+        this.overlayRef = this.overlay.create({ positionStrategy });
+        // Fix: Use TemplatePortal instead of ComponentPortal
+        const portal = new TemplatePortal(this.menuTemplate, this.viewContainerRef);
+        this.overlayRef.attach(portal);
+    }
+    closeMenu() {
+        this.overlayRef?.detach();
+        this.overlayRef = null;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.5", ngImport: i0, type: NxeMenu, deps: [{ token: i0.ElementRef }, { token: i1.Overlay }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.1.5", type: NxeMenu, isStandalone: true, selector: "[nxeMenu]", inputs: { menuTemplate: ["nxeMenu", "menuTemplate"] }, host: { listeners: { "click": "toggleMenu($event)", "document:click": "onClickOutside($event)" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.5", ngImport: i0, type: NxeMenu, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[nxeMenu]',
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i1.Overlay }, { type: i0.ViewContainerRef }], propDecorators: { menuTemplate: [{
+                type: Input,
+                args: ['nxeMenu']
+            }], toggleMenu: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }], onClickOutside: [{
+                type: HostListener,
+                args: ['document:click', ['$event']]
+            }] } });
+
+/**
+ * Opens a component in a centred, click-to-dismiss backdrop and resolves when it closes.
+ *
+ * Ported from nextera-library with one required change: `ComponentFactoryResolver` and
+ * `resolveComponentFactory()` are Ivy-era shims that no longer exist in Angular 22, so
+ * instantiation goes through `createComponent()` instead. The behaviour is the same —
+ * the component is created outside any view, attached to the ApplicationRef so it takes
+ * part in change detection, and appended to the backdrop element.
+ *
+ * `data` is assigned onto the instance before the view is attached, so the component sees
+ * its inputs on first render rather than one cycle late.
+ */
+class NxeModalService {
+    injector = inject(Injector);
+    environmentInjector = inject(EnvironmentInjector);
+    applicationRef = inject(ApplicationRef);
+    renderer = inject(RendererFactory2).createRenderer(null, null);
+    componentRef;
+    backdropElement;
+    closeSubject;
+    open(component, data) {
+        this.closeSubject = new Subject();
+        this.createBackdrop();
+        const componentRef = createComponent(component, {
+            environmentInjector: this.environmentInjector,
+            elementInjector: this.injector,
+        });
+        if (data) {
+            Object.assign(componentRef.instance, data);
+        }
+        this.applicationRef.attachView(componentRef.hostView);
+        this.renderer.appendChild(this.backdropElement, componentRef.location.nativeElement);
+        this.componentRef = componentRef;
+        return this.closeSubject.asObservable();
+    }
+    close(result) {
+        if (this.componentRef) {
+            this.applicationRef.detachView(this.componentRef.hostView);
+            this.componentRef.destroy();
+            this.componentRef = undefined;
+        }
+        if (this.backdropElement) {
+            this.renderer.removeChild(document.body, this.backdropElement);
+            this.backdropElement = undefined;
+        }
+        this.closeSubject?.next(result);
+        this.closeSubject?.complete();
+    }
+    createBackdrop() {
+        const el = this.renderer.createElement('div');
+        this.renderer.addClass(el, 'modal-backdrop');
+        const style = {
+            position: 'fixed',
+            top: '0',
+            left: '0',
+            width: '100%',
+            height: '100%',
+            background: 'rgba(0, 0, 0, 0.5)',
+            'z-index': '1000',
+            display: 'flex',
+            'align-items': 'center',
+            'justify-content': 'center',
+        };
+        for (const [prop, value] of Object.entries(style)) {
+            this.renderer.setStyle(el, prop, value);
+        }
+        this.renderer.listen(el, 'click', () => this.close());
+        document.body.appendChild(el);
+        this.backdropElement = el;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.5", ngImport: i0, type: NxeModalService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.1.5", ngImport: i0, type: NxeModalService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.5", ngImport: i0, type: NxeModalService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+// @nexterajs/app-kit — public API.
+//
+// The metadata-driven application framework that used to ship inside nextera-library:
+// module/page metadata, action constants, and the pure helpers built on them. It is
+// deliberately separate from @nexterajs/ui — this half is coupled to a specific backend
+// shape, and an app that only wants components should not have to take it.
+/* Module metadata — the shape a module declares its pages with */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { ACTION_MAPPER, ActionCode, ActionCodePipe, BadgeDirective, BooleanOperator, ConditionEvaluator, ConditionOperator, ConditionType, DataType, LayoutType, MappedLov, ModeSignalHelper, NullPipe, NxeMenu, NxeModalService, PageMode, ValueChangeEvent, ValueOperator, arrayToString, constructUrlWithQueryParams, createFormGroup, downloadFile, extractGridItems, filterQueryParams, getActionActivated, getActionAddSubTreaty, getActionAddToPayment, getActionApproval, getActionBind, getActionBinding, getActionCalculate, getActionCancel, getActionConfirm, getActionConvertToProposal, getActionCorrection, getActionDelete, getActionDivider, getActionDownload, getActionExtendDueDate, getActionExtract, getActionFinalize, getActionIssue, getActionLock, getActionModify, getActionNew, getActionPlacement, getActionPosting, getActionPrint, getActionReactivate, getActionResetPassword, getActionReverse, getActionRollback, getActionRun, getActionSend, getActionSendForApproval, getActionTerminate, getActionTerminated, getActionUnlock, getActionUnposting, getActionValidate, getActionView, mapLov, mapOriginalLov, previewPDF, removeEmptyObject, sortSequence, toDateString, trackChanges };
+//# sourceMappingURL=nexterajs-app-kit.mjs.map