@wavemaker-ai/app-ng-runtime 1.0.0-rc.647469

package/components/base/esm2022/pipes/trust-as.pipe.mjs

@@ -0,0 +1,41 @@
+import { Pipe, SecurityContext } from '@angular/core';
+import { DomSanitizer } from '@angular/platform-browser';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/platform-browser";
+export class TrustAsPipe {
+    constructor(domSanitizer) {
+        this.domSanitizer = domSanitizer;
+    }
+    transform(content, context) {
+        if (content === null || content === undefined) {
+            return '';
+        }
+        switch (context) {
+            case 'html':
+            case SecurityContext.HTML:
+                return this.domSanitizer.bypassSecurityTrustHtml(content);
+            case 'style':
+            case SecurityContext.STYLE:
+                return this.domSanitizer.bypassSecurityTrustStyle(content);
+            case 'script':
+            case SecurityContext.SCRIPT:
+                return this.domSanitizer.bypassSecurityTrustScript(content);
+            case 'url':
+            case SecurityContext.URL:
+                return this.domSanitizer.bypassSecurityTrustUrl(content);
+            case 'resource':
+            case SecurityContext.RESOURCE_URL:
+                return this.domSanitizer.bypassSecurityTrustResourceUrl(content);
+        }
+    }
+    static { this.ɵfac = function TrustAsPipe_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || TrustAsPipe)(i0.ɵɵdirectiveInject(i1.DomSanitizer, 16)); }; }
+    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "trustAs", type: TrustAsPipe, pure: true, standalone: true }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TrustAsPipe, [{
+        type: Pipe,
+        args: [{
+                standalone: true,
+                name: 'trustAs'
+            }]
+    }], () => [{ type: i1.DomSanitizer }], null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/components/base/esm2022/pipes/wm-pipe.mjs

@@ -0,0 +1,18 @@
+import { isFunction } from "lodash-es";
+export class WmPipe {
+    constructor(pipeName, customPipeManager) {
+        this.pipeName = pipeName;
+        this.customPipeManager = customPipeManager;
+        this.pipeRef = this.customPipeManager ? this.customPipeManager.getCustomPipe(pipeName) : null;
+        this.isCustomPipe = this.pipeRef && isFunction(this.pipeRef.formatter);
+    }
+    customFormatter(data, args, variables) {
+        try {
+            return this.pipeRef.formatter(...args, variables);
+        }
+        catch (error) {
+            return data;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid20tcGlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NvbXBvbmVudHMvYmFzZS9zcmMvcGlwZXMvd20tcGlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEVBQUMsVUFBVSxFQUFDLE1BQU0sV0FBVyxDQUFDO0FBRXJDLE1BQU0sT0FBTyxNQUFNO0lBR2YsWUFBb0IsUUFBUSxFQUFZLGlCQUFvQztRQUF4RCxhQUFRLEdBQVIsUUFBUSxDQUFBO1FBQVksc0JBQWlCLEdBQWpCLGlCQUFpQixDQUFtQjtRQUN4RSxJQUFJLENBQUMsT0FBTyxHQUFHLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLGlCQUFpQixDQUFDLGFBQWEsQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDO1FBQzlGLElBQUksQ0FBQyxZQUFZLEdBQUcsSUFBSSxDQUFDLE9BQU8sSUFBSSxVQUFVLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxTQUFTLENBQUMsQ0FBQztJQUMzRSxDQUFDO0lBRUQsZUFBZSxDQUFDLElBQUksRUFBRSxJQUFJLEVBQUUsU0FBUztRQUNqQyxJQUFJLENBQUM7WUFDRCxPQUFPLElBQUksQ0FBQyxPQUFPLENBQUMsU0FBUyxDQUFDLEdBQUcsSUFBSSxFQUFFLFNBQVMsQ0FBQyxDQUFDO1FBQ3RELENBQUM7UUFBQyxPQUFPLEtBQUssRUFBRSxDQUFDO1lBQ2IsT0FBTyxJQUFJLENBQUM7UUFDaEIsQ0FBQztJQUNMLENBQUM7Q0FDSiIsInNvdXJjZXNDb250ZW50IjpbIlxuaW1wb3J0IHsgQ3VzdG9tUGlwZU1hbmFnZXIgfSBmcm9tICdAd20vY29yZSc7XG5pbXBvcnQge2lzRnVuY3Rpb259IGZyb20gXCJsb2Rhc2gtZXNcIjtcblxuZXhwb3J0IGNsYXNzIFdtUGlwZSB7XG4gICAgcHJvdGVjdGVkIHBpcGVSZWY7XG4gICAgcHJvdGVjdGVkIGlzQ3VzdG9tUGlwZTtcbiAgICBjb25zdHJ1Y3Rvcihwcml2YXRlIHBpcGVOYW1lLCBwcm90ZWN0ZWQgY3VzdG9tUGlwZU1hbmFnZXI6IEN1c3RvbVBpcGVNYW5hZ2VyKSB7XG4gICAgICAgIHRoaXMucGlwZVJlZiA9IHRoaXMuY3VzdG9tUGlwZU1hbmFnZXIgPyB0aGlzLmN1c3RvbVBpcGVNYW5hZ2VyLmdldEN1c3RvbVBpcGUocGlwZU5hbWUpIDogbnVsbDtcbiAgICAgICAgdGhpcy5pc0N1c3RvbVBpcGUgPSB0aGlzLnBpcGVSZWYgJiYgaXNGdW5jdGlvbih0aGlzLnBpcGVSZWYuZm9ybWF0dGVyKTtcbiAgICB9XG5cbiAgICBjdXN0b21Gb3JtYXR0ZXIoZGF0YSwgYXJncywgdmFyaWFibGVzKSB7XG4gICAgICAgIHRyeSB7XG4gICAgICAgICAgICByZXR1cm4gdGhpcy5waXBlUmVmLmZvcm1hdHRlciguLi5hcmdzLCB2YXJpYWJsZXMpO1xuICAgICAgICB9IGNhdGNoIChlcnJvcikge1xuICAgICAgICAgICAgcmV0dXJuIGRhdGE7XG4gICAgICAgIH1cbiAgICB9XG59XG4iXX0=

package/components/base/esm2022/public_api.mjs

@@ -0,0 +1,36 @@
+export { Live_Operations, ALLFIELDS, LIVE_CONSTANTS, performDataOperation, refreshDataSource, fetchRelatedFieldData, interpolateBindExpressions, getDistinctFieldProperties, getDistinctValues, fetchDistinctValues, getDistinctValuesForField, getRangeFieldValue, getRangeMatchMode, getEnableEmptyFilter, getEmptyMatchMode, createArrayFrom, applyFilterOnField, transformData } from './utils/data-utils';
+export { getOrderedDataset, transformDataWithKeys, extractDataAsArray, convertDataToObject, transformFormData, getUniqObjsByDataField, setItemByCompare, groupData, filterDate, toggleAllHeaders, handleHeaderClick, configureDnD, DataSetItem } from './utils/form-utils';
+export { EDIT_MODE, setHeaderConfig, setHeaderConfigForTable, getRowOperationsColumn, getFieldLayoutConfig, getDefaultViewModeWidget, parseValueByType, getFieldTypeWidgetTypesMap, getDataTableFilterWidget, getEditModeWidget, getDefaultValue } from './utils/live-utils';
+export { getObjValueByKey, getEvaluatedData, isActiveNavItem, hasLinkToCurrentPage, getOrderByExpr, isDataSetWidget, getCurrentWidgets, getImageUrl, getBackGroundImageUrl, provideAs, provideAsWidgetRef, provideAsDialogRef, unsupportedStatePersistenceTypes, NAVIGATION_TYPE, INPUTMODE, AUTOCLOSE_TYPE, getWatchIdentifier, getMatchModeTypesMap, getMatchModeMsgs, getConditionalClasses, prepareFieldDefs, getContainerTargetClass, extractDataSourceName, setFocusTrap, getKeyboardFocusableElements } from './utils/widget-utils';
+export { BaseComponent } from './widgets/common/base/base.component';
+export * from './widgets/common/base/base-container.component';
+export { DatasetAwareNavComponent } from './widgets/common/base/dataset-aware-nav.component';
+export * from './widgets/common/base/partial-container.directive';
+export * from './widgets/common/base/custom-widget-container.directive';
+export * from './widgets/common/base/base-field-validations';
+export * from './widgets/common/item-template/item-template.directive';
+export * from './widgets/common/repeat-template/repeat-template.directive';
+export * from './widgets/common/base/stylable.component';
+export * from './widgets/common/message/message.component';
+export * from './widgets/common/pull-to-refresh/pull-to-refresh';
+export * from './widgets/common/partial/partial.directive';
+export * from './widgets/common/redraw/redrawable.directive';
+export * from './widgets/framework/constants';
+export { updateDeviceView } from './widgets/framework/deviceview';
+export * from './widgets/framework/styler';
+export * from './widgets/framework/types';
+export * from './widgets/framework/widget-id-generator';
+export { getWidgetPropsByType, register, registerFormWidget, PROP_TYPE, PROP_STRING, PROP_NUMBER, PROP_BOOLEAN, PROP_ANY } from './widgets/framework/widget-props';
+export * from './widgets/common/dialog/dialog.service';
+export { ToDatePipe, ToNumberPipe, ToCurrencyPipe, PrefixPipe, SuffixPipe, CustomPipe, TimeFromNowPipe, NumberToStringPipe, StringToNumberPipe, FilterPipe, FileSizePipe, FileIconClassPipe, StateClassPipe, FileExtensionFromMimePipe, TrailingZeroDecimalPipe, TemplateReplacePipe } from './pipes/custom-pipes';
+export * from './pipes/trust-as.pipe';
+export * from './pipes/sanitize.pipe';
+export * from './pipes/image.pipe';
+export * from './widgets/common/container/container.directive';
+export * from './widgets/common/lazy-load/lazy-load.directive';
+export * from './widgets/common/partial-param/partial-param.directive';
+export * from './widgets/common/base/text-content.directive';
+export * from './directives/show-in-device.directive';
+export * from './decorators/autolayout.decorator';
+export * from './decorators/autolayout.props';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"public_api.js","sourceRoot":"","sources":["../../../../projects/components/base/src/public_api.ts"],"names":[],"mappings":"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","sourcesContent":["import {Live_Operations} from './utils/data-utils';\n\nexport {\n    Live_Operations,\n    ALLFIELDS,\n    LIVE_CONSTANTS,\n    performDataOperation,\n    refreshDataSource,\n    fetchRelatedFieldData,\n    interpolateBindExpressions,\n    getDistinctFieldProperties,\n    getDistinctValues,\n    fetchDistinctValues,\n    getDistinctValuesForField,\n    getRangeFieldValue,\n    getRangeMatchMode,\n    getEnableEmptyFilter,\n    getEmptyMatchMode,\n    createArrayFrom,\n    applyFilterOnField,\n    transformData\n} from './utils/data-utils';\nexport {\n    getOrderedDataset,\n    transformDataWithKeys,\n    extractDataAsArray,\n    convertDataToObject,\n    transformFormData,\n    getUniqObjsByDataField,\n    setItemByCompare,\n    groupData,\n    filterDate,\n    toggleAllHeaders,\n    handleHeaderClick,\n    configureDnD,\n    DataSetItem\n} from './utils/form-utils';\nexport {\n    EDIT_MODE,\n    setHeaderConfig,\n    setHeaderConfigForTable,\n    getRowOperationsColumn,\n    getFieldLayoutConfig,\n    getDefaultViewModeWidget,\n    parseValueByType,\n    getFieldTypeWidgetTypesMap,\n    getDataTableFilterWidget,\n    getEditModeWidget,\n    getDefaultValue\n} from './utils/live-utils';\nexport {\n    getObjValueByKey,\n    getEvaluatedData,\n    isActiveNavItem,\n    hasLinkToCurrentPage,\n    getOrderByExpr,\n    isDataSetWidget,\n    getCurrentWidgets,\n    getImageUrl,\n    getBackGroundImageUrl,\n    provideAs,\n    provideAsWidgetRef,\n    provideAsDialogRef,\n    unsupportedStatePersistenceTypes,\n    NAVIGATION_TYPE,\n    INPUTMODE,\n    AUTOCLOSE_TYPE,\n    getWatchIdentifier,\n    getMatchModeTypesMap,\n    getMatchModeMsgs,\n    getConditionalClasses,\n    prepareFieldDefs ,\n    getContainerTargetClass,\n    extractDataSourceName,\n    setFocusTrap,\n    getKeyboardFocusableElements\n} from './utils/widget-utils';\nexport {\n    BaseComponent\n} from './widgets/common/base/base.component';\nexport * from './widgets/common/base/base-container.component';\nexport {\n    DatasetAwareNavComponent,\n    NavNode\n} from './widgets/common/base/dataset-aware-nav.component';\nexport * from './widgets/common/base/partial-container.directive';\nexport * from './widgets/common/base/custom-widget-container.directive';\nexport * from './widgets/common/base/base-field-validations';\nexport * from './widgets/common/item-template/item-template.directive';\nexport * from './widgets/common/repeat-template/repeat-template.directive';\nexport * from './widgets/common/base/stylable.component';\nexport * from './widgets/common/message/message.component';\nexport * from './widgets/common/pull-to-refresh/pull-to-refresh';\nexport * from './widgets/common/partial/partial.directive';\nexport * from './widgets/common/redraw/redrawable.directive';\nexport * from './widgets/framework/constants';\nexport {\n    updateDeviceView\n} from './widgets/framework/deviceview';\nexport * from './widgets/framework/styler';\nexport * from './widgets/framework/types';\nexport * from './widgets/framework/widget-id-generator';\nexport {\n    getWidgetPropsByType,\n    register,\n    registerFormWidget,\n    PROP_TYPE,\n    PROP_STRING,\n    PROP_NUMBER,\n    PROP_BOOLEAN,\n    PROP_ANY\n} from './widgets/framework/widget-props';\nexport * from './widgets/common/dialog/dialog.service';\nexport {\n    ToDatePipe,\n    ToNumberPipe,\n    ToCurrencyPipe,\n    PrefixPipe,\n    SuffixPipe,\n    CustomPipe,\n    TimeFromNowPipe,\n    NumberToStringPipe,\n    StringToNumberPipe,\n    FilterPipe,\n    FileSizePipe,\n    FileIconClassPipe,\n    StateClassPipe,\n    FileExtensionFromMimePipe,\n    TrailingZeroDecimalPipe,\n    TemplateReplacePipe\n} from './pipes/custom-pipes';\nexport * from './pipes/trust-as.pipe';\nexport * from './pipes/sanitize.pipe';\nexport * from './pipes/image.pipe';\nexport * from './widgets/common/container/container.directive';\nexport * from './widgets/common/lazy-load/lazy-load.directive';\nexport * from './widgets/common/partial-param/partial-param.directive';\nexport * from './widgets/common/base/text-content.directive';\nexport * from './directives/show-in-device.directive';\nexport * from './decorators/autolayout.decorator';\nexport * from './decorators/autolayout.props';\n"]}

package/components/base/esm2022/utils/autolayout-utils.mjs

@@ -0,0 +1,261 @@
+export class AutoLayoutUtils {
+    constructor() {
+        this.direction = 'row';
+        this.hasWrap = false;
+        this.alignment = 'top-left';
+        // Alignment matrix
+        this.alignmentMatrix = {
+            'top-left': { justifyContent: 'flex-start', alignItems: 'flex-start' },
+            'top-center': { justifyContent: 'center', alignItems: 'flex-start' },
+            'top-right': { justifyContent: 'flex-end', alignItems: 'flex-start' },
+            'middle-left': { justifyContent: 'flex-start', alignItems: 'center' },
+            'middle-center': { justifyContent: 'center', alignItems: 'center' },
+            'middle-right': { justifyContent: 'flex-end', alignItems: 'center' },
+            'bottom-left': { justifyContent: 'flex-start', alignItems: 'flex-end' },
+            'bottom-center': { justifyContent: 'center', alignItems: 'flex-end' },
+            'bottom-right': { justifyContent: 'flex-end', alignItems: 'flex-end' },
+            'start': { justifyContent: 'space-between', alignItems: 'flex-start' },
+            'center': { justifyContent: 'space-between', alignItems: 'center' },
+            'end': { justifyContent: 'space-between', alignItems: 'flex-end' }
+        };
+    }
+    /** Apply direction (row/column) */
+    applyDirection(direction) {
+        this.direction = direction;
+        if (direction === 'column')
+            this.hasWrap = false;
+        this.$element.css({ display: 'flex', flexDirection: direction });
+        this.applyAlignment(this.alignment);
+    }
+    /** Apply wrapping */
+    applyWrap(wrap) {
+        this.hasWrap = wrap;
+        this.$element.css('flex-wrap', wrap ? 'wrap' : 'nowrap');
+    }
+    /** Apply alignment based on direction */
+    applyAlignment(alignmentKey) {
+        if (!alignmentKey)
+            return;
+        const base = this.alignmentMatrix[alignmentKey];
+        if (!base)
+            return;
+        const isRow = this.direction === 'row';
+        let justifyContent = isRow ? base.justifyContent : base.alignItems;
+        let alignItems = isRow ? base.alignItems : base.justifyContent;
+        this.$element.css({
+            display: 'flex',
+            'flex-wrap': this.hasWrap ? 'wrap' : 'nowrap',
+            justifyContent,
+            alignItems
+        });
+    }
+    /** Apply spacing for gap + column gap */
+    applySpacing(key, nv) {
+        const base = this.alignmentMatrix[this.alignment];
+        if (!base)
+            return;
+        const gapValue = key === 'gap' ? nv : this.gap;
+        const colValue = key === 'columngap' ? nv : this.columngap;
+        const isRow = this.direction === 'row';
+        const gapVal = (gapValue && gapValue !== 'auto') ? gapValue : null;
+        const colVal = (colValue && colValue !== 'auto') ? colValue : null;
+        const rowVal = this.hasWrap && gapVal ? gapVal : null;
+        let justifyContent = isRow ? base.justifyContent : base.alignItems;
+        let alignItems = isRow ? base.alignItems : base.justifyContent;
+        // ————— NO WRAP —————
+        if (!this.hasWrap) {
+            if (gapValue === 'auto') {
+                this.$element.css({
+                    'justify-content': base.justifyContent,
+                    'align-items': base.alignItems
+                });
+            }
+            else {
+                this.$element.css({
+                    'justify-content': justifyContent,
+                    'align-items': alignItems,
+                    gap: `${gapVal}px`
+                });
+            }
+        }
+        // ————— WRAP LOGIC —————
+        else {
+            if (gapValue === 'auto' && colValue === 'auto') {
+                this.$element.css({
+                    'justify-content': justifyContent,
+                    'align-content': justifyContent
+                });
+            }
+            else if (gapValue !== 'auto' && colValue === 'auto') {
+                this.$element.css({
+                    'justify-content': justifyContent,
+                    'align-content': alignItems,
+                    'row-gap': `${rowVal}px`
+                });
+            }
+            else if (gapValue === 'auto' && colValue !== 'auto') {
+                this.$element.css({
+                    'align-content': 'space-between',
+                    'column-gap': `${colVal}px`
+                });
+            }
+            else {
+                if (colVal && rowVal) {
+                    if (colVal === rowVal) {
+                        this.$element.css({
+                            'gap': `${colVal}px`,
+                            'align-content': alignItems,
+                            'justify-content': justifyContent
+                        });
+                    }
+                    else {
+                        this.$element.css({
+                            'gap': `${rowVal}px ${colVal}px`,
+                            'align-content': alignItems,
+                            'justify-content': justifyContent
+                        });
+                    }
+                }
+            }
+        }
+        this.gap = gapValue?.toString();
+        this.columngap = colValue?.toString();
+    }
+    onPropertyChange(key, nv, ov) {
+        switch (key) {
+            case 'direction':
+                this.applyDirection(nv);
+                break;
+            case 'wrap':
+                this.applyWrap(nv);
+                break;
+            case 'alignment':
+                this.alignment = nv;
+                this.applyAlignment(nv);
+                break;
+            case 'gap':
+            case 'columngap':
+                setTimeout(() => {
+                    this.applySpacing(key, nv);
+                });
+                break;
+            case 'position':
+                this.position = nv;
+                this.handlePosition();
+                break;
+            case 'clipcontent':
+                this.clipContent = nv;
+                this.handleClipBehaviour();
+                break;
+        }
+    }
+    applyStyleChange(key, nv) {
+        if (key === 'width' || key === 'height') {
+            this.applySize(key, nv);
+        }
+        else if (key === 'padding') {
+            this.$element.css('padding', nv);
+        }
+        else if (key === 'overflow') {
+            this.overflowtype = nv;
+            this.handleClipBehaviour();
+        }
+        else if (key === 'zindex') {
+            this.zIndex = nv;
+            this.handlePosition();
+        }
+    }
+    applySize(key, nv) {
+        if (nv === 'fill') {
+            const element = this.$element?.[0];
+            // If element or parent doesn't exist → fallback to 100%
+            if (!element?.parentElement) {
+                this.$element.css(key, '100%');
+                return;
+            }
+            const parent = element.parentElement;
+            const parentStyle = getComputedStyle(parent);
+            const isParentFlex = ['flex', 'inline-flex'].includes(parentStyle.display);
+            if (!isParentFlex) {
+                // Non-flex parent → fallback
+                this.$element.css(key, '100%');
+                return;
+            }
+            const flexDirection = parentStyle.flexDirection;
+            const isRow = ['row', 'row-reverse'].includes(flexDirection);
+            const isMainAxis = (key === 'width' && isRow) || (key === 'height' && !isRow);
+            if (isMainAxis) {
+                this.$element.css('flex-grow', '1');
+            }
+            else {
+                this.$element.css('align-self', 'stretch');
+            }
+        }
+        else if (nv === 'hug') {
+            if (key === 'width') {
+                this.$element.css('width', 'fit-content');
+            }
+            if (key === 'height') {
+                this.$element.css('height', 'fit-content');
+            }
+        }
+        else {
+            this.$element.css('flex-shrink', '0'); // Don't shrink when size is fixed
+        }
+    }
+    // Determine whether the container should clip its content and configure scrolling behaviour accordingly.
+    handleClipBehaviour() {
+        const overflow = this.overflowtype?.toLowerCase();
+        switch (overflow) {
+            case 'vertical':
+                this.$element.css({
+                    'overflow-x': 'hidden',
+                    'overflow-y': 'scroll'
+                });
+                break;
+            case 'horizontal':
+                this.$element.css({
+                    'overflow-x': 'scroll',
+                    'overflow-y': 'hidden'
+                });
+                break;
+            case 'both directions':
+                this.$element.css({
+                    'overflow': 'scroll'
+                });
+                break;
+            case 'no scrolling':
+                if (this.clipContent) {
+                    this.$element.css({ 'overflow': 'hidden' });
+                }
+                else {
+                    this.$element.css({ 'overflow': '' });
+                }
+                break;
+            default:
+                break;
+        }
+    }
+    // Toggle and apply positional behaviour and expose the z-index control when position is not relative.
+    handlePosition() {
+        if (this.position === 'sticky') {
+            // Apply sticky styles
+            this.$element.css({
+                'position': 'sticky',
+                'top': '0', // Sticks to top when scrolling vertically
+                'left': '0', // Sticks to left when scrolling horizontally
+                'z-index': this.zIndex
+            });
+        }
+        else {
+            // Reset to default (static/relative behavior)
+            this.$element.css({
+                'position': '',
+                'top': '',
+                'left': '',
+                'z-index': ''
+            });
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"autolayout-utils.js","sourceRoot":"","sources":["../../../../../projects/components/base/src/utils/autolayout-utils.ts"],"names":[],"mappings":"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","sourcesContent":["export class AutoLayoutUtils {\n\n    direction: 'row' | 'column' = 'row';\n    hasWrap = false;\n    alignment: string = 'top-left';\n    gap: string;\n    columngap: string;\n    clipContent: string;\n    position: string;\n    overflowtype: string;\n    zIndex: string;\n\n    protected nativeElement!: HTMLElement;\n    protected $element!: any;\n    protected parentElement!: HTMLElement | null;\n\n\n    // Alignment matrix\n    private readonly alignmentMatrix = {\n        'top-left': { justifyContent: 'flex-start', alignItems: 'flex-start' },\n        'top-center': { justifyContent: 'center', alignItems: 'flex-start' },\n        'top-right': { justifyContent: 'flex-end', alignItems: 'flex-start' },\n\n        'middle-left': { justifyContent: 'flex-start', alignItems: 'center' },\n        'middle-center': { justifyContent: 'center', alignItems: 'center' },\n        'middle-right': { justifyContent: 'flex-end', alignItems: 'center' },\n\n        'bottom-left': { justifyContent: 'flex-start', alignItems: 'flex-end' },\n        'bottom-center': { justifyContent: 'center', alignItems: 'flex-end' },\n        'bottom-right': { justifyContent: 'flex-end', alignItems: 'flex-end' },\n\n        'start': { justifyContent: 'space-between', alignItems: 'flex-start' },\n        'center': { justifyContent: 'space-between', alignItems: 'center' },\n        'end': { justifyContent: 'space-between', alignItems: 'flex-end' }\n    };\n\n    constructor() { }\n\n    /** Apply direction (row/column) */\n    applyDirection(direction: 'row' | 'column') {\n        this.direction = direction;\n        if (direction === 'column') this.hasWrap = false;\n\n        this.$element.css({ display: 'flex', flexDirection: direction });\n        this.applyAlignment(this.alignment);\n    }\n\n    /** Apply wrapping */\n    applyWrap(wrap: boolean) {\n        this.hasWrap = wrap;\n        this.$element.css('flex-wrap', wrap ? 'wrap' : 'nowrap');\n    }\n\n    /** Apply alignment based on direction */\n    applyAlignment(alignmentKey: string) {\n        if (!alignmentKey) return;\n\n        const base = (this.alignmentMatrix as any)[alignmentKey];\n        if (!base) return;\n\n        const isRow = this.direction === 'row';\n\n        let justifyContent = isRow ? base.justifyContent : base.alignItems;\n        let alignItems = isRow ? base.alignItems : base.justifyContent;\n\n        this.$element.css({\n            display: 'flex',\n            'flex-wrap': this.hasWrap ? 'wrap' : 'nowrap',\n            justifyContent,\n            alignItems\n        });\n    }\n\n    /** Apply spacing for gap + column gap */\n    applySpacing(key: string, nv: string) {\n        const base = (this.alignmentMatrix as any)[this.alignment];\n        if (!base) return;\n\n        const gapValue = key === 'gap' ? nv : this.gap;\n        const colValue = key === 'columngap' ? nv : this.columngap;\n\n        const isRow = this.direction === 'row';\n\n        const gapVal = (gapValue && gapValue !== 'auto') ? gapValue : null;\n        const colVal = (colValue && colValue !== 'auto') ? colValue : null;\n        const rowVal = this.hasWrap && gapVal ? gapVal : null;\n\n        let justifyContent = isRow ? base.justifyContent : base.alignItems;\n        let alignItems = isRow ? base.alignItems : base.justifyContent;\n\n        // ————— NO WRAP —————\n        if (!this.hasWrap) {\n            if (gapValue === 'auto') {\n                this.$element.css({\n                    'justify-content': base.justifyContent,\n                    'align-items': base.alignItems\n                });\n            } else {\n                this.$element.css({\n                    'justify-content': justifyContent,\n                    'align-items': alignItems,\n                    gap: `${gapVal}px`\n                });\n            }\n        }\n\n        // ————— WRAP LOGIC —————\n        else {\n            if (gapValue === 'auto' && colValue === 'auto') {\n                this.$element.css({\n                    'justify-content': justifyContent,\n                    'align-content': justifyContent\n                });\n            }\n            else if (gapValue !== 'auto' && colValue === 'auto') {\n                this.$element.css({\n                    'justify-content': justifyContent,\n                    'align-content': alignItems,\n                    'row-gap': `${rowVal}px`\n                });\n            }\n            else if (gapValue === 'auto' && colValue !== 'auto') {\n                this.$element.css({\n                    'align-content': 'space-between',\n                    'column-gap': `${colVal}px`\n                });\n            }\n            else {\n                if (colVal && rowVal) {\n                    if (colVal === rowVal) {\n                        this.$element.css({\n                            'gap': `${colVal}px`,\n                            'align-content': alignItems,\n                            'justify-content': justifyContent\n                        });\n                    } else {\n                        this.$element.css({\n                            'gap': `${rowVal}px ${colVal}px`,\n                            'align-content': alignItems,\n                            'justify-content': justifyContent\n                        });\n                    }\n                }\n            }\n        }\n\n        this.gap = gapValue?.toString();\n        this.columngap = colValue?.toString();\n    }\n\n    onPropertyChange(key: string, nv: any, ov?: any) {\n        switch (key) {\n            case 'direction':\n                this.applyDirection(nv);\n                break;\n            case 'wrap':\n                this.applyWrap(nv);\n                break;\n            case 'alignment':\n                this.alignment = nv;\n                this.applyAlignment(nv);\n                break;\n            case 'gap':\n            case 'columngap':\n                setTimeout(() => {\n                    this.applySpacing(key, nv);\n                });\n                break;\n            case 'position':\n                this.position = nv;\n                this.handlePosition();\n                break;\n            case 'clipcontent':\n                this.clipContent = nv;\n                this.handleClipBehaviour();\n                break;\n        }\n    }\n\n    applyStyleChange(key: string, nv: any,) {\n\n        if (key === 'width' || key === 'height') {\n            this.applySize(key, nv);\n        }\n\n        else if (key === 'padding') {\n            this.$element.css('padding', nv);\n        }\n\n        else if(key === 'overflow') {\n            this.overflowtype = nv;\n            this.handleClipBehaviour();\n        }\n\n        else if(key === 'zindex') {\n            this.zIndex = nv;\n            this.handlePosition();\n        }\n    }\n\n    private applySize(key: string, nv: any) {\n\n        if (nv === 'fill') {\n            const element = this.$element?.[0];\n            // If element or parent doesn't exist → fallback to 100%\n            if (!element?.parentElement) {\n                this.$element.css(key, '100%');\n                return;\n            }\n            const parent = element.parentElement;\n            const parentStyle = getComputedStyle(parent);\n            const isParentFlex = ['flex', 'inline-flex'].includes(parentStyle.display);\n            if (!isParentFlex) {\n                // Non-flex parent → fallback\n                this.$element.css(key, '100%');\n                return;\n            }\n            const flexDirection = parentStyle.flexDirection;\n            const isRow = ['row', 'row-reverse'].includes(flexDirection);\n            const isMainAxis = (key === 'width' && isRow) || (key === 'height' && !isRow);\n            if (isMainAxis) {\n                this.$element.css('flex-grow', '1');\n            } else {\n                this.$element.css('align-self', 'stretch');\n            }\n        }else if (nv === 'hug') {\n\n            if (key === 'width') {\n                this.$element.css('width', 'fit-content');\n            }\n\n            if (key === 'height') {\n                this.$element.css('height', 'fit-content');\n            }\n        } else {\n            this.$element.css('flex-shrink', '0'); // Don't shrink when size is fixed\n        }\n    }\n\n    // Determine whether the container should clip its content and configure scrolling behaviour accordingly.\n    private handleClipBehaviour() {\n\n        const overflow = this.overflowtype?.toLowerCase();\n        switch (overflow) {\n            case 'vertical':\n                this.$element.css({\n                    'overflow-x': 'hidden',\n                    'overflow-y': 'scroll'\n                });\n                break;\n\n            case 'horizontal':\n                this.$element.css({\n                    'overflow-x': 'scroll',\n                    'overflow-y': 'hidden'\n                });\n                break;\n\n            case 'both directions':\n                this.$element.css({\n                    'overflow': 'scroll'\n                });\n                break;\n\n            case 'no scrolling':\n                if (this.clipContent) {\n                    this.$element.css({ 'overflow': 'hidden' });\n                } else {\n                    this.$element.css({ 'overflow': '' });\n                }\n                break;\n\n            default:\n                break;\n        }\n\n    }\n\n    // Toggle and apply positional behaviour and expose the z-index control when position is not relative.\n    private handlePosition() {\n        if (this.position === 'sticky') {\n            // Apply sticky styles\n            this.$element.css({\n                'position': 'sticky',\n                'top': '0',    // Sticks to top when scrolling vertically\n                'left': '0',   // Sticks to left when scrolling horizontally\n                'z-index': this.zIndex\n            });\n        } else {\n            // Reset to default (static/relative behavior)\n            this.$element.css({\n                'position': '',\n                'top': '',\n                'left': '',\n                'z-index': ''\n            });\n        }\n    }\n\n\n}\n"]}