@acorex/platform 19.3.8 → 19.4.1

package/fesm2022/acorex-platform-core.mjs

@@ -1,10 +1,245 @@
-import { get, isPlainObject, set, isArray, merge, isNil, isObjectLike, transform, isEmpty, isUndefined, endsWith, startsWith, includes, lte, gte, lt, gt, isEqual, orderBy } from 'lodash-es';
+import { signalStore, withState, withComputed, withMethods, patchState } from '@ngrx/signals';
+import { get, isPlainObject, set, isArray, merge, isNil, isObjectLike, transform, isEmpty, cloneDeep, isEqual, isUndefined, endsWith, startsWith, includes, lte, gte, lt, gt, orderBy } from 'lodash-es';
 import * as i0 from '@angular/core';
-import { InjectionToken, inject, Injectable, input, effect, Directive, EventEmitter, HostListener, Output, signal, Pipe, provideAppInitializer } from '@angular/core';
+import { computed, InjectionToken, inject, Injectable, input, effect, Directive, EventEmitter, HostListener, Output, ViewContainerRef, ElementRef, signal, Pipe, provideAppInitializer } from '@angular/core';
 import { Subject, interval } from 'rxjs';
 import { AXCalendarService } from '@acorex/core/date-time';
 import { startWith, map } from 'rxjs/operators';
 
+function extractNestedFieldsWildcard(obj, basePath, fields) {
+    const result = {};
+    if (fields.length === 1 && fields[0] === '*') {
+        const fullObj = get(obj, basePath);
+        return isPlainObject(fullObj) ? fullObj : {};
+    }
+    for (const field of fields) {
+        const fullPath = basePath ? `${basePath}.${field}` : field;
+        const value = get(obj, fullPath);
+        set(result, field, value);
+    }
+    return result;
+}
+function setSmart(obj, smartPath, value) {
+    const pathParts = smartPath.split('.');
+    const lastPart = pathParts[pathParts.length - 1];
+    const fieldMatch = lastPart.match(/^\{(.+)\}$/);
+    if (!fieldMatch) {
+        set(obj, smartPath, value);
+        return obj;
+    }
+    const fields = fieldMatch[1].split(',').map((f) => f.trim());
+    const basePath = pathParts.slice(0, -1).join('.');
+    const [arrayKey, ...restPath] = basePath.split('.');
+    // Make sure the array exists
+    if (!obj[arrayKey])
+        obj[arrayKey] = [];
+    // 🟡 Case A: value is array (normal set)
+    if (isArray(value)) {
+        for (let i = 0; i < value.length; i++) {
+            const item = value[i];
+            const targetItem = obj[arrayKey][i] ?? {};
+            const nested = {};
+            if (restPath.length > 0) {
+                const picked = extractNestedFieldsWildcard(item, restPath.join('.'), fields);
+                set(nested, restPath.join('.'), picked);
+            }
+            else {
+                const picked = extractNestedFieldsWildcard(item, '', fields);
+                Object.assign(nested, picked);
+            }
+            obj[arrayKey][i] = merge({}, targetItem, nested);
+        }
+    }
+    // 🟢 Case B: value is a single value → broadcast
+    else {
+        for (let i = 0; i < obj[arrayKey].length; i++) {
+            const targetItem = obj[arrayKey][i] ?? {};
+            const nested = {};
+            if (restPath.length > 0) {
+                for (const field of fields) {
+                    set(nested, `${restPath.join('.')}.${field}`, value);
+                }
+            }
+            else {
+                for (const field of fields) {
+                    set(nested, field, value);
+                }
+            }
+            obj[arrayKey][i] = merge({}, targetItem, nested);
+        }
+    }
+    return obj;
+}
+function extractFieldsFromPath(obj, basePath, fields) {
+    if (fields.length === 1 && fields[0] === '*') {
+        const fullObj = basePath ? get(obj, basePath) : obj;
+        return isPlainObject(fullObj) ? fullObj : {};
+    }
+    const result = {};
+    for (const field of fields) {
+        const fullPath = basePath ? `${basePath}.${field}` : field;
+        const val = get(obj, fullPath);
+        if (val !== undefined) {
+            result[field] = val;
+        }
+    }
+    return result;
+}
+function getSmart(obj, smartPath) {
+    const pathParts = smartPath.split('.');
+    const lastPart = pathParts[pathParts.length - 1];
+    const fieldMatch = lastPart.match(/^\{(.+)\}$/);
+    // Simple get (no fields)
+    if (!fieldMatch) {
+        return get(obj, smartPath);
+    }
+    const fields = fieldMatch[1].split(',').map((f) => f.trim());
+    const basePath = pathParts.slice(0, -1).join('.');
+    const items = get(obj, basePath);
+    if (!isArray(items))
+        return [];
+    const nestedPath = basePath.includes('.') ? basePath.split('.').slice(1).join('.') : '';
+    return items.map((item) => {
+        return extractFieldsFromPath(item, nestedPath, fields);
+    });
+}
+function extractValue(value, key = 'id') {
+    if (isNil(value)) {
+        return null;
+    }
+    ;
+    return isObjectLike(value) ? get(value, key) : value;
+}
+function cleanDeep(obj) {
+    return transform(obj, (result, value, key) => {
+        if (isObjectLike(value)) {
+            const cleaned = cleanDeep(value);
+            if (!isEmpty(cleaned)) {
+                result[key] = cleaned;
+            }
+        }
+        else if (!isNil(value) && // not null or undefined
+            !(typeof value === 'string' && value.trim() === '') && // not empty string
+            !(Array.isArray(value) && value.length === 0) // not empty array
+        ) {
+            result[key] = value;
+        }
+    });
+}
+
+class AXPContextChangeEvent {
+}
+const AXPContextStore = signalStore({
+    providedIn: 'root',
+}, 
+// Initial State
+withState(() => ({
+    data: {}, // Shared context data
+    state: 'initiated', // Current state
+    initialSnapshot: {}, // Snapshot of the first initialized state
+    previousSnapshot: {}, // Snapshot of the previous state
+    lastChange: {
+        state: 'initiated',
+    }, // Last change event
+})), 
+// Computed Signals
+withComputed(({ data, state, lastChange, initialSnapshot, previousSnapshot }) => ({
+    isChanged: computed(() => state() === 'changed'),
+    isReset: computed(() => state() === 'restored'),
+    isInitiated: computed(() => state() === 'initiated'),
+    isEmpty: computed(() => Object.keys(data()).length === 0),
+    snapshot: computed(() => cloneDeep(data())), // Current data snapshot
+    initial: computed(() => cloneDeep(initialSnapshot())), // Initial snapshot
+    previous: computed(() => cloneDeep(previousSnapshot())), // Previous snapshot
+    changeEvent: computed(() => lastChange()), // Reactive last change event
+})), 
+// Methods for State Management
+withMethods((store) => ({
+    // Update a specific value
+    update(path, value) {
+        const currentData = cloneDeep(store.data());
+        const oldValue = getSmart(currentData, path);
+        // Skip if the value hasn't changed
+        if (isEqual(oldValue, value)) {
+            return;
+        }
+        // Update the value and prepare the change event
+        const updatedData = setSmart(currentData, path, value);
+        const changeEvent = {
+            oldValue,
+            newValue: value,
+            path,
+            state: 'changed',
+            data: updatedData,
+        };
+        // Patch the state
+        patchState(store, {
+            previousSnapshot: store.snapshot(), // Save the previous state
+            data: updatedData,
+            state: 'changed',
+            lastChange: changeEvent,
+        });
+    },
+    patch(context) {
+        const currentData = cloneDeep(store.data());
+        // Update the value and prepare the change event
+        const updatedData = { ...currentData, ...context };
+        const changeEvent = {
+            state: 'patch',
+            data: updatedData,
+        };
+        // Patch the state
+        patchState(store, {
+            previousSnapshot: store.snapshot(), // Save the previous state
+            data: updatedData,
+            state: 'changed',
+            lastChange: changeEvent,
+        });
+    },
+    // Reset to the initial state
+    reset() {
+        const initialData = store.initial();
+        const changeEvent = {
+            oldValue: cloneDeep(store.data()), // Current data becomes old value
+            newValue: cloneDeep(initialData), // Reset to the initial state
+            path: '',
+            state: 'restored',
+            data: initialData,
+        };
+        patchState(store, {
+            previousSnapshot: store.snapshot(), // Save the previous state
+            data: initialData,
+            state: 'restored',
+            lastChange: changeEvent,
+        });
+    },
+    // Initialize the state
+    set(initialData) {
+        const currentData = store.data();
+        if (isEqual(currentData, initialData)) {
+            return; // Skip if the current state matches the initial state
+        }
+        const changeEvent = {
+            oldValue: null,
+            newValue: cloneDeep(initialData),
+            path: '',
+            state: 'initiated',
+            data: initialData,
+        };
+        patchState(store, {
+            initialSnapshot: cloneDeep(initialData), // Save the initial state
+            previousSnapshot: store.snapshot(), // Save the current state as the previous
+            data: initialData,
+            state: 'initiated',
+            lastChange: changeEvent,
+        });
+    },
+    // Get a specific value
+    getValue(path) {
+        return getSmart(store.data(), path);
+    },
+})));
+
 class AXPDataGenerator {
     static uuid() {
         return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (char) => {
@@ -175,127 +410,6 @@ class AXPDataGenerator {
     }
 }
 
-function extractNestedFieldsWildcard(obj, basePath, fields) {
-    const result = {};
-    if (fields.length === 1 && fields[0] === '*') {
-        const fullObj = get(obj, basePath);
-        return isPlainObject(fullObj) ? fullObj : {};
-    }
-    for (const field of fields) {
-        const fullPath = basePath ? `${basePath}.${field}` : field;
-        const value = get(obj, fullPath);
-        set(result, field, value);
-    }
-    return result;
-}
-function setSmart(obj, smartPath, value) {
-    const pathParts = smartPath.split('.');
-    const lastPart = pathParts[pathParts.length - 1];
-    const fieldMatch = lastPart.match(/^\{(.+)\}$/);
-    if (!fieldMatch) {
-        set(obj, smartPath, value);
-        return obj;
-    }
-    const fields = fieldMatch[1].split(',').map((f) => f.trim());
-    const basePath = pathParts.slice(0, -1).join('.');
-    const [arrayKey, ...restPath] = basePath.split('.');
-    // Make sure the array exists
-    if (!obj[arrayKey])
-        obj[arrayKey] = [];
-    // 🟡 Case A: value is array (normal set)
-    if (isArray(value)) {
-        for (let i = 0; i < value.length; i++) {
-            const item = value[i];
-            const targetItem = obj[arrayKey][i] ?? {};
-            const nested = {};
-            if (restPath.length > 0) {
-                const picked = extractNestedFieldsWildcard(item, restPath.join('.'), fields);
-                set(nested, restPath.join('.'), picked);
-            }
-            else {
-                const picked = extractNestedFieldsWildcard(item, '', fields);
-                Object.assign(nested, picked);
-            }
-            obj[arrayKey][i] = merge({}, targetItem, nested);
-        }
-    }
-    // 🟢 Case B: value is a single value → broadcast
-    else {
-        for (let i = 0; i < obj[arrayKey].length; i++) {
-            const targetItem = obj[arrayKey][i] ?? {};
-            const nested = {};
-            if (restPath.length > 0) {
-                for (const field of fields) {
-                    set(nested, `${restPath.join('.')}.${field}`, value);
-                }
-            }
-            else {
-                for (const field of fields) {
-                    set(nested, field, value);
-                }
-            }
-            obj[arrayKey][i] = merge({}, targetItem, nested);
-        }
-    }
-    return obj;
-}
-function extractFieldsFromPath(obj, basePath, fields) {
-    if (fields.length === 1 && fields[0] === '*') {
-        const fullObj = basePath ? get(obj, basePath) : obj;
-        return isPlainObject(fullObj) ? fullObj : {};
-    }
-    const result = {};
-    for (const field of fields) {
-        const fullPath = basePath ? `${basePath}.${field}` : field;
-        const val = get(obj, fullPath);
-        if (val !== undefined) {
-            result[field] = val;
-        }
-    }
-    return result;
-}
-function getSmart(obj, smartPath) {
-    const pathParts = smartPath.split('.');
-    const lastPart = pathParts[pathParts.length - 1];
-    const fieldMatch = lastPart.match(/^\{(.+)\}$/);
-    // Simple get (no fields)
-    if (!fieldMatch) {
-        return get(obj, smartPath);
-    }
-    const fields = fieldMatch[1].split(',').map((f) => f.trim());
-    const basePath = pathParts.slice(0, -1).join('.');
-    const items = get(obj, basePath);
-    if (!isArray(items))
-        return [];
-    const nestedPath = basePath.includes('.') ? basePath.split('.').slice(1).join('.') : '';
-    return items.map((item) => {
-        return extractFieldsFromPath(item, nestedPath, fields);
-    });
-}
-function extractValue(value, key = 'id') {
-    if (isNil(value)) {
-        return null;
-    }
-    ;
-    return isObjectLike(value) ? get(value, key) : value;
-}
-function cleanDeep(obj) {
-    return transform(obj, (result, value, key) => {
-        if (isObjectLike(value)) {
-            const cleaned = cleanDeep(value);
-            if (!isEmpty(cleaned)) {
-                result[key] = cleaned;
-            }
-        }
-        else if (!isNil(value) && // not null or undefined
-            !(typeof value === 'string' && value.trim() === '') && // not empty string
-            !(Array.isArray(value) && value.length === 0) // not empty array
-        ) {
-            result[key] = value;
-        }
-    });
-}
-
 function objectKeyValueTransforms(keyName) {
     return {
         getter: (value) => {
@@ -469,6 +583,30 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.10", ngImpo
                 }]
         }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }] });
 
+// src/app/directives/grid-layout.directive.ts
+class AXPContentCheckerDirective {
+    constructor() {
+        this.viewContainerRef = inject(ViewContainerRef);
+        this.elementRef = inject((ElementRef));
+        this.isEmpty = computed(() => this.viewContainerRef.length === 0);
+    }
+    ngAfterViewInit() {
+        setTimeout(() => {
+            console.log(this.elementRef.nativeElement.childNodes);
+        }, 1000);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.10", ngImport: i0, type: AXPContentCheckerDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.10", type: AXPContentCheckerDirective, isStandalone: true, selector: "[axp-content-checker]", exportAs: ["checker"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.10", ngImport: i0, type: AXPContentCheckerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[axp-content-checker]',
+                    standalone: true,
+                    exportAs: 'checker'
+                }]
+        }] });
+
 class AXPBroadcastEventService {
     constructor() {
         this.eventSubjects = new Map();
@@ -583,10 +721,51 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.10", ngImpo
                 }]
         }], ctorParameters: () => [] });
 
+class AXPExpressionEvaluatorScopeProviderContext {
+    constructor() {
+        this.scopes = {};
+    }
+    addScope(namespace, functions) {
+        this.scopes[namespace] = { ...this.scopes[namespace], ...functions };
+    }
+    getScopes() {
+        return this.scopes;
+    }
+}
+const AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER = new InjectionToken('AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER');
+class AXPExpressionEvaluatorScopeProviderService {
+    constructor() {
+        this.providers = inject(AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER, { optional: true });
+        this.cache = null;
+    }
+    async load() {
+        if (this.cache)
+            return;
+        const context = new AXPExpressionEvaluatorScopeProviderContext();
+        if (Array.isArray(this.providers)) {
+            for (const provider of this.providers) {
+                await provider.provide(context);
+            }
+        }
+        this.cache = context.getScopes();
+    }
+    async getScopesAsync() {
+        await this.load();
+        return this.cache || {};
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.10", ngImport: i0, type: AXPExpressionEvaluatorScopeProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.10", ngImport: i0, type: AXPExpressionEvaluatorScopeProviderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.10", ngImport: i0, type: AXPExpressionEvaluatorScopeProviderService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
 class AXPExpressionEvaluatorService {
     constructor() {
         // Memoization cache for compiled expressions
         this.expressionCache = new Map();
+        this.providerService = inject(AXPExpressionEvaluatorScopeProviderService);
     }
     getOrCompileFunction(expression) {
         if (!this.expressionCache.has(expression)) {
@@ -595,15 +774,21 @@ class AXPExpressionEvaluatorService {
         }
         return this.expressionCache.get(expression);
     }
+    async getMergedScope(userScope) {
+        const pluginScopes = await this.providerService.getScopesAsync();
+        // Merge pluginScopes and userScope (userScope takes precedence)
+        return { ...pluginScopes, ...userScope };
+    }
     async evaluate(source, scope) {
         try {
+            const mergedScope = await this.getMergedScope(scope);
             if (typeof source === 'string' && source.includes('{{')) {
-                return await this.evaluateStringExpression(source, scope);
+                return await this.evaluateStringExpression(source, mergedScope);
             }
             else if (Array.isArray(source)) {
                 const evaluatedArray = [];
                 for (const item of source) {
-                    evaluatedArray.push(await this.evaluate(item, scope));
+                    evaluatedArray.push(await this.evaluate(item, mergedScope));
                 }
                 return evaluatedArray;
             }
@@ -611,7 +796,7 @@ class AXPExpressionEvaluatorService {
                 const evaluatedObject = {};
                 for (const key in source) {
                     if (source.hasOwnProperty(key)) {
-                        evaluatedObject[key] = await this.evaluate(source[key], scope);
+                        evaluatedObject[key] = await this.evaluate(source[key], mergedScope);
                     }
                 }
                 return evaluatedObject;
@@ -1368,5 +1553,5 @@ const AXPAppStartUpProvider = provideAppInitializer(() => {
  * Generated bundle index. Do not edit.
  */
 
-export { AXHighlightService, AXPAppStartUpProvider, AXPAppStartUpService, AXPBroadcastEventService, AXPComponentLogoConfig, AXPCountdownPipe, AXPDataGenerator, AXPDataSourceDefinitionProviderService, AXPDblClickDirective, AXPElementDataDirective, AXPExpressionEvaluatorService, AXPGridLayoutDirective, AXPImageUrlLogoConfig, AXPPlatformScope, AXPSystemActions, AXP_DATASOURCE_DEFINITION_PROVIDER, applyFilterArray, applyPagination, applyQueryArray, applySortArray, cleanDeep, extractNestedFieldsWildcard, extractValue, getNestedKeys, getSmart, objectKeyValueTransforms, resolvePlatformScopeKey, resolvePlatformScopeName, setSmart };
+export { AXHighlightService, AXPAppStartUpProvider, AXPAppStartUpService, AXPBroadcastEventService, AXPComponentLogoConfig, AXPContentCheckerDirective, AXPContextChangeEvent, AXPContextStore, AXPCountdownPipe, AXPDataGenerator, AXPDataSourceDefinitionProviderService, AXPDblClickDirective, AXPElementDataDirective, AXPExpressionEvaluatorScopeProviderContext, AXPExpressionEvaluatorScopeProviderService, AXPExpressionEvaluatorService, AXPGridLayoutDirective, AXPImageUrlLogoConfig, AXPPlatformScope, AXPSystemActions, AXP_DATASOURCE_DEFINITION_PROVIDER, AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER, applyFilterArray, applyPagination, applyQueryArray, applySortArray, cleanDeep, extractNestedFieldsWildcard, extractValue, getNestedKeys, getSmart, objectKeyValueTransforms, resolvePlatformScopeKey, resolvePlatformScopeName, setSmart };
 //# sourceMappingURL=acorex-platform-core.mjs.map