@acorex/modules 20.2.0-next.2 → 20.2.0-next.4

package/fesm2022/acorex-modules-common.mjs

@@ -1,2 +1,1223 @@
-export { c as AXMCommonModule, d as AXMEntityProvider, l as AXMLockPopupWorkflow, k as AXMLockPopupWorkflowAction, e as AXMMenuProvider, f as AXMSearchCommandProvider, g as AXMSettingProvider, n as AXMUnlockConfirmWorkflow, m as AXMUnlockConfirmWorkflowAction, i as AXPGlobalSearchModule, A as AXPGlobalSearchViewModel, o as AXPLockPopupComponent, j as AXPVersionHistoryModule, a as AXPWidgetsList, h as AXP_GLOBAL_SEARCH_CONFIG_TOKEN, R as RootConfig } from './acorex-modules-common-acorex-modules-common-D06CT4CO.mjs';
+import { AXPSessionService, AXP_PERMISSION_DEFINITION_PROVIDER } from '@acorex/platform/auth';
+import { AXPHomePageService, AXPSearchCommandProvider, AXPSearchService, AXPSettingService, AXPLockService, AXP_MENU_PROVIDER, AXP_SETTING_DEFINITION_PROVIDER, AXP_SEARCH_PROVIDER } from '@acorex/platform/common';
+import { AXPEntityDefinitionRegistryService, AXP_ENTITY_DEFINITION_LOADER } from '@acorex/platform/layout/entity';
+import * as i0 from '@angular/core';
+import { inject, Injector, Injectable, input, signal, ViewEncapsulation, Component, NgModule, InjectionToken, HostListener, computed, viewChild } from '@angular/core';
+import { firstValueFrom, Subject } from 'rxjs';
+import * as i1$2 from '@acorex/platform/core';
+import { objectKeyValueTransforms, AXPPlatformScope, AXPActivityLogService, AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER } from '@acorex/platform/core';
+import * as i4 from '@acorex/core/translation';
+import { AXTranslationService, AXTranslationModule } from '@acorex/core/translation';
+import { AXPWidgetsCatalog } from '@acorex/platform/layout/builder';
+import { AXPWidgetsModule } from '@acorex/platform/widgets';
+import * as i1$1 from '@acorex/platform/workflow';
+import { AXPWorkflowAction, AXPWorkflowModule, AXPWorkflowService } from '@acorex/platform/workflow';
+import * as i1 from '@angular/common';
+import { CommonModule } from '@angular/common';
+import * as i2 from '@acorex/components/button';
+import { AXButtonModule } from '@acorex/components/button';
+import { AXBasePageComponent } from '@acorex/components/page';
+import * as i3 from '@acorex/components/decorators';
+import { AXDecoratorModule } from '@acorex/components/decorators';
+import * as i2$1 from '@acorex/platform/layout/components';
+import { AXPCompareViewComponent, AXPComponentSlotModule } from '@acorex/platform/layout/components';
+import { AXPopupService } from '@acorex/components/popup';
+import { AXFormatService } from '@acorex/core/format';
+import { AXTextBoxModule } from '@acorex/components/text-box';
+import { AXDialogService } from '@acorex/components/dialog';
+import * as i1$3 from '@angular/forms';
+import { FormsModule } from '@angular/forms';
+import * as i4$1 from '@acorex/components/form';
+import { AXFormModule } from '@acorex/components/form';
+import * as i5 from '@acorex/components/label';
+import { AXLabelModule } from '@acorex/components/label';
+import * as i6 from '@acorex/components/select-box';
+import { AXSelectBoxModule } from '@acorex/components/select-box';
+import * as i7 from '@acorex/components/text-area';
+import { AXTextAreaModule } from '@acorex/components/text-area';
+import { AXValidationModule } from '@acorex/core/validation';
+import { AXCalendarService } from '@acorex/core/date-time';
+
+const config = {
+    i18n: 'common',
+};
+const RootConfig = {
+    config,
+    module: {
+        module: 'common',
+        name: 'Common',
+        title: `t('module-name', {scope:"${config.i18n}"})`,
+        icon: 'fa-light fa-file-invoice',
+    },
+    entities: {},
+};
+
+class AXMEntityProvider {
+    constructor() {
+        this.injector = inject(Injector);
+    }
+    preload() {
+        const module = RootConfig.module.name;
+        return Array.from(Object.values(RootConfig.entities)).map((entity) => ({
+            module: module,
+            entity: entity.name,
+        }));
+    }
+    async get(moduleName, entityName) {
+        if (moduleName == RootConfig.module.name) {
+            switch (entityName) {
+            }
+        }
+        return null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXMEntityProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXMEntityProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXMEntityProvider, decorators: [{
+            type: Injectable
+        }] });
+
+class AXMMenuProvider {
+    constructor() {
+        this.sessionService = inject(AXPSessionService);
+        this.homePageService = inject(AXPHomePageService);
+    }
+    async provide(context) {
+        const scope = RootConfig.config.i18n;
+        const module = RootConfig.module;
+        const appName = this.sessionService.application?.name;
+        const isAuthorized = await firstValueFrom(this.sessionService.isAuthorized$);
+        if (!isAuthorized) {
+            return;
+        }
+        //
+        const homePagePath = this.homePageService.getCurrent().path;
+        if (homePagePath) {
+            context.addItems([
+                {
+                    priority: -9,
+                    text: `t('home',{scope:'common'})`,
+                    path: homePagePath,
+                    icon: 'fa-light fa-grid-2',
+                    data: {
+                    //requiredPermission: '',
+                    },
+                },
+            ]);
+        }
+        context.find('user-profile').addItems([
+            {
+                text: `t('user.title', {scope: "settings"})`,
+                name: 'user-settings',
+                icon: 'fa-light fa-gear',
+                path: `/${this.sessionService.application?.name}/settings/user`,
+            },
+        ]);
+        context.addItems([
+            {
+                name: 'tenant-application-settings',
+                priority: 10000,
+                text: `t('tenant.title', {scope: "settings"})`,
+                type: 'menu',
+                icon: 'fa-light fa-gear',
+                path: `/${appName}/settings/tenant`,
+                data: {
+                    requiredPermission: 'admin',
+                },
+            },
+        ]);
+    }
+}
+
+class AXMPermissionDefinitionProvider {
+    async define(context) {
+        // context.addPermissions([
+        //   {
+        //     name: 'view_templates',
+        //     title: 'Permission to view templates',
+        //     isArchived: false,
+        //   },
+        // ]);
+    }
+}
+
+class AXMSearchCommandProvider extends AXPSearchCommandProvider {
+    constructor() {
+        super(...arguments);
+        this.commands = [
+        // {
+        //   group: 'command',
+        //  title: 'New Form Template',
+        //  icon: RootConfig.entities.template.icon,
+        //  description: 'Create a new form template for designing reusable forms.', // Added description
+        //  commands: {
+        //    'create-entity': {
+        //      entity: `${RootConfig.module.name}.${RootConfig.entities.template.name}`,
+        //    },
+        //  },
+        // }
+        ];
+    }
+}
+
+var AXMLockSystemSettings;
+(function (AXMLockSystemSettings) {
+    AXMLockSystemSettings["LockSystem"] = "general:lock-system:lock";
+})(AXMLockSystemSettings || (AXMLockSystemSettings = {}));
+
+class AXMSettingProvider {
+    constructor(injector) {
+        this.injector = injector;
+        this.translateService = this.injector.get(AXTranslationService);
+    }
+    async provide(context) {
+        const trans = async (key) => await this.translateService.translateAsync(`settings.${key}`, { scope: 'general' });
+        // Find the 'General Settings' group
+        const group = context.group('general');
+        if (!group) {
+            return;
+        }
+        // Add the 'Release Notes' setting
+        group.addSection('lock-system', await trans('general.lock-system.lock.title'), await trans('general.lock-system.lock.description')).addSetting({
+            key: AXMLockSystemSettings.LockSystem,
+            title: await trans('general.lock-system.lock.title'),
+            scope: AXPPlatformScope.Tenant,
+            isInherited: true,
+            defaultValue: false,
+            valueTransforms: objectKeyValueTransforms('id'),
+            widget: {
+                type: AXPWidgetsCatalog.toggle,
+                options: {
+                    label: null,
+                }
+            },
+            description: await trans('general.lock-system.lock.description'),
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXMSettingProvider, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXMSettingProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXMSettingProvider, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i0.Injector }] });
+
+class AXPComparePopupComponent extends AXBasePageComponent {
+    constructor() {
+        super(...arguments);
+        this.inputs = input(...(ngDevMode ? [undefined, { debugName: "inputs" }] : []));
+        this.isBusy = signal(false, ...(ngDevMode ? [{ debugName: "isBusy" }] : []));
+        this.mode = input('compare', ...(ngDevMode ? [{ debugName: "mode" }] : []));
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        // Any additional initialization logic can go here
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXPComparePopupComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "20.1.4", type: AXPComparePopupComponent, isStandalone: true, selector: "axp-compare-popup", inputs: { inputs: { classPropertyName: "inputs", publicName: "inputs", isSignal: true, isRequired: false, transformFunction: null }, mode: { classPropertyName: "mode", publicName: "mode", isSignal: true, isRequired: false, transformFunction: null } }, providers: [], usesInheritance: true, ngImport: i0, template: "<ax-content>\n  <div class=\"ax-p-6 ax-min-h-[30vh] ax-overflow-y-auto\">\n    <axp-compare-view [inputs]=\"inputs()\" [mode]=\"mode()\"></axp-compare-view>\n  </div>\n</ax-content>\n<ax-footer>\n  <ax-prefix></ax-prefix>\n  <ax-suffix>\n    <ax-button [text]=\"'close' | translate | async\" look=\"solid\" color=\"primary\" (onClick)=\"close()\"> </ax-button>\n  </ax-suffix>\n</ax-footer>", dependencies: [{ kind: "ngmodule", type: 
+                // Angular
+                CommonModule }, { kind: "ngmodule", type: 
+                // ACoreX
+                AXDecoratorModule }, { kind: "component", type: i3.AXDecoratorGenericComponent, selector: "ax-footer, ax-header, ax-content, ax-divider, ax-form-hint, ax-prefix, ax-suffix, ax-text, ax-title, ax-subtitle, ax-placeholder, ax-overlay" }, { kind: "ngmodule", type: AXButtonModule }, { kind: "component", type: i2.AXButtonComponent, selector: "ax-button", inputs: ["disabled", "size", "tabIndex", "color", "look", "text", "toggleable", "selected", "iconOnly", "type", "loadingText"], outputs: ["onBlur", "onFocus", "onClick", "selectedChange", "toggleableChange", "lookChange", "colorChange", "disabledChange", "loadingTextChange"] }, { kind: "ngmodule", type: AXTranslationModule }, { kind: "component", type: 
+                // Compare View
+                AXPCompareViewComponent, selector: "axp-compare-view", inputs: ["inputs", "mode"] }, { kind: "pipe", type: i1.AsyncPipe, name: "async" }, { kind: "pipe", type: i4.AXTranslatorPipe, name: "translate" }], encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXPComparePopupComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'axp-compare-popup', standalone: true, imports: [
+                        // Angular
+                        CommonModule,
+                        // ACoreX
+                        AXDecoratorModule,
+                        AXButtonModule,
+                        AXTranslationModule,
+                        // Compare View
+                        AXPCompareViewComponent
+                    ], encapsulation: ViewEncapsulation.None, providers: [], template: "<ax-content>\n  <div class=\"ax-p-6 ax-min-h-[30vh] ax-overflow-y-auto\">\n    <axp-compare-view [inputs]=\"inputs()\" [mode]=\"mode()\"></axp-compare-view>\n  </div>\n</ax-content>\n<ax-footer>\n  <ax-prefix></ax-prefix>\n  <ax-suffix>\n    <ax-button [text]=\"'close' | translate | async\" look=\"solid\" color=\"primary\" (onClick)=\"close()\"> </ax-button>\n  </ax-suffix>\n</ax-footer>" }]
+        }] });
+
+var comparePopup_component = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXPComparePopupComponent: AXPComparePopupComponent
+});
+
+class AXMComparePopupStartAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.popupService = inject(AXPopupService);
+        this.translate = inject(AXTranslationService);
+    }
+    async execute(context) {
+        const comp = (await Promise.resolve().then(function () { return comparePopup_component; })).AXPComparePopupComponent;
+        this.popupService.open(comp, {
+            title: await this.translate.translateAsync('Compare'),
+            size: 'lg',
+            data: {
+                inputs: signal(context.getVariable('inputs')),
+                mode: signal(context.getVariable('mode')),
+            },
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXMComparePopupStartAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXMComparePopupStartAction }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXMComparePopupStartAction, decorators: [{
+            type: Injectable
+        }] });
+class AXMCompareEntityRecordsAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.entityRegistry = inject(AXPEntityDefinitionRegistryService);
+    }
+    async execute(context) {
+        const [moduleName, entityName] = context.getVariable('entity').split('.');
+        const entityRef = await this.entityRegistry.resolve(moduleName, entityName);
+        const records = context.getVariable('data');
+        const ids = records?.map((r) => r.id);
+        const getById = entityRef.queries.byKey?.execute;
+        //
+        const fields = entityRef.properties
+            .filter(p => p.schema.interface && p.schema.hidden != true)
+            .map((p) => ({
+            path: p.name,
+            title: p.title,
+            description: p.description,
+            widget: {
+                type: p.schema.interface?.type,
+                name: p.name,
+                path: p.name,
+                options: p.schema.interface?.options,
+            },
+        }));
+        const objects = await Promise.all(ids.map(async (c) => {
+            const object = await getById(c);
+            return {
+                id: object.id,
+                title: object.title,
+                description: object.description,
+                context: object,
+            };
+        }));
+        const inputs = {
+            fields: fields,
+            objects: objects,
+        };
+        //
+        context.setVariable('inputs', inputs);
+        context.setVariable('mode', 'records');
+        context.setOutput('result', true);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXMCompareEntityRecordsAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXMCompareEntityRecordsAction }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXMCompareEntityRecordsAction, decorators: [{
+            type: Injectable
+        }] });
+class AXMCompareEntityRecordVersionsAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.entityRegistry = inject(AXPEntityDefinitionRegistryService);
+        this.activityLogService = inject(AXPActivityLogService);
+        this.formatService = inject(AXFormatService);
+        this.translate = inject(AXTranslationService);
+    }
+    async execute(context) {
+        const [moduleName, entityName] = context.getVariable('entity').split('.');
+        const entityRef = await this.entityRegistry.resolve(moduleName, entityName);
+        const refId = context.getVariable('data.refId');
+        const refType = context.getVariable('data.refType');
+        const ids = context.getVariable('data.ids');
+        const histories = await this.activityLogService.getHistoryByIds(refId, refType, ids);
+        //
+        const fields = entityRef.properties
+            .filter(p => p.schema.interface && p.schema.hidden != true)
+            .map((p) => ({
+            path: p.name,
+            title: p.title,
+            description: p.description,
+            widget: {
+                type: p.schema.interface?.type,
+                name: p.name,
+                path: p.name,
+                options: p.schema.interface?.options,
+            },
+        }));
+        const objects = await Promise.all(histories.map(async (h) => ({
+            id: h.id,
+            title: await this.translate.translateAsync(`@activity-log:${h.changeType == 'update' ? 'updated' : 'created'}-by-title`, {
+                params: {
+                    user: h.user?.title,
+                    date: this.formatService.format(h.date, 'datetime', { format: 'short' }),
+                }
+            }),
+            description: h.user?.title,
+            context: h.data,
+        })));
+        const inputs = {
+            fields: fields,
+            objects: objects,
+        };
+        //
+        context.setVariable('inputs', inputs);
+        context.setVariable('mode', 'changes');
+        context.setOutput('result', true);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXMCompareEntityRecordVersionsAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXMCompareEntityRecordVersionsAction }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXMCompareEntityRecordVersionsAction, decorators: [{
+            type: Injectable
+        }] });
+const AXMCompareEntityRecordsWorkflow = {
+    startStepId: 'start',
+    steps: {
+        start: {
+            action: 'show-entity-records-compare-action',
+            nextSteps: [
+                {
+                    conditions: [{ type: 'SINGLE', expression: 'context.getOutput("result") == true' }],
+                    nextStepId: 'show-popup',
+                }
+            ],
+        },
+        'show-popup': {
+            action: 'show-compare-popup-action',
+        },
+    },
+};
+const AXMCompareEntityRecordVersionsWorkflow = {
+    startStepId: 'start',
+    steps: {
+        start: {
+            action: 'show-entity-record-versions-compare-action',
+            nextSteps: [
+                {
+                    conditions: [{ type: 'SINGLE', expression: 'context.getOutput("result") == true' }],
+                    nextStepId: 'show-popup',
+                }
+            ],
+        },
+        'show-popup': {
+            action: 'show-compare-popup-action',
+        },
+    },
+};
+
+class AXPCompareModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXPCompareModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.1.4", ngImport: i0, type: AXPCompareModule, imports: [AXPComparePopupComponent, i1$1.AXPWorkflowModule], exports: [AXPComparePopupComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXPCompareModule, imports: [AXPComparePopupComponent,
+            AXPWorkflowModule.forChild({
+                actions: {
+                    'show-compare-popup-action': AXMComparePopupStartAction,
+                    'show-entity-records-compare-action': AXMCompareEntityRecordsAction,
+                    'show-entity-record-versions-compare-action': AXMCompareEntityRecordVersionsAction,
+                },
+                workflows: {
+                    'show-entity-records-compare': AXMCompareEntityRecordsWorkflow,
+                    'show-entity-record-versions-compare': AXMCompareEntityRecordVersionsWorkflow,
+                },
+            })] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXPCompareModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        AXPComparePopupComponent,
+                        AXPWorkflowModule.forChild({
+                            actions: {
+                                'show-compare-popup-action': AXMComparePopupStartAction,
+                                'show-entity-records-compare-action': AXMCompareEntityRecordsAction,
+                                'show-entity-record-versions-compare-action': AXMCompareEntityRecordVersionsAction,
+                            },
+                            workflows: {
+                                'show-entity-records-compare': AXMCompareEntityRecordsWorkflow,
+                                'show-entity-record-versions-compare': AXMCompareEntityRecordVersionsWorkflow,
+                            },
+                        }),
+                    ],
+                    exports: [AXPComparePopupComponent],
+                }]
+        }] });
+
+const AXP_GLOBAL_SEARCH_CONFIG_TOKEN = new InjectionToken('AXP_GLOBAL_SEARCH_CONFIG_TOKEN');
+
+class AXPGlobalSearchSlotComponent {
+    constructor() {
+        this.workflow = inject(AXPWorkflowService);
+    }
+    async startSearch() {
+        await this.workflow.execute('global-search');
+    }
+    async handleKeyboardEvent(event) {
+        if (event.ctrlKey) {
+            switch (event.code) {
+                case 'KeyK':
+                    event.preventDefault();
+                    event.stopPropagation();
+                    await this.startSearch();
+                    break;
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXPGlobalSearchSlotComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.1.4", type: AXPGlobalSearchSlotComponent, isStandalone: true, selector: "ng-component", host: { listeners: { "document:keydown": "handleKeyboardEvent($event)" } }, ngImport: i0, template: `
+    <ax-button color="primary" class="ax-flex md:ax-hidden" (onClick)="startSearch()">
+      <ax-icon class="fa-regular fa-search">
+      </ax-icon>
+    </ax-button>
+    <div class="ax-bg-primary-200/15 ax-h-10 ax-w-72 ax-rounded-default ax-cursor-pointer ax-justify-between ax-hidden md:ax-flex ax-items-center ax-px-3 hover:ax-bg-primary-200/30 ax-text-primary-text" (click)="startSearch()" *translate="let t">
+      <div class="ax-flex ax-items-center ax-gap-2">
+      <i class="fa-light fa-search ax-text-xl"></i>
+      <span>{{ t('search-placeholder',{scope:'global-search'}) | async}}</span>
+      </div>
+      <kbd class="ax-text-sm">Ctrl+K</kbd>
+    </div>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: AXButtonModule }, { kind: "component", type: i2.AXButtonComponent, selector: "ax-button", inputs: ["disabled", "size", "tabIndex", "color", "look", "text", "toggleable", "selected", "iconOnly", "type", "loadingText"], outputs: ["onBlur", "onFocus", "onClick", "selectedChange", "toggleableChange", "lookChange", "colorChange", "disabledChange", "loadingTextChange"] }, { kind: "ngmodule", type: AXDecoratorModule }, { kind: "component", type: i3.AXDecoratorIconComponent, selector: "ax-icon", inputs: ["icon"] }, { kind: "ngmodule", type: AXTranslationModule }, { kind: "directive", type: i4.AXTranslatorDirective, selector: "[translate]" }, { kind: "ngmodule", type: AXTextBoxModule }, { kind: "pipe", type: i1.AsyncPipe, name: "async" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXPGlobalSearchSlotComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: `
+    <ax-button color="primary" class="ax-flex md:ax-hidden" (onClick)="startSearch()">
+      <ax-icon class="fa-regular fa-search">
+      </ax-icon>
+    </ax-button>
+    <div class="ax-bg-primary-200/15 ax-h-10 ax-w-72 ax-rounded-default ax-cursor-pointer ax-justify-between ax-hidden md:ax-flex ax-items-center ax-px-3 hover:ax-bg-primary-200/30 ax-text-primary-text" (click)="startSearch()" *translate="let t">
+      <div class="ax-flex ax-items-center ax-gap-2">
+      <i class="fa-light fa-search ax-text-xl"></i>
+      <span>{{ t('search-placeholder',{scope:'global-search'}) | async}}</span>
+      </div>
+      <kbd class="ax-text-sm">Ctrl+K</kbd>
+    </div>
+  `,
+                    imports: [CommonModule, AXButtonModule, AXDecoratorModule, AXTranslationModule, AXTextBoxModule]
+                }]
+        }], propDecorators: { handleKeyboardEvent: [{
+                type: HostListener,
+                args: ['document:keydown', ['$event']]
+            }] } });
+
+class AXPGlobalSearchStartAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.popupService = inject(AXPopupService);
+        this.workflow = inject(AXPWorkflowService);
+        this.config = inject(AXP_GLOBAL_SEARCH_CONFIG_TOKEN);
+    }
+    async execute(context) {
+        const component = await this.config.window();
+        const popup = await this.popupService.open(component, {
+            title: 'Search...',
+            size: 'fit',
+            closeOnBackdropClick: true,
+            data: {
+                text: context.getVariable('text'),
+            },
+            header: false,
+        });
+        if (popup.data) {
+            const result = popup.data;
+            if (result && result.command) {
+                this.workflow.execute(result.command?.name, result.command?.options);
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXPGlobalSearchStartAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXPGlobalSearchStartAction }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXPGlobalSearchStartAction, decorators: [{
+            type: Injectable
+        }] });
+const AXPGlobalSearchWorkflow = {
+    startStepId: 'start',
+    steps: {
+        start: {
+            action: 'AXPGlobalSearchStartAction',
+        },
+    },
+};
+
+class AXPGlobalSearchModule {
+    constructor(appInitService, injector) {
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXPGlobalSearchModule, deps: [{ token: i1$2.AXPAppStartUpService }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.1.4", ngImport: i0, type: AXPGlobalSearchModule, imports: [i2$1.AXPComponentSlotModule, i1$1.AXPWorkflowModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXPGlobalSearchModule, providers: [
+            {
+                provide: AXP_GLOBAL_SEARCH_CONFIG_TOKEN,
+                useValue: {
+                    window: () => import('./acorex-modules-common-search-popup.component-D7Y4T3Rp.mjs').then((c) => c.AXPGlobalSearchPopupComponent),
+                },
+            },
+        ], imports: [AXPComponentSlotModule.forChild({
+                'root-header-start': [
+                    {
+                        priority: 0,
+                        name: 'search',
+                        component: AXPGlobalSearchSlotComponent,
+                    },
+                ],
+            }),
+            //
+            AXPWorkflowModule.forChild({
+                actions: {
+                    AXPGlobalSearchStartAction
+                },
+                workflows: {
+                    'global-search': AXPGlobalSearchWorkflow,
+                },
+            })] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXPGlobalSearchModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        AXPComponentSlotModule.forChild({
+                            'root-header-start': [
+                                {
+                                    priority: 0,
+                                    name: 'search',
+                                    component: AXPGlobalSearchSlotComponent,
+                                },
+                            ],
+                        }),
+                        //
+                        AXPWorkflowModule.forChild({
+                            actions: {
+                                AXPGlobalSearchStartAction
+                            },
+                            workflows: {
+                                'global-search': AXPGlobalSearchWorkflow,
+                            },
+                        })
+                    ],
+                    exports: [],
+                    declarations: [],
+                    providers: [
+                        {
+                            provide: AXP_GLOBAL_SEARCH_CONFIG_TOKEN,
+                            useValue: {
+                                window: () => import('./acorex-modules-common-search-popup.component-D7Y4T3Rp.mjs').then((c) => c.AXPGlobalSearchPopupComponent),
+                            },
+                        },
+                    ]
+                }]
+        }], ctorParameters: () => [{ type: i1$2.AXPAppStartUpService }, { type: i0.Injector }] });
+
+class AXPGlobalSearchViewModel {
+    constructor() {
+        this.settingKeys = {
+            recent: "global-search:recents:items",
+            pinned: "global-search:pinned:items"
+        };
+        this.searchService = inject(AXPSearchService);
+        this.settingService = inject(AXPSettingService);
+        this._text = signal(null, ...(ngDevMode ? [{ debugName: "_text" }] : []));
+        this.text = this._text.asReadonly();
+        this._results = signal([], ...(ngDevMode ? [{ debugName: "_results" }] : []));
+        this.results = this._results.asReadonly();
+        this._isBusy = signal(false, ...(ngDevMode ? [{ debugName: "_isBusy" }] : []));
+        this.isBusy = this._isBusy.asReadonly();
+        this.isEmpty = computed(() => this.text() && this.results().length == 0, ...(ngDevMode ? [{ debugName: "isEmpty" }] : []));
+        this.isValid = computed(() => (this.text()?.length ?? 0) > 2, ...(ngDevMode ? [{ debugName: "isValid" }] : []));
+        this.isStart = computed(() => !this.isEmpty() && this.results().length == 0, ...(ngDevMode ? [{ debugName: "isStart" }] : []));
+        this.isWelcome = computed(() => this.isStart() && this.pinnedItems().length == 0 && this.recentItems().length == 0, ...(ngDevMode ? [{ debugName: "isWelcome" }] : []));
+        this._recentItems = signal([], ...(ngDevMode ? [{ debugName: "_recentItems" }] : []));
+        this._pinnedItems = signal([], ...(ngDevMode ? [{ debugName: "_pinnedItems" }] : []));
+        this.pinnedItems = this._pinnedItems.asReadonly();
+        this.recentItems = computed(() => this.getTopRecentItems(), ...(ngDevMode ? [{ debugName: "recentItems" }] : []));
+        this.onItemSelected = new Subject();
+        this.loadSettings();
+    }
+    async search(text) {
+        this._isBusy.set(true);
+        this._text.set(text);
+        if (!this.isValid()) {
+            this._results.set([]);
+        }
+        else {
+            await new Promise((resolve) => setTimeout(resolve, 250));
+            const results = await this.searchService.search(text);
+            this._results.set(results);
+        }
+        this._isBusy.set(false);
+    }
+    async execute(item) {
+        this.onItemSelected.next(item);
+        await this.updateSelectionHistory(item);
+    }
+    async pin(item) {
+        const currentPinned = this._pinnedItems();
+        if (!currentPinned.some(i => i.id === item.id)) {
+            this._pinnedItems.set([item, ...currentPinned].slice(0, 5));
+            await this.saveSettings();
+        }
+    }
+    async unpin(item) {
+        const currentPinned = this._pinnedItems();
+        this._pinnedItems.set(currentPinned.filter(i => i.id !== item.id));
+        await this.saveSettings();
+    }
+    async togglePin(item) {
+        if (this.isPinned(item)) {
+            await this.unpin(item);
+        }
+        else {
+            await this.pin(item);
+        }
+    }
+    isPinned(item) {
+        const currentPinned = this._pinnedItems();
+        return currentPinned.some(i => i.id === item.id);
+    }
+    async updateSelectionHistory(item) {
+        // Update recent selections
+        const currentHistory = this._recentItems();
+        const updatedHistory = [item, ...currentHistory.filter(i => i.id !== item.id)].slice(0, 5);
+        this._recentItems.set(updatedHistory);
+        // Save updated settings
+        await this.saveSettings();
+    }
+    getTopRecentItems() {
+        const pinnedIds = new Set(this._pinnedItems().map(item => item.id));
+        return this._recentItems().filter(item => !pinnedIds.has(item.id)).slice(0, 5);
+    }
+    async clearRecentItems() {
+        this._recentItems.set([]);
+        await this.settingService.scope(AXPPlatformScope.User).set(this.settingKeys.recent, []);
+    }
+    async loadSettings() {
+        // Load recent selections
+        const recent = await this.settingService.get(this.settingKeys.recent);
+        if (recent) {
+            this._recentItems.set(recent.slice(0, 5));
+        }
+        // Load pinned items
+        const pinned = await this.settingService.get(this.settingKeys.pinned);
+        if (pinned) {
+            this._pinnedItems.set(pinned.slice(0, 5));
+        }
+    }
+    async saveSettings() {
+        // Save recent selections
+        await this.settingService.scope(AXPPlatformScope.User).set(this.settingKeys.recent, this._recentItems().slice(0, 5));
+        // Save pinned items
+        await this.settingService.scope(AXPPlatformScope.User).set(this.settingKeys.pinned, this._pinnedItems().slice(0, 5));
+    }
+}
+
+class AXMLockPopupWorkflowAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.popupService = inject(AXPopupService);
+    }
+    async execute(context) {
+        const comp = (await Promise.resolve().then(function () { return index; })).AXPLockPopupComponent;
+        const result = await this.popupService.open(comp, {
+            title: 'lock-system.lock',
+            data: {
+                refId: context.getVariable('options.refId'),
+                refType: context.getVariable('options.refType'),
+            },
+        });
+        if (result.data != null && result.data.isCanceled != null) {
+            context.setOutput('isCanceled', result.data.isCanceled);
+            if (!result.data.isCanceled) {
+                context.setOutput('lockDuration', result.data.duration);
+                context.setOutput('lockReason', result.data.reason);
+            }
+        }
+        else {
+            context.setOutput('isCanceled', true);
+        }
+    }
+}
+const AXMLockPopupWorkflow = {
+    startStepId: 'lock-popup',
+    steps: {
+        'lock-popup': {
+            action: 'AXMLockPopupWorkflowAction',
+            nextSteps: [
+                {
+                    conditions: [{ type: 'SINGLE', expression: 'context.getOutput("isCanceled") == false' }],
+                    nextStepId: 'successToast',
+                },
+            ],
+        },
+        successToast: {
+            id: 'successToast',
+            action: 'AXPToastAction',
+            input: {
+                color: 'success',
+                title: 'workflow.entity-modified-title',
+                content: 'workflow.entity-modified-body',
+            },
+            nextSteps: [
+                {
+                    conditions: [],
+                    nextStepId: 'modifyConfirmed',
+                },
+            ],
+        },
+        modifyConfirmed: {
+            id: 'modifyConfirmed',
+            action: 'AXPEntityModifyConfirmedAction',
+        },
+    },
+};
+
+class AXMUnlockConfirmWorkflowAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.dialogService = inject(AXDialogService);
+        this.translationService = inject(AXTranslationService);
+        this.lockService = inject(AXPLockService);
+        this.sessionService = inject(AXPSessionService);
+    }
+    async execute(context) {
+        const refId = context.getVariable('options.refId');
+        const refType = context.getVariable('options.refType');
+        // Show confirmation dialog
+        const dialogResult = await this.dialogService.confirm(await this.translationService.translateAsync('unlock.title', { scope: 'general' }), await this.translationService.translateAsync('lock-system.confirm-unlock', { scope: 'general' }), 'warning', 'horizontal', false, 'cancel');
+        if (dialogResult.result) {
+            try {
+                // Perform unlock
+                await this.lockService.unlock({
+                    refId: refId,
+                    refType: refType,
+                    type: 'user',
+                });
+                context.setOutput('isCanceled', false);
+                context.setOutput('unlocked', true);
+            }
+            catch (error) {
+                console.error('Unlock failed:', error);
+                // Show error dialog
+                await this.dialogService.alert(await this.translationService.translateAsync('workflow.error'), await this.translationService.translateAsync('lock-system.unlock-failed', { scope: 'general' }), 'danger');
+                context.setOutput('isCanceled', true);
+                context.setOutput('unlocked', false);
+            }
+        }
+        else {
+            context.setOutput('isCanceled', true);
+            context.setOutput('unlocked', false);
+        }
+    }
+}
+const AXMUnlockConfirmWorkflow = {
+    startStepId: 'unlock-confirm',
+    steps: {
+        'unlock-confirm': {
+            action: 'AXMUnlockConfirmWorkflowAction',
+            nextSteps: [
+                {
+                    conditions: [{ type: 'SINGLE', expression: 'context.getOutput("unlocked") == true' }],
+                    nextStepId: 'successToast',
+                },
+            ],
+        },
+        successToast: {
+            id: 'successToast',
+            action: 'AXPToastAction',
+            input: {
+                color: 'success',
+                title: 'workflow.entity-modified-title',
+                content: 'workflow.entity-modified-body',
+            },
+            nextSteps: [
+                {
+                    conditions: [],
+                    nextStepId: 'modifyConfirmed',
+                },
+            ],
+        },
+        modifyConfirmed: {
+            id: 'modifyConfirmed',
+            action: 'AXPEntityModifyConfirmedAction',
+        },
+    },
+};
+
+class AXPLockPopupComponent extends AXBasePageComponent {
+    constructor() {
+        super(...arguments);
+        //#endregion
+        //#region ----   Signals & Services   ----
+        this.isBusy = signal(false, ...(ngDevMode ? [{ debugName: "isBusy" }] : []));
+        this.form = viewChild.required('form');
+        this.lockService = inject(AXPLockService);
+        this.sessionService = inject(AXPSessionService);
+        this.translationService = inject(AXTranslationService);
+        //#endregion
+        //#region ----   Form Data   ----
+        this.duration = '1h';
+        this.reason = '';
+        this.lockDurations = [];
+    }
+    async ngOnInit() {
+        // Load translated duration options
+        this.lockDurations = [
+            {
+                value: '1h',
+                text: await this.translationService.translateAsync('lock-system.duration.options.1h', { scope: 'general' }),
+                hours: 1
+            },
+            {
+                value: '1d',
+                text: await this.translationService.translateAsync('lock-system.duration.options.1d', { scope: 'general' }),
+                hours: 24
+            },
+            {
+                value: 'infinite',
+                text: await this.translationService.translateAsync('lock-system.duration.options.infinite', { scope: 'general' })
+            }
+        ];
+    }
+    //#endregion
+    //#region ----   UI Handlers   ----
+    async handleConfirm() {
+        if (this.isBusy()) {
+            return;
+        }
+        // Validate form
+        const validation = await this.form().validate();
+        if (!validation.result) {
+            return;
+        }
+        // Ensure duration is selected
+        if (!this.duration) {
+            return;
+        }
+        this.isBusy.set(true);
+        try {
+            const selectedDuration = this.lockDurations.find(d => d.value === this.duration);
+            const expireAt = selectedDuration?.hours
+                ? new Date(Date.now() + selectedDuration.hours * 60 * 60 * 1000)
+                : undefined; // undefined means infinite
+            await this.lockService.lock({
+                refId: this.refId,
+                refType: this.refType,
+                type: 'user',
+                date: new Date().toISOString(),
+                expireAt: expireAt,
+                lockedBy: {
+                    id: this.sessionService.user?.id ?? 'system',
+                    type: 'oidc.users',
+                },
+            });
+            // Close and notify success
+            this.close({
+                isCanceled: false,
+                duration: this.duration,
+                reason: this.reason
+            });
+        }
+        catch (error) {
+            console.error(error);
+            // TODO: show error toast if required
+        }
+        finally {
+            this.isBusy.set(false);
+        }
+    }
+    handleCancel() {
+        this.close({ isCanceled: true });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXPLockPopupComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "20.1.4", type: AXPLockPopupComponent, isStandalone: true, selector: "axp-lock-popup", viewQueries: [{ propertyName: "form", first: true, predicate: ["form"], descendants: true, isSignal: true }], usesInheritance: true, ngImport: i0, template: "<ax-content *translate=\"let t\">\n  <div class=\"ax-p-6\">\n    <ax-form #form>\n      <div class=\"ax-grid ax-grid-cols-12 ax-gap-4\">\n        \n        <!-- Lock Duration Selection -->\n        <ax-form-field class=\"ax-col-span-12\">\n          <ax-label>{{ t('lock-system.duration.title', {scope: 'general'}) | async }}</ax-label>\n          <ax-select-box\n            [(ngModel)]=\"duration\"\n            [dataSource]=\"lockDurations\"\n            [valueField]=\"'value'\"\n            [textField]=\"'text'\"\n            name=\"duration\"\n            class=\"ax-w-full\"\n          >\n            <ax-validation-rule\n              rule=\"required\"\n              message=\"This field is required\"\n            ></ax-validation-rule>\n          </ax-select-box>\n        </ax-form-field>\n\n        <!-- Optional Reason -->\n        <ax-form-field class=\"ax-col-span-12\">\n          <ax-label>{{ t('lock-system.reason.title', {scope: 'general'}) | async }}</ax-label>\n          <ax-text-area\n            [(ngModel)]=\"reason\"\n            [placeholder]=\"t('lock-system.reason.placeholder', {scope: 'general'}) | async\"\n            name=\"reason\"\n            class=\"ax-w-full ax-min-h-20\"\n          >\n            <ax-clear-button></ax-clear-button>\n          </ax-text-area>\n        </ax-form-field>\n\n      </div>\n    </ax-form>\n  </div>\n</ax-content>\n\n<ax-footer *translate=\"let t\">\n  <ax-prefix></ax-prefix>\n  <ax-suffix>\n    <ax-button \n      [text]=\"t('cancel') | async\" \n      (onClick)=\"handleCancel()\" \n      [disabled]=\"isBusy()\"\n    ></ax-button>\n    <ax-button\n      [text]=\"t('lock-system.lock', {scope: 'general'}) | async\"\n      color=\"primary\"\n      look=\"solid\"\n      (onClick)=\"handleConfirm()\"\n      [disabled]=\"isBusy()\"\n    >\n    </ax-button>\n  </ax-suffix>\n</ax-footer>\n", styles: [""], dependencies: [{ kind: "ngmodule", type: 
+                // Angular
+                CommonModule }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i1$3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1$3.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "ngmodule", type: 
+                // ACoreX
+                AXButtonModule }, { kind: "component", type: i2.AXButtonComponent, selector: "ax-button", inputs: ["disabled", "size", "tabIndex", "color", "look", "text", "toggleable", "selected", "iconOnly", "type", "loadingText"], outputs: ["onBlur", "onFocus", "onClick", "selectedChange", "toggleableChange", "lookChange", "colorChange", "disabledChange", "loadingTextChange"] }, { kind: "ngmodule", type: AXDecoratorModule }, { kind: "component", type: i3.AXDecoratorClearButtonComponent, selector: "ax-clear-button", inputs: ["icon"] }, { kind: "component", type: i3.AXDecoratorGenericComponent, selector: "ax-footer, ax-header, ax-content, ax-divider, ax-form-hint, ax-prefix, ax-suffix, ax-text, ax-title, ax-subtitle, ax-placeholder, ax-overlay" }, { kind: "ngmodule", type: AXFormModule }, { kind: "component", type: i4$1.AXFormFieldComponent, selector: "ax-form-field", inputs: ["labelMode"] }, { kind: "component", type: i4$1.AXFormComponent, selector: "ax-form", inputs: ["labelMode", "look", "messageStyle", "updateOn"], outputs: ["onValidate", "updateOnChange"] }, { kind: "directive", type: i4$1.AXValidationRuleDirective, selector: "ax-validation-rule", inputs: ["rule", "options", "message", "disabled"] }, { kind: "ngmodule", type: AXLabelModule }, { kind: "component", type: i5.AXLabelComponent, selector: "ax-label", inputs: ["required", "for"], outputs: ["requiredChange"] }, { kind: "ngmodule", type: AXSelectBoxModule }, { kind: "component", type: i6.AXSelectBoxComponent, selector: "ax-select-box", inputs: ["disabled", "readonly", "tabIndex", "placeholder", "minValue", "maxValue", "value", "state", "name", "id", "type", "look", "multiple", "valueField", "textField", "disabledField", "textTemplate", "selectedItems", "isItemTruncated", "showItemTooltip", "dataSource", "minRecordsForSearch", "caption", "itemTemplate", "selectedTemplate", "emptyTemplate", "loadingTemplate", "dropdownWidth", "searchBoxAutoFocus"], outputs: ["valueChange", "stateChange", "onValueChanged", "onBlur", "onFocus", "readonlyChange", "disabledChange", "onOpened", "onClosed"] }, { kind: "ngmodule", type: AXTextAreaModule }, { kind: "component", type: i7.AXTextAreaComponent, selector: "ax-text-area", inputs: ["disabled", "tabIndex", "readonly", "value", "state", "name", "placeholder", "maxLength", "look", "rows", "allowResize", "showCounter", "class"], outputs: ["onBlur", "onFocus", "valueChange", "stateChange", "onValueChanged", "readonlyChange", "disabledChange", "onKeyDown", "onKeyUp", "onKeyPress"] }, { kind: "ngmodule", type: AXTranslationModule }, { kind: "directive", type: i4.AXTranslatorDirective, selector: "[translate]" }, { kind: "ngmodule", type: AXValidationModule }, { kind: "pipe", type: i1.AsyncPipe, name: "async" }], encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXPLockPopupComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'axp-lock-popup', standalone: true, imports: [
+                        // Angular
+                        CommonModule,
+                        FormsModule,
+                        // ACoreX
+                        AXButtonModule,
+                        AXDecoratorModule,
+                        AXFormModule,
+                        AXLabelModule,
+                        AXSelectBoxModule,
+                        AXTextAreaModule,
+                        AXTranslationModule,
+                        AXValidationModule,
+                    ], encapsulation: ViewEncapsulation.None, template: "<ax-content *translate=\"let t\">\n  <div class=\"ax-p-6\">\n    <ax-form #form>\n      <div class=\"ax-grid ax-grid-cols-12 ax-gap-4\">\n        \n        <!-- Lock Duration Selection -->\n        <ax-form-field class=\"ax-col-span-12\">\n          <ax-label>{{ t('lock-system.duration.title', {scope: 'general'}) | async }}</ax-label>\n          <ax-select-box\n            [(ngModel)]=\"duration\"\n            [dataSource]=\"lockDurations\"\n            [valueField]=\"'value'\"\n            [textField]=\"'text'\"\n            name=\"duration\"\n            class=\"ax-w-full\"\n          >\n            <ax-validation-rule\n              rule=\"required\"\n              message=\"This field is required\"\n            ></ax-validation-rule>\n          </ax-select-box>\n        </ax-form-field>\n\n        <!-- Optional Reason -->\n        <ax-form-field class=\"ax-col-span-12\">\n          <ax-label>{{ t('lock-system.reason.title', {scope: 'general'}) | async }}</ax-label>\n          <ax-text-area\n            [(ngModel)]=\"reason\"\n            [placeholder]=\"t('lock-system.reason.placeholder', {scope: 'general'}) | async\"\n            name=\"reason\"\n            class=\"ax-w-full ax-min-h-20\"\n          >\n            <ax-clear-button></ax-clear-button>\n          </ax-text-area>\n        </ax-form-field>\n\n      </div>\n    </ax-form>\n  </div>\n</ax-content>\n\n<ax-footer *translate=\"let t\">\n  <ax-prefix></ax-prefix>\n  <ax-suffix>\n    <ax-button \n      [text]=\"t('cancel') | async\" \n      (onClick)=\"handleCancel()\" \n      [disabled]=\"isBusy()\"\n    ></ax-button>\n    <ax-button\n      [text]=\"t('lock-system.lock', {scope: 'general'}) | async\"\n      color=\"primary\"\n      look=\"solid\"\n      (onClick)=\"handleConfirm()\"\n      [disabled]=\"isBusy()\"\n    >\n    </ax-button>\n  </ax-suffix>\n</ax-footer>\n" }]
+        }] });
+
+var index = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXPLockPopupComponent: AXPLockPopupComponent
+});
+
+class AXMLockEvaluatorScopeProvider {
+    constructor() {
+        this.lockService = inject(AXPLockService);
+    }
+    async provide(context) {
+        context.addScope('lock', {
+            check: async (refId, refType) => {
+                const lock = await this.lockService.check({
+                    refId, refType
+                });
+                return lock;
+            }
+        });
+    }
+}
+
+class AXMVersionHistoryPopupStartAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.popupService = inject(AXPopupService);
+        this.translate = inject(AXTranslationService);
+    }
+    async execute(context) {
+        const comp = (await import('./acorex-modules-common-timeline-version-history-popup.component-ceEtE6qB.mjs')).AXMTimelineVersionHistoryPopupComponent;
+        this.popupService.open(comp, {
+            title: await this.translate.translateAsync('@activity-log:actions.view-history'),
+            data: {
+                refId: context.getVariable('options.refId'),
+                refType: context.getVariable('options.refType'),
+                fromDate: context.getVariable('options.fromDate'),
+                toDate: context.getVariable('options.toDate'),
+                limit: context.getVariable('options.limit'),
+                offset: context.getVariable('options.offset'),
+            },
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXMVersionHistoryPopupStartAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXMVersionHistoryPopupStartAction }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXMVersionHistoryPopupStartAction, decorators: [{
+            type: Injectable
+        }] });
+const AXMVersionHistoryPopupWorkflow = {
+    startStepId: 'start',
+    steps: {
+        start: {
+            action: 'show-version-history-popup-action',
+        },
+    },
+};
+
+class AXPVersionHistoryModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXPVersionHistoryModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.1.4", ngImport: i0, type: AXPVersionHistoryModule, imports: [i1$1.AXPWorkflowModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXPVersionHistoryModule, imports: [AXPWorkflowModule.forChild({
+                actions: {
+                    'show-version-history-popup-action': AXMVersionHistoryPopupStartAction,
+                },
+                workflows: {
+                    'show-version-history-popup': AXMVersionHistoryPopupWorkflow,
+                },
+            })] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXPVersionHistoryModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        AXPWorkflowModule.forChild({
+                            actions: {
+                                'show-version-history-popup-action': AXMVersionHistoryPopupStartAction,
+                            },
+                            workflows: {
+                                'show-version-history-popup': AXMVersionHistoryPopupWorkflow,
+                            },
+                        }),
+                    ],
+                    exports: [],
+                }]
+        }] });
+
+class AXPDateTimeEvaluatorScopeProvider {
+    constructor() {
+        this.calendarService = inject(AXCalendarService);
+    }
+    async provide(context) {
+        context.addScope('date', {
+            today: () => {
+                return this.calendarService.now();
+            },
+            tomorrow: () => {
+                return this.calendarService.create(this.calendarService.now()).add('day', 1).startOf('day').date;
+            },
+            yesterday: () => {
+                return this.calendarService.create(this.calendarService.now()).add('day', -1).startOf('day').date;
+            },
+            addDays: (date, days) => {
+                return this.calendarService.create(date).add('day', days).date;
+            },
+        });
+    }
+}
+
+class AXMCommonModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXMCommonModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.1.4", ngImport: i0, type: AXMCommonModule, imports: [AXPGlobalSearchModule,
+            AXPWidgetsModule,
+            AXPVersionHistoryModule,
+            AXPCompareModule, i1$1.AXPWorkflowModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXMCommonModule, providers: [
+            {
+                provide: AXP_MENU_PROVIDER,
+                useClass: AXMMenuProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_ENTITY_DEFINITION_LOADER,
+                useClass: AXMEntityProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_SETTING_DEFINITION_PROVIDER,
+                useClass: AXMSettingProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_SEARCH_PROVIDER,
+                useClass: AXMSearchCommandProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_PERMISSION_DEFINITION_PROVIDER,
+                useClass: AXMPermissionDefinitionProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER,
+                useClass: AXMLockEvaluatorScopeProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER,
+                useClass: AXPDateTimeEvaluatorScopeProvider,
+                multi: true,
+            },
+        ], imports: [AXPGlobalSearchModule,
+            AXPWidgetsModule,
+            AXPVersionHistoryModule,
+            AXPCompareModule,
+            AXPWorkflowModule.forChild({
+                actions: {
+                    AXMLockPopupWorkflowAction,
+                    AXMUnlockConfirmWorkflowAction,
+                },
+                workflows: {
+                    'lock-popup': AXMLockPopupWorkflow,
+                    'unlock-confirm': AXMUnlockConfirmWorkflow,
+                },
+            })] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXMCommonModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        AXPGlobalSearchModule,
+                        AXPWidgetsModule,
+                        AXPVersionHistoryModule,
+                        AXPCompareModule,
+                        AXPWorkflowModule.forChild({
+                            actions: {
+                                AXMLockPopupWorkflowAction,
+                                AXMUnlockConfirmWorkflowAction,
+                            },
+                            workflows: {
+                                'lock-popup': AXMLockPopupWorkflow,
+                                'unlock-confirm': AXMUnlockConfirmWorkflow,
+                            },
+                        }),
+                    ],
+                    exports: [],
+                    declarations: [],
+                    providers: [
+                        {
+                            provide: AXP_MENU_PROVIDER,
+                            useClass: AXMMenuProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_ENTITY_DEFINITION_LOADER,
+                            useClass: AXMEntityProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_SETTING_DEFINITION_PROVIDER,
+                            useClass: AXMSettingProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_SEARCH_PROVIDER,
+                            useClass: AXMSearchCommandProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_PERMISSION_DEFINITION_PROVIDER,
+                            useClass: AXMPermissionDefinitionProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER,
+                            useClass: AXMLockEvaluatorScopeProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER,
+                            useClass: AXPDateTimeEvaluatorScopeProvider,
+                            multi: true,
+                        },
+                    ],
+                }]
+        }] });
+
+const AXPWidgetsList = {
+    Editors: {
+        DocumentAttachment: 'document-attachment-editor',
+        TagBox: 'tagable-editor',
+        CheckBox: 'checkbox-editor',
+        ColorBox: 'color-editor',
+        DateTimeBox: 'date-time-editor',
+        Direction: 'direction',
+        LargeTextBox: 'large-text-editor',
+        NumberBox: 'number-editor',
+        UnitValueBox: 'number-unit-editor',
+        PasswordBox: 'password-editor',
+        QueryBuilder: 'query-builder-editor',
+        RichText: 'rich-text-editor',
+        SelectBox: 'select-editor',
+        SelectionList: 'selection-list-editor',
+        TextBox: 'text-editor',
+        InlineDataTable: 'table-editor',
+        ToggleSwitch: 'toggle-editor',
+        FileTypeExtension: 'file-type-extension',
+        MapBox: 'map',
+        MediaGallery: 'gallery',
+        SignatureBox: 'signature',
+        LookupBox: 'lookup-editor',
+    },
+    Layouts: {
+        BlockLayout: 'block-layout',
+        RepeaterLayout: 'repeater-layout',
+        TextBlockLayout: 'text-block-layout',
+        FormField: 'form-field',
+    },
+    Actions: {
+        ActionButton: 'button-action',
+    },
+    Advanced: {
+        QRCode: 'qrcode',
+    },
+    Templates: {
+        Designer: 'template-designer',
+    },
+};
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AXMCommonModule, AXMEntityProvider, AXMLockPopupWorkflow, AXMLockPopupWorkflowAction, AXMMenuProvider, AXMSearchCommandProvider, AXMSettingProvider, AXMUnlockConfirmWorkflow, AXMUnlockConfirmWorkflowAction, AXPGlobalSearchModule, AXPGlobalSearchViewModel, AXPLockPopupComponent, AXPVersionHistoryModule, AXPWidgetsList, AXP_GLOBAL_SEARCH_CONFIG_TOKEN, RootConfig };
 //# sourceMappingURL=acorex-modules-common.mjs.map