@acorex/platform 19.1.2 → 19.1.4

package/fesm2022/acorex-platform-common.mjs

@@ -1,6 +1,6 @@
 import * as i0 from '@angular/core';
 import { Injectable, provideAppInitializer, inject, RendererFactory2, InjectionToken, Injector, ErrorHandler, NgModule, Inject, Directive, Input, EventEmitter, Output, runInInjectionContext, Optional, Component, ViewEncapsulation, ChangeDetectorRef, ChangeDetectionStrategy, ViewChild } from '@angular/core';
-import { kebabCase, merge, cloneDeep, sortBy, assign, isEqual, get, set } from 'lodash-es';
+import { kebabCase, merge, cloneDeep, get, sortBy, assign, isEqual, set } from 'lodash-es';
 import { AXPopupModule } from '@acorex/components/popup';
 import { AXToastService, AXToastModule } from '@acorex/components/toast';
 import { AXDateTimeModule } from '@acorex/core/date-time';
@@ -112,8 +112,10 @@ function resolveActionLook(tr) {
             return { color: 'primary', icon: 'fa-solid fa-info' };
         case 'delete':
             return { color: 'danger', icon: 'fa-solid fa-trash' };
+        case 'update':
+            return { color: 'primary', icon: 'fa-solid  fa-pen-to-square' };
         case 'print':
-            return { color: 'secondary', icon: 'fa-solid fa-print' };
+            return { color: 'neutral', icon: 'fa-solid fa-print' };
         case 'confirm':
             return { color: 'success', icon: 'fa-solid fa-check' };
         case 'archive':
@@ -670,7 +672,6 @@ class AXPFilterOperatorMiddlewareServiceImpl extends AXPFilterOperatorMiddleware
         return filters.map((filter) => this.transformFilter(filter));
     }
     transformFilter(filter) {
-        console.log(filter);
         const { operator, value, filters, field } = filter;
         // Find the operator (either default or custom)
         const filterOperator = this.operators[operator?.type] || null;
@@ -763,6 +764,15 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [{ type: i0.Injector }, { type: AXPErrorHandlerRegistryService }] });
 
+var AXPSettingScope;
+(function (AXPSettingScope) {
+    AXPSettingScope["Environment"] = "C";
+    AXPSettingScope["Global"] = "G";
+    AXPSettingScope["Tenant"] = "T";
+    AXPSettingScope["User"] = "U";
+})(AXPSettingScope || (AXPSettingScope = {}));
+;
+
 class AXPSettingDefinitionProviderContext {
     constructor() {
         this.rootGroups = [];
@@ -861,8 +871,12 @@ class AXPSettingDefinitionSectionBuilder {
                 name: setting.key,
                 path: setting.key,
                 defaultValue: setting.defaultValue,
-                options: merge(setting.widget.options ?? {}, { label: setting.widget.options?.['label'] ?? setting.title }),
+                options: merge(setting.widget.options ?? {}, {
+                    label: setting.widget.options?.['label'] ?? setting.title,
+                    validationRules: setting.validationRules ?? [],
+                }),
                 valueTransforms: setting.valueTransforms,
+                triggers: setting.widget.triggers,
             },
         };
         this.section.settings.push(newSetting);
@@ -880,9 +894,9 @@ class AXPSettingDefinitionProviderService {
         this.providers = inject(AXP_SETTING_DEFINITION_PROVIDER, { optional: true });
         this.cache = null;
     }
-    async items() {
+    async load() {
         if (this.cache) {
-            return this.cache;
+            return;
         }
         const context = new AXPSettingDefinitionProviderContext();
         if (Array.isArray(this.providers)) {
@@ -891,15 +905,52 @@ class AXPSettingDefinitionProviderService {
             }
         }
         this.cache = context.getGroups();
-        return this.cache;
     }
-    defaultValues(scope) {
+    async getListAsync(scope) {
+        await this.load();
+        return this.getList(scope);
+    }
+    getList(scope) {
+        if (!this.cache) {
+            return [];
+        }
+        const scopeOrder = ['C', 'G', 'T', 'U']; // Scopes hierarchy in ascending order
+        const filterByScope = (groups, currentScope) => {
+            const currentScopeIndex = scopeOrder.indexOf(currentScope);
+            return groups
+                .map((group) => ({
+                ...group,
+                sections: group.sections.map((section) => ({
+                    ...section,
+                    settings: section.settings.filter((setting) => {
+                        const settingScopeIndex = scopeOrder.indexOf(setting.scope);
+                        // Include settings where:
+                        // 1. The scope matches the requested scope.
+                        if (setting.scope === currentScope)
+                            return true;
+                        // 2. The setting scope is higher (closer to 'U') and is inherited.
+                        if (setting.isInherited &&
+                            settingScopeIndex > currentScopeIndex // Higher scope
+                        ) {
+                            return true;
+                        }
+                        // 3. Exclude settings with a lower or irrelevant scope.
+                        return false;
+                    }),
+                })).filter((section) => section.settings.length > 0), // Keep only sections with settings
+                groups: filterByScope(group.groups, currentScope), // Recursively filter nested groups
+            }))
+                .filter((group) => group.sections.length > 0 || group.groups.length > 0); // Keep groups with valid sections or nested groups
+        };
+        return filterByScope(this.cache, scope);
+    }
+    async defaultValues() {
         const defaults = {};
         const collectDefaults = (groups) => {
             groups.forEach((group) => {
                 group.sections.forEach((section) => {
                     section.settings.forEach((setting) => {
-                        if (setting.defaultValue !== undefined && (!scope || setting.scope === scope)) {
+                        if (setting.defaultValue !== undefined) {
                             defaults[setting.name] = setting.defaultValue;
                         }
                     });
@@ -907,16 +958,14 @@ class AXPSettingDefinitionProviderService {
                 collectDefaults(group.groups);
             });
         };
-        if (this.cache) {
-            collectDefaults(this.cache);
+        if (!this.cache) {
+            await this.load();
         }
+        collectDefaults(this.cache);
         return defaults;
     }
-    findGroup(groupName) {
-        if (this.cache) {
-            return this.searchRecursive(this.cache, groupName, []); // Initialize with an empty breadcrumb
-        }
-        return null;
+    findGroup(scope, groupName) {
+        return this.searchRecursive(this.getList(scope), groupName, []); // Initialize with an empty breadcrumb
     }
     searchRecursive(groups, groupName, breadcrumb) {
         for (const group of groups) {
@@ -931,12 +980,16 @@ class AXPSettingDefinitionProviderService {
             }
             // Recursively search in nested groups
             const nestedResult = this.searchRecursive(group.groups, groupName, currentBreadcrumb);
-            if (nestedResult) {
+            if (nestedResult.breadcrumb.length > 0) {
                 return nestedResult;
             }
         }
         // If no matching group is found
-        return null;
+        return {
+            breadcrumb: [],
+            groups: [],
+            sections: []
+        };
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSettingDefinitionProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSettingDefinitionProviderService, providedIn: 'root' }); }
@@ -945,17 +998,39 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
+class AXPSettingDefaultValueProvider {
+    constructor() {
+        this.definitionProvider = inject(AXPSettingDefinitionProviderService);
+    }
+    get scope() {
+        return AXPSettingScope.Global;
+    }
+    async load() {
+        return Object.entries(await this.definitionProvider.defaultValues()).map(c => ({ key: c[0], value: c[1] }));
+    }
+    set(key, value) {
+        throw new Error('Method not implemented.');
+    }
+}
 
 const AXP_SETTING_VALUE_PROVIDER = new InjectionToken('AXP_SETTING_VALUE_PROVIDER', {
     providedIn: 'root',
     factory: () => {
-        return new AXPSettingValueProviderDefault();
+        return [
+            //new AXPSettingDefaultValueProvider(),
+            new AXPSettingValueProviderDefault(AXPSettingScope.Tenant),
+            new AXPSettingValueProviderDefault(AXPSettingScope.User)
+        ];
     }
 });
 class AXPSettingValueProviderDefault {
-    constructor() {
+    get scope() {
+        return this._scope;
+    }
+    constructor(_scope) {
+        this._scope = _scope;
         this.cache = new Map();
-        this.localStorageKey = 'AXP_SETTINGS';
+        this.localStorageKey = `AXP_SETTINGS_SCOPE(${this.scope})`;
     }
     async load() {
         // Load settings from localStorage as a single key
@@ -993,64 +1068,84 @@ class AXPSettingValueProviderDefault {
 
 class AXPSettingValueProviderService {
     constructor() {
-        this.settingsProvider = inject(AXP_SETTING_VALUE_PROVIDER);
-        this.settingsCache = new Map();
+        this.providers = inject(AXP_SETTING_VALUE_PROVIDER);
+        this.definitionService = inject(AXPSettingDefinitionProviderService);
+        this.scopedSettingsCache = new Map();
         this.onChanged = new Subject();
+        // Initialize scoped caches for dynamic scopes
+        const staticScopes = [AXPSettingScope.Environment, AXPSettingScope.Global, AXPSettingScope.Tenant, AXPSettingScope.User];
+        staticScopes.forEach((scope) => {
+            if (!this.scopedSettingsCache.has(scope)) {
+                this.scopedSettingsCache.set(scope, new Map());
+            }
+        });
     }
     async load() {
         try {
-            const settingsList = await this.settingsProvider.load();
-            this.settingsCache.clear();
-            settingsList.forEach((setting) => {
-                this.settingsCache.set(setting.key, setting.value);
-            });
+            const settingsList = [];
+            for (const provider of this.providers) {
+                const scopeCache = this.scopedSettingsCache.get(provider.scope);
+                const providerSettings = await provider.load();
+                providerSettings.forEach((setting) => {
+                    scopeCache.set(setting.key, setting.value);
+                });
+                settingsList.push(...providerSettings);
+            }
             return settingsList;
         }
         catch (error) {
             console.error('Error loading settings', error);
-            throw error; // Re-throw or handle it appropriately
+            throw error;
         }
     }
     async get(key) {
-        if (this.settingsCache.size == 0) {
+        if (this.scopedSettingsCache.size === 0) {
             await this.load();
         }
-        return cloneDeep(this.settingsCache.get(key));
-    }
-    async all() {
-        if (this.settingsCache.size == 0) {
-            await this.load();
+        const scopeOrder = [AXPSettingScope.User, AXPSettingScope.Tenant, AXPSettingScope.Global, AXPSettingScope.Environment];
+        for (const scope of scopeOrder) {
+            const scopeCache = this.scopedSettingsCache.get(scope);
+            if (scopeCache && scopeCache.has(key)) {
+                const value = scopeCache.get(key);
+                if (value !== undefined && value !== null) {
+                    return cloneDeep(value);
+                }
+            }
+        }
+        const defaults = await this.definitionService.defaultValues();
+        return get(defaults, key); // Fallback if no value is found
+    }
+    async defaultValues(scope) {
+        // TODO: not work properly
+        debugger;
+        const scopeOrder = [AXPSettingScope.Environment, AXPSettingScope.Global, AXPSettingScope.Tenant, AXPSettingScope.User].reverse();
+        const scopeIndex = scopeOrder.indexOf(scope);
+        if (scopeIndex === -1) {
+            throw new Error(`Invalid scope: ${scope}`);
+        }
+        // Accumulate defaults from the current scope and higher scopes
+        const accumulatedDefaults = {};
+        for (let i = scopeIndex; i < scopeOrder.length; i++) {
+            const currentScope = scopeOrder[i];
+            const scopeCache = this.scopedSettingsCache.get(currentScope);
+            if (scopeCache) {
+                scopeCache.forEach((value, key) => {
+                    if (!(key in accumulatedDefaults)) {
+                        accumulatedDefaults[key] = value;
+                    }
+                });
+            }
         }
-        return Object.fromEntries(this.settingsCache);
+        // Merge with global default values from the definition service
+        const globalDefaults = await this.definitionService.defaultValues();
+        return { ...globalDefaults, ...accumulatedDefaults };
     }
-    // Implementation
-    async set(keyOrValues, value) {
-        const changes = {};
-        if (typeof keyOrValues === 'string') {
-            // Single value update
-            const key = keyOrValues;
-            this.settingsCache.set(key, value);
-            changes[key] = value;
-            await this.settingsProvider.set(key, value); // Call single update
+    scope(scope) {
+        const provider = this.providers.find((p) => p.scope === scope);
+        if (!provider) {
+            throw new Error(`No provider found for scope: ${scope}`);
         }
-        else {
-            // Bulk update
-            const values = keyOrValues;
-            for (const [key, val] of Object.entries(values)) {
-                this.settingsCache.set(key, val);
-                changes[key] = val;
-            }
-            await this.settingsProvider.set(values); // Call bulk update
-        }
-        // Prepare the detailed change event
-        const keys = Object.keys(changes);
-        const entries = Array.from(this.settingsCache.entries()).map(([key, value]) => ({ key, value }));
-        // Emit the enhanced onChanged event
-        this.onChanged.next({
-            keys,
-            values: changes,
-            entries,
-        });
+        return new ScopedSettingService(this, provider, this.onChanged, this.scopedSettingsCache.get(scope));
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSettingValueProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSettingValueProviderService, providedIn: 'root' }); }
@@ -1060,7 +1155,52 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
             args: [{
                     providedIn: 'root',
                 }]
-        }] });
+        }], ctorParameters: () => [] });
+class ScopedSettingService {
+    constructor(parent, provider, onChanged, scopeCache) {
+        this.parent = parent;
+        this.provider = provider;
+        this.onChanged = onChanged;
+        this.scopeCache = scopeCache;
+    }
+    async get(key) {
+        const settings = await this.provider.load();
+        const setting = settings.find((s) => s.key === key);
+        return setting ? cloneDeep(setting.value) : undefined;
+    }
+    async all() {
+        const settings = await this.provider.load();
+        return Object.fromEntries(settings.map((s) => [s.key, cloneDeep(s.value)]));
+    }
+    async defaultValues() {
+        return this.parent.defaultValues(this.provider.scope);
+    }
+    async set(keyOrValues, value) {
+        if (typeof keyOrValues === 'string') {
+            // Single key-value pair
+            await this.provider.set(keyOrValues, value);
+            this.scopeCache.set(keyOrValues, value); // Sync the cache
+            this.onChanged.next({
+                scope: this.provider.scope,
+                keys: [keyOrValues],
+                values: { [keyOrValues]: value },
+                entries: [{ key: keyOrValues, value }],
+            });
+        }
+        else {
+            // Multiple key-value pairs
+            await this.provider.set(keyOrValues);
+            Object.entries(keyOrValues).forEach(([key, val]) => this.scopeCache.set(key, val)); // Sync the cache
+            const entries = Object.entries(keyOrValues).map(([key, val]) => ({ key, value: val }));
+            this.onChanged.next({
+                scope: this.provider.scope,
+                keys: Object.keys(keyOrValues),
+                values: keyOrValues,
+                entries,
+            });
+        }
+    }
+}
 
 const AXPNavigateAction = createAction('[Navigate] Action', props());
 const AXPSignOutAction = createAction('[SignOut] Action');
@@ -1103,7 +1243,7 @@ class AXPWorkflowNavigateAction extends AXPWorkflowAction {
             this.router.navigate(payload.commands, payload.extras);
         }
         else {
-            if (payload.commands.toLowerCase().startsWith('http') || payload.target == "blank") {
+            if (payload.commands.toLowerCase().startsWith('http') || payload.target == 'blank') {
                 window.open(payload.commands, '_blank');
             }
             else
@@ -1341,14 +1481,13 @@ const AXP_PLATFORM_CONFIG_TOKEN = new InjectionToken('AXP_PLATFORM_CONFIG_TOKEN'
     },
 });
 const AXPPlatformDefaultConfigs = {
-    copyright: 'ACoreX @ 2023',
+    copyright: 'ACoreX @ 2024',
     title: 'ACoreX Platform',
     logo: {
         dark: new AXPTextLogoConfig('ACoreX'),
         light: new AXPTextLogoConfig('ACoreX'),
         colored: new AXPTextLogoConfig('ACoreX'),
     },
-    useLocalData: false,
     network: {
         timeOut: 5000,
     }
@@ -1359,6 +1498,23 @@ function configPlatform(config = AXPPlatformDefaultConfigs) {
 
 const AXP_ROOT_CONFIG_TOKEN = new InjectionToken('AXP_ROOT_CONFIG_TOKEN');
 
+class AXPFiltersProviderService {
+    async getAll() {
+        return Promise.resolve('');
+    }
+    async execute() {
+        return Promise.resolve('');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPFiltersProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPFiltersProviderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPFiltersProviderService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
 // src/app/directives/grid-layout.directive.ts
 class AXPGridLayoutDirective {
     constructor(el, renderer) {
@@ -1887,7 +2043,7 @@ withMethods((store, router = inject(Router), globalStore = inject(Store)) => {
                     }
                     if (item.path) {
                         // Check if the item path matches the current path
-                        const matchResult = pathsMatch(item.path, path);
+                        const matchResult = pathsMatch(item.path, path, ["list", "view", "edit", "create"]);
                         if (matchResult.isMatch) {
                             return { item, isPartialMatch: matchResult.isPartial };
                         }
@@ -1895,27 +2051,31 @@ withMethods((store, router = inject(Router), globalStore = inject(Store)) => {
                 }
                 return { item: null, isPartialMatch: false };
             };
-            const pathsMatch = (itemPath, currentPath) => {
-                // Split both paths into segments
+            const pathsMatch = (itemPath, currentPath, trailingSegmentsToIgnore = []) => {
                 const itemSegments = itemPath.split('/').filter(segment => segment.length > 0);
                 const pathSegments = currentPath.split('/').filter(segment => segment.length > 0);
-                // Determine the minimum number of segments to compare
-                const minLength = Math.min(itemSegments.length, pathSegments.length);
-                // Compare segments until we find a mismatch
-                let commonBaseLength = 0;
-                for (let i = 0; i < minLength; i++) {
-                    if (itemSegments[i] === pathSegments[i]) {
-                        commonBaseLength++;
-                    }
-                    else {
-                        break; // Stop at the first mismatch
+                const menuLength = itemSegments.length;
+                const pathLength = pathSegments.length;
+                // Identify the effective base length for the menuPath
+                let effectiveMenuLength = menuLength;
+                if (menuLength > 0 &&
+                    trailingSegmentsToIgnore.includes(itemSegments[menuLength - 1])) {
+                    effectiveMenuLength--; // Exclude trailing non-hierarchical segments
+                }
+                // Check if the menuPath (base segments) is a prefix of browserPath
+                let isPrefix = true;
+                for (let i = 0; i < effectiveMenuLength; i++) {
+                    if (itemSegments[i] !== pathSegments[i]) {
+                        isPrefix = false;
+                        break;
                     }
                 }
-                // Determine if we have a common base of at least 5 segments
-                const isPartialMatch = commonBaseLength >= 5 && commonBaseLength < itemSegments.length;
-                const isExactMatch = commonBaseLength === itemSegments.length && itemSegments.length === pathSegments.length;
+                // Partial match: menuPath base is a strict prefix of browserPath
+                const isPartialMatch = isPrefix && effectiveMenuLength < pathLength;
+                // Exact match: all segments match completely
+                const isExactMatch = isPrefix && effectiveMenuLength === pathLength;
                 return {
-                    isMatch: isPartialMatch || isExactMatch,
+                    isMatch: isExactMatch || isPartialMatch,
                     isPartial: isPartialMatch && !isExactMatch,
                 };
             };
@@ -1960,14 +2120,14 @@ withMethods((store, router = inject(Router), globalStore = inject(Store)) => {
 class AXPFooterTextSlotComponent {
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPFooterTextSlotComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
     static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.0.3", type: AXPFooterTextSlotComponent, isStandalone: true, selector: "ng-component", inputs: { text: "text" }, ngImport: i0, template: `
-      <small class="ax-text-sm  ax-text-neutral-400" [innerHTML]="text"></small>
+      <small class="ax-text-sm" [innerHTML]="text"></small>
     `, isInline: true }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPFooterTextSlotComponent, decorators: [{
             type: Component,
             args: [{
                     template: `
-      <small class="ax-text-sm  ax-text-neutral-400" [innerHTML]="text"></small>
+      <small class="ax-text-sm" [innerHTML]="text"></small>
     `,
                     standalone: true
                 }]
@@ -3146,9 +3306,26 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
                 }]
         }], ctorParameters: () => [{ type: AXPSchemaRegistryService }] });
 
+class AXPFileStorageService {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPFileStorageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPFileStorageService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPFileStorageService, decorators: [{
+            type: Injectable
+        }] });
+
+var AXPFileStorageStatus;
+(function (AXPFileStorageStatus) {
+    AXPFileStorageStatus["Temporary"] = "temporary";
+    AXPFileStorageStatus["Committed"] = "committed";
+    AXPFileStorageStatus["PendingDeletion"] = "pendingDeletion";
+    AXPFileStorageStatus["Archived"] = "archived";
+    AXPFileStorageStatus["Error"] = "error";
+})(AXPFileStorageStatus || (AXPFileStorageStatus = {}));
+
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { ALL_DEFAULT_OPERATORS, AXEntityLoaderDefault, AXMEntityCrudService, AXMEntityCrudServiceImpl, AXMWorkflowErrorHandler, AXPAppStartUpProvider, AXPAppStartUpService, AXPClipBoardService, AXPCommonEffects, AXPCommonModule, AXPCommonWidgetModule, AXPComponentLogoConfig, AXPComponentSlotDirective, AXPComponentSlotLoaderService, AXPComponentSlotModule, AXPComponentSlotRegistryService, AXPCustomOperatorService, AXPCustomOperatorServiceImpl, AXPDataGenerator, AXPDataProvider, AXPDataSeederService, AXPDexieEntityStorageService, AXPDialogConfirmAction, AXPEntityCommandScope, AXPEntityDataProvider, AXPEntityDataProviderImpl, AXPEntityListViewConfigEmpty, AXPEntityQueryType, AXPEntityRegistryService, AXPEntityStorageService, AXPErrorHandlerRegistryService, AXPFilterOperatorMiddlewareService, AXPFilterOperatorMiddlewareServiceImpl, AXPFontIconLogoConfig, AXPFooterTextSlotComponent, AXPGlobalErrorHandler, AXPGridLayoutDirective, AXPImageUrlLogoConfig, AXPLogoComponent, AXPMenuProviderService, AXPMenuService, AXPNavBarSlotComponent, AXPNavigateAction, AXPPdfPageSize, AXPPdfService, AXPPlatformDefaultConfigs, AXPRedirectEvent, AXPRelationshipCardinality, AXPRelationshipKind, AXPSchemaModule, AXPSchemaRegistryService, AXPSettingDefinitionGroupBuilder, AXPSettingDefinitionProviderContext, AXPSettingDefinitionProviderService, AXPSettingDefinitionSectionBuilder, AXPSettingValueProviderService, AXPSignInAction, AXPSignOutAction, AXPStickyDirective, AXPTextLogoConfig, AXPToastAction, AXPWidgetBase, AXPWidgetColumnRendererComponent, AXPWidgetEditBase, AXPWidgetFilterBase, AXPWidgetFilterRendererComponent, AXPWidgetRendererComponent, AXPWorkflowNavigateAction, AXP_DATA_SEEDER_TOKEN, AXP_ENTITY_LOADER, AXP_MENU_PROVIDER, AXP_PLATFORM_CONFIG_TOKEN, AXP_ROOT_CONFIG_TOKEN, AXP_SETTING_DEFINITION_PROVIDER, AXP_SETTING_VALUE_PROVIDER, AXP_WIDGET_TOKEN, BETWEEN_OPER, BOOLEAN_OPERATORS, CONTAINS_OPER, DATE_OPERATORS, ENDS_WITH_OPER, ENVIRONMENT, EQ_OPER, GTE_OPER, GT_OPER, IS_EMPTY_OPER, IS_NOT_EMPTY_OPER, LTE_OPER, LT_OPER, NOT_CONTAINS_OPER, NOT_EQ_OPER, NUMBER_OPERATORS, STARTS_WITH_OPER, STRING_OPERATORS, configPlatform, convertPropertiesToColumns, convertPropertyToColumn, getEntityInfo, resolveActionLook, widgetSchemas };
+export { ALL_DEFAULT_OPERATORS, AXEntityLoaderDefault, AXMEntityCrudService, AXMEntityCrudServiceImpl, AXMWorkflowErrorHandler, AXPAppStartUpProvider, AXPAppStartUpService, AXPClipBoardService, AXPCommonEffects, AXPCommonModule, AXPCommonWidgetModule, AXPComponentLogoConfig, AXPComponentSlotDirective, AXPComponentSlotLoaderService, AXPComponentSlotModule, AXPComponentSlotRegistryService, AXPCustomOperatorService, AXPCustomOperatorServiceImpl, AXPDataGenerator, AXPDataProvider, AXPDataSeederService, AXPDexieEntityStorageService, AXPDialogConfirmAction, AXPEntityCommandScope, AXPEntityDataProvider, AXPEntityDataProviderImpl, AXPEntityListViewConfigEmpty, AXPEntityQueryType, AXPEntityRegistryService, AXPEntityStorageService, AXPErrorHandlerRegistryService, AXPFileStorageService, AXPFileStorageStatus, AXPFilterOperatorMiddlewareService, AXPFilterOperatorMiddlewareServiceImpl, AXPFiltersProviderService, AXPFontIconLogoConfig, AXPFooterTextSlotComponent, AXPGlobalErrorHandler, AXPGridLayoutDirective, AXPImageUrlLogoConfig, AXPLogoComponent, AXPMenuProviderService, AXPMenuService, AXPNavBarSlotComponent, AXPNavigateAction, AXPPdfPageSize, AXPPdfService, AXPPlatformDefaultConfigs, AXPRedirectEvent, AXPRelationshipCardinality, AXPRelationshipKind, AXPSchemaModule, AXPSchemaRegistryService, AXPSettingDefaultValueProvider, AXPSettingDefinitionGroupBuilder, AXPSettingDefinitionProviderContext, AXPSettingDefinitionProviderService, AXPSettingDefinitionSectionBuilder, AXPSettingScope, AXPSettingValueProviderService, AXPSignInAction, AXPSignOutAction, AXPStickyDirective, AXPTextLogoConfig, AXPToastAction, AXPWidgetBase, AXPWidgetColumnRendererComponent, AXPWidgetEditBase, AXPWidgetFilterBase, AXPWidgetFilterRendererComponent, AXPWidgetRendererComponent, AXPWorkflowNavigateAction, AXP_DATA_SEEDER_TOKEN, AXP_ENTITY_LOADER, AXP_MENU_PROVIDER, AXP_PLATFORM_CONFIG_TOKEN, AXP_ROOT_CONFIG_TOKEN, AXP_SETTING_DEFINITION_PROVIDER, AXP_SETTING_VALUE_PROVIDER, AXP_WIDGET_TOKEN, BETWEEN_OPER, BOOLEAN_OPERATORS, CONTAINS_OPER, DATE_OPERATORS, ENDS_WITH_OPER, ENVIRONMENT, EQ_OPER, GTE_OPER, GT_OPER, IS_EMPTY_OPER, IS_NOT_EMPTY_OPER, LTE_OPER, LT_OPER, NOT_CONTAINS_OPER, NOT_EQ_OPER, NUMBER_OPERATORS, STARTS_WITH_OPER, STRING_OPERATORS, configPlatform, convertPropertiesToColumns, convertPropertyToColumn, getEntityInfo, resolveActionLook, widgetSchemas };
 //# sourceMappingURL=acorex-platform-common.mjs.map