@acorex-platform/framework-client 0.0.58 → 0.0.60

package/fesm2022/acorex-platform-framework-client-layout-widget-core.mjs

@@ -1190,24 +1190,32 @@ class AXPValueWidgetComponent extends AXPLayoutBaseWidgetComponent {
         this.contextService.update(path, value, { origin: 'user' });
         this.onValueChanged.next({ sender: this });
     }
+    /**
+     * Repeater clones pass the row index onto every descendant. Attach that index
+     * to the ancestor array path (`rows[0].field`), not after the leaf (`rows.field.[0]`).
+     * Lodash paths need `rows[0].field` — a dotted `.[0].` segment is a literal key.
+     */
+    joinIndexedWidgetPath(sections) {
+        return sections.filter((section) => section != null && section !== '').join('.').replace(/\.\[(\d+)\]/g, '[$1]');
+    }
     detectFullPath() {
         const sections = [];
         const ids = [];
-        //
+        const rowIndex = this.index;
+        let attachedRowIndex = false;
         let parent = this;
-        //
         while (parent) {
             const isValueWidget = parent instanceof AXPValueWidgetComponent && parent.isValueWidget();
             const valueParent = parent;
             const path = valueParent.path ?? (isValueWidget ? valueParent.name : null);
             const id = valueParent.name;
-            //
             if (path) {
+                if (parent !== this && isValueWidget && rowIndex != null && !attachedRowIndex) {
+                    sections.push(`[${rowIndex}]`);
+                    attachedRowIndex = true;
+                }
                 sections.push(path);
             }
-            if (parent.index != null && isValueWidget) {
-                sections.push(`[${parent.index}]`);
-            }
             if (id) {
                 ids.push(id);
                 if (parent.index != null) {
@@ -1216,9 +1224,9 @@ class AXPValueWidgetComponent extends AXPLayoutBaseWidgetComponent {
             }
             parent = parent.parent;
         }
-        //
-        this.fullPath.set(sections.reverse().join('.'));
-        this.parentPath.set(sections.slice(0, sections.length - 1).join('.'));
+        sections.reverse();
+        this.fullPath.set(this.joinIndexedWidgetPath(sections));
+        this.parentPath.set(this.joinIndexedWidgetPath(sections.slice(0, Math.max(0, sections.length - 1))));
         this._id = this.name || this.parent ? ids.reverse().join('_') : null;
         if (this._id) {
             this.layoutService.registerWidget(this._id, this);
@@ -1255,6 +1263,8 @@ class AXPDataListWidgetComponent extends AXPValueWidgetComponent {
         ...(ngDevMode ? [{ debugName: "textTemplate" }] : /* istanbul ignore next */ []));
         this.dataSource = signal(convertArrayToDataSource([]), /* @ts-ignore */
         ...(ngDevMode ? [{ debugName: "dataSource" }] : /* istanbul ignore next */ []));
+        /** AXDataSource instance from options that the isolated widget copy was built from. */
+        this.boundRemoteDataSource = null;
         /** Query key from options, when options.dataSource is a string or `{ id }` object. */
         this.queryDataSourceName = computed(() => {
             const rawValue = this.options()['dataSource'];
@@ -1365,8 +1375,15 @@ class AXPDataListWidgetComponent extends AXPValueWidgetComponent {
         try {
             if (rawValue instanceof AXDataSource) {
                 this.loadedQueryDefinition.set(null);
-                if (!isEqual(rawValue.config, this.dataSource().config)) {
-                    this.dataSource.set(rawValue);
+                if (this.boundRemoteDataSource !== rawValue) {
+                    this.boundRemoteDataSource = rawValue;
+                    const sourceConfig = rawValue.config;
+                    this.dataSource.set(new AXDataSource({
+                        key: sourceConfig.key,
+                        pageSize: sourceConfig.pageSize,
+                        load: (event) => sourceConfig.load(event),
+                        byKey: sourceConfig.byKey ? (key) => sourceConfig.byKey(key) : undefined,
+                    }));
                 }
                 this.queryDataSourceReady.set(true);
                 return;
@@ -1885,6 +1902,12 @@ class AXPGridBaseLayoutWidgetComponent extends AXPBlockBaseLayoutWidgetComponent
             const g = this.resolvedGrid();
             if (g?.gap)
                 style['gap'] = g.gap;
+            // Numeric columns cannot rely on dynamic Tailwind `grid-cols-${n}` (often purged).
+            // Mirror fieldset-layout and set the template via inline style.
+            const columns = g?.columns;
+            if (typeof columns === 'number' && columns > 0) {
+                style['grid-template-columns'] = `repeat(${columns}, minmax(0, 1fr))`;
+            }
             return style;
         }, /* @ts-ignore */
         ...(ngDevMode ? [{ debugName: "hostGridStyle" }] : /* istanbul ignore next */ []));
@@ -3429,8 +3452,16 @@ class AXPWidgetRendererDirective {
     /**
      * True when a context store path used in an expression (`context.eval`, `context.options`) is
      * affected by `changedPath`.
+     *
+     * Do not drop `repeaterRowIndexConflicts` or re-enable last-segment matching across rows.
+     * `applicationRoleRows[0].applicationId` and `applicationRoleRows[1].applicationId` share the
+     * suffix `applicationId`; treating that as a match clears sibling repeater fields (roles).
+     * Canonical: `libs/framework/client/layout/widget-core/README.md` (repeater context isolation).
      */
     contextStorePathDependsOnChangedPath(evalPath, changedPath) {
+        if (this.repeaterRowIndexConflicts(evalPath, changedPath)) {
+            return false;
+        }
         const normalizePath = (p) => {
             if (!p)
                 return p;
@@ -3454,23 +3485,87 @@ class AXPWidgetRendererDirective {
             }
             return true;
         };
+        const isIndexedOrChildPath = (parent, child) => {
+            if (!parent || !child) {
+                return false;
+            }
+            if (child === parent) {
+                return true;
+            }
+            if (child.startsWith(`${parent}.`) || child.startsWith(`${parent}[`)) {
+                return true;
+            }
+            const wildcardBase = parent.replace(/\.\{[^}]+\}$/, '');
+            if (wildcardBase !== parent) {
+                return child === wildcardBase || child.startsWith(`${wildcardBase}.`) || child.startsWith(`${wildcardBase}[`);
+            }
+            return false;
+        };
         const evalNorm = normalizePath(evalPath);
         const changedNorm = normalizePath(changedPath);
-        const rawMatch = evalPath === changedPath || evalPath.startsWith(changedPath + '.') || changedPath.startsWith(evalPath + '.') || isSegmentSuffix(evalPath, changedPath) || isSegmentSuffix(changedPath, evalPath);
-        const normMatch = evalNorm === changedNorm || evalNorm.startsWith(changedNorm + '.') || changedNorm.startsWith(evalNorm + '.') || isSegmentSuffix(evalNorm, changedNorm) || isSegmentSuffix(changedNorm, evalNorm);
+        const rawMatch = evalPath === changedPath ||
+            isIndexedOrChildPath(evalPath, changedPath) ||
+            isIndexedOrChildPath(changedPath, evalPath) ||
+            isSegmentSuffix(evalPath, changedPath) ||
+            isSegmentSuffix(changedPath, evalPath);
+        const normMatch = evalNorm === changedNorm ||
+            isIndexedOrChildPath(evalNorm, changedNorm) ||
+            isIndexedOrChildPath(changedNorm, evalNorm) ||
+            isSegmentSuffix(evalNorm, changedNorm) ||
+            isSegmentSuffix(changedNorm, evalNorm);
         if (rawMatch || normMatch) {
             return true;
         }
         return this.isPathAlias(evalPath, changedPath);
     }
+    /**
+     * Different indexed rows of the same array must not share context events.
+     * `rows[0].applicationId` must not match `rows[1].applicationId` via suffix (`applicationId`).
+     * Bare `rows` (no `[n]`) still matches every indexed child so list-wide expressions can refresh.
+     * Do not remove this gate or “simplify” it back to suffix-only matching.
+     */
+    repeaterRowIndexConflicts(evalPath, changedPath) {
+        const indexByArray = (path) => {
+            const found = new Map();
+            const matcher = /([^.\[]+)\[(\d+)\]/g;
+            let match;
+            while ((match = matcher.exec(path)) !== null) {
+                found.set(match[1], match[2]);
+            }
+            return found;
+        };
+        const left = indexByArray(evalPath);
+        const right = indexByArray(changedPath);
+        for (const [name, index] of left) {
+            const other = right.get(name);
+            if (other != null && other !== index) {
+                return true;
+            }
+        }
+        return false;
+    }
     /**
      * Whether an expression template string reads context store paths affected by `changedPath`.
+     *
+     * Unresolved `>field` (parentPath empty) is `field` only — never suffix-match every `*.field`.
+     * Do not fold `>` back into generic suffix matching.
      */
     expressionTextDependsOnContextPath(expressionValue, changedPath) {
         const contextEvalRegex = /context\.eval\(['"]([^'\"]+)['"]\)/g;
         let match;
         while ((match = contextEvalRegex.exec(expressionValue)) !== null) {
-            if (this.contextStorePathDependsOnChangedPath(match[1], changedPath)) {
+            const rawPath = match[1];
+            const evalPath = this.resolveRowRelativeContextPath(rawPath);
+            if (rawPath.startsWith('>')) {
+                const relativeField = rawPath.substring(1);
+                if (evalPath === relativeField) {
+                    if (changedPath === evalPath) {
+                        return true;
+                    }
+                    continue;
+                }
+            }
+            if (this.contextStorePathDependsOnChangedPath(evalPath, changedPath)) {
                 return true;
             }
         }
@@ -3568,16 +3663,42 @@ class AXPWidgetRendererDirective {
             return null;
         }
     }
+    /**
+     * `events.context('>field')` is this row only (exact resolved path).
+     * Do not use `*field` / suffix matching for row-local reset triggers — that fires on every
+     * repeater row that has a field of the same name.
+     */
     hasTriggerDependency(changedPath) {
         const node = this.node();
         const triggers = node.triggers || node.options?.['triggers'] || this.mergedOptions()?.triggers;
         if (!triggers)
             return false;
-        // Check if any trigger event depends on the changed path
         for (const trigger of triggers) {
-            if (trigger.event && trigger.event.includes(changedPath)) {
+            const event = typeof trigger.event === 'string' ? trigger.event : '';
+            if (event.includes(changedPath)) {
                 return true;
             }
+            const contextEvent = /events\.context\(\s*['"]([^'"]*)['"]\s*\)/g;
+            let match;
+            while ((match = contextEvent.exec(event)) !== null) {
+                const pattern = match[1];
+                if (!pattern) {
+                    return true;
+                }
+                if (pattern.endsWith('*') && changedPath.startsWith(pattern.slice(0, -1))) {
+                    return true;
+                }
+                if (pattern.startsWith('*') && changedPath.endsWith(pattern.slice(1))) {
+                    return true;
+                }
+                if (pattern.startsWith('>')) {
+                    return changedPath === this.resolveRowRelativeContextPath(pattern);
+                }
+                const resolved = this.resolveRowRelativeContextPath(pattern);
+                if (this.contextStorePathDependsOnChangedPath(resolved, changedPath)) {
+                    return true;
+                }
+            }
         }
         return false;
     }
@@ -3987,6 +4108,20 @@ class AXPWidgetRendererDirective {
             return false;
         }
     }
+    /**
+     * Repeater-relative paths (`>applicationId`) resolve against this widget's parent
+     * row (`applicationRoleRows[0].applicationId`), not every field with the same name.
+     * When `parentPath` is empty the result is the bare field — callers must not treat that
+     * as “any `*.applicationId`”.
+     */
+    resolveRowRelativeContextPath(path) {
+        if (!path.startsWith('>')) {
+            return path;
+        }
+        const rest = path.substring(1);
+        const parent = this.instance?.parentPath?.() ?? '';
+        return parent ? `${parent}.${rest}` : rest;
+    }
     buildExpressionScope() {
         return {
             context: this.getContextScope(),
@@ -3999,10 +4134,7 @@ class AXPWidgetRendererDirective {
     getContextScope() {
         return {
             eval: (path) => {
-                //TODO: Handle array index
-                const fullPath = path.startsWith('>') ? `${this.instance?.parentPath()}.${path.substring(1)}` : path;
-                const value = this.contextService.getValue(fullPath);
-                return value;
+                return this.contextService.getValue(this.resolveRowRelativeContextPath(path));
             },
             set: (path, value) => {
                 this.contextService.update(path, value, { origin: 'user' });
@@ -4029,6 +4161,10 @@ class AXPWidgetRendererDirective {
             },
         };
     }
+    /**
+     * `events.context('>…')` is exact row path only. Do not OR it with
+     * `contextStorePathDependsOnChangedPath` — that suffix-matches sibling rows.
+     */
     getEventScope() {
         return {
             context: (...paths) => {
@@ -4043,18 +4179,19 @@ class AXPWidgetRendererDirective {
                         return false;
                     }
                     return activePaths.some((path) => {
-                        // Pattern: "prefix*" - matches paths that start with prefix
-                        if (path.endsWith('*')) {
-                            const prefix = path.substring(0, path.length - 1);
+                        if (path.startsWith('>')) {
+                            return c.path === this.resolveRowRelativeContextPath(path);
+                        }
+                        const resolved = this.resolveRowRelativeContextPath(path);
+                        if (resolved.endsWith('*')) {
+                            const prefix = resolved.substring(0, resolved.length - 1);
                             return c.path.startsWith(prefix);
                         }
-                        // Pattern: "*suffix" - matches paths that end with suffix
-                        if (path.startsWith('*')) {
-                            const suffix = path.substring(1);
+                        if (resolved.startsWith('*')) {
+                            const suffix = resolved.substring(1);
                             return c.path.endsWith(suffix);
                         }
-                        // Exact match
-                        return c.path === path;
+                        return c.path === resolved || this.contextStorePathDependsOnChangedPath(resolved, c.path);
                     });
                 }));
             },