@jinntec/fore 1.4.0 → 1.6.0

package/src/fx-instance.js

@@ -30,12 +30,14 @@ async function handleResponse(response) {
     // console.log("********** inside res json *********");
     return response.json();
   }
-  if (responseContentType.startsWith('application/xml')) {
+  if (responseContentType.startsWith('application/xml') ||
+      responseContentType.startsWith('text/xml')) {
+    // See https://www.rfc-editor.org/rfc/rfc7303
     const text = await response.text();
     // console.log('xml ********', result);
     return new DOMParser().parseFromString(text, 'application/xml');
   }
-  return 'done';
+  throw new Error(`unable to handle response content type: ${responseContentType}`);
 }
 
 /**
@@ -49,6 +51,7 @@ export class FxInstance extends HTMLElement {
     super();
     this.model = this.parentNode;
     this.attachShadow({ mode: 'open' });
+    this.originalInstance = null;
   }
 
   connectedCallback() {
@@ -67,6 +70,7 @@ export class FxInstance extends HTMLElement {
       this.type = this.getAttribute('type');
     } else {
       this.type = 'xml';
+      this.setAttribute('type',this.type);
     }
     const style = `
             :host {
@@ -107,6 +111,11 @@ export class FxInstance extends HTMLElement {
     return this;
   }
 
+  reset(){
+    // this._useInlineData();
+    this.instanceData = this.originalInstance;
+  }
+
   evalXPath(xpath) {
     const formElement = this.parentElement.parentElement;
     const result = evaluateXPathToFirstNode(xpath, this.getDefaultContext(), formElement);
@@ -130,7 +139,8 @@ export class FxInstance extends HTMLElement {
       this.createInstanceData();
       return;
     }
-    this.instanceData = data;
+    this._setInitialData(data);
+    // this.instanceData = data;
   }
 
   /**
@@ -168,7 +178,11 @@ export class FxInstance extends HTMLElement {
         newNode.appendChild(doc.createTextNode(p[1]));
         root.appendChild(newNode);
       }
+      this._setInitialData(doc);
+/*
       this.instanceData = doc;
+      this.originalInstance = this.instanceData.cloneNode(true);
+*/
       // this.instanceData.firstElementChild.setAttribute('id', this.id);
       // resolve('done');
     } else if (this.src) {
@@ -183,9 +197,11 @@ export class FxInstance extends HTMLElement {
       // const doc = new DOMParser().parseFromString('<data data-id="default"></data>', 'application/xml');
       const doc = new DOMParser().parseFromString('<data></data>', 'application/xml');
       this.instanceData = doc;
+      this.originalInstance = this.instanceData.cloneNode(true);
     }
     if (this.type === 'json') {
       this.instanceData = {};
+      this.originalInstance = [...this.instanceData];
     }
   }
 
@@ -196,8 +212,8 @@ export class FxInstance extends HTMLElement {
       const key = url.substring(url.indexOf(':') + 1);
 
       const doc = new DOMParser().parseFromString('<data></data>', 'application/xml');
-      const root = doc.firstElementChild;
       this.instanceData = doc;
+      // ### does it make sense to store originalData here?
 
       if (!key) {
         console.warn('no key specified for localStore');
@@ -212,7 +228,6 @@ export class FxInstance extends HTMLElement {
       }
       const data = new DOMParser().parseFromString(serialized, 'application/xml');
       // let data = this._parse(serialized, instance);
-      // root.appendChild(data);
       doc.firstElementChild.replaceWith(data.firstElementChild);
       return;
     }
@@ -221,25 +236,41 @@ export class FxInstance extends HTMLElement {
     try {
       const response = await fetch(url, {
         method: 'GET',
+/*
         mode: 'cors',
         credentials: 'include',
+*/
         headers: {
           'Content-Type': contentType,
         },
       });
-      const { status } = response;
       const data = await handleResponse(response);
+      this._setInitialData(data);
+/*
       if (data.nodeType) {
+        this._setInitialData(data);
         this.instanceData = data;
+        this.originalInstance = this.instanceData.cloneNode(true);
         console.log('instanceData loaded: ', this.id, this.instanceData);
         return;
       }
       this.instanceData = data;
+      this.originalInstance = [...data];
+*/
     } catch (error) {
       throw new Error(`failed loading data ${error}`);
     }
   }
 
+  _setInitialData(data){
+    this.instanceData = data;
+    if(data.nodeType){
+      this.originalInstance = this.instanceData.cloneNode(true);
+    } else {
+      this.originalInstance = {...this.instanceData};
+    }
+  }
+
   _getContentType() {
     if (this.type === 'xml') {
       return 'application/xml';
@@ -257,7 +288,8 @@ export class FxInstance extends HTMLElement {
       const instanceData = new DOMParser().parseFromString(this.innerHTML, 'application/xml');
 
       // console.log('fx-instance init id:', this.id);
-      this.instanceData = instanceData;
+      // this.instanceData = instanceData;
+      this._setInitialData(instanceData);
       // console.log('instanceData ', this.instanceData);
       // console.log('instanceData ', this.instanceData.firstElementChild);
 
@@ -265,28 +297,34 @@ export class FxInstance extends HTMLElement {
       // this.instanceData.firstElementChild.setAttribute('id', this.id);
       // todo: move innerHTML out to shadowDOM (for later reset)
     } else if (this.type === 'json') {
-      this.instanceData = JSON.parse(this.textContent);
+      // this.instanceData = JSON.parse(this.textContent);
+      this._setInitialData(JSON.parse(this.textContent));
     } else if (this.type === 'html') {
-      this.instanceData = this.firstElementChild.children;
+      // this.instanceData = this.firstElementChild.children;
+      this._setInitialData(this.firstElementChild.children)
+
     } else if (this.type === 'text') {
-      this.instanceData = this.textContent;
+      // this.instanceData = this.textContent;
+      this._setInitialData(this.textContent)
     } else {
       console.warn('unknow type for data ', this.type);
     }
   }
 
-  _handleResponse() {
-    console.log('_handleResponse ');
-    const ajax = this.shadowRoot.getElementById('loader');
-    const instanceData = new DOMParser().parseFromString(ajax.lastResponse, 'application/xml');
-    this.instanceData = instanceData;
-    console.log('data: ', this.instanceData);
-  }
+  // _handleResponse() {
+  //   console.log('_handleResponse ');
+  //   const ajax = this.shadowRoot.getElementById('loader');
+  //   const instanceData = new DOMParser().parseFromString(ajax.lastResponse, 'application/xml');
+  //   this.instanceData = instanceData;
+  //   console.log('data: ', this.instanceData);
+  // }
 
+/*
   _handleError() {
     const loader = this.shadowRoot.getElementById('loader');
     console.log('_handleResponse ', loader.lastError);
   }
+*/
 }
 if (!customElements.get('fx-instance')) {
   customElements.define('fx-instance', FxInstance);

package/src/fx-model.js

@@ -6,7 +6,13 @@ import {evaluateXPath, evaluateXPathToBoolean} from './xpath-evaluation.js';
 import {XPathUtil} from './xpath-util.js';
 
 /**
- * @ts-check
+ * The model of this Fore scope. It holds all the intances, binding, submissions and custom functions that
+ * as required.
+ *
+ * The model is updatin by executing rebuild (as needed), recalculate and revalidate in turn.
+ *
+ * After the cycle is run all modelItems have updated their stete to reflect latest computations.
+ *
  */
 export class FxModel extends HTMLElement {
     static dataChanged = false;
@@ -103,7 +109,6 @@ export class FxModel extends HTMLElement {
         // console.time('instance-loading');
         const instances = this.querySelectorAll('fx-instance');
         if (instances.length > 0) {
-            console.group('init instances');
             const promises = [];
             instances.forEach(instance => {
                 promises.push(instance.init());
@@ -119,7 +124,6 @@ export class FxModel extends HTMLElement {
             await Fore.dispatch(this, 'model-construct-done', {model: this});
             this.inited = true;
             this.updateModel();
-            console.groupEnd();
         } else {
             // ### if there's no instance one will created
             await this.dispatchEvent(
@@ -145,17 +149,20 @@ export class FxModel extends HTMLElement {
     updateModel() {
         // console.time('updateModel');
         this.rebuild();
+/*
         if (this.skipUpdate){
             console.info('%crecalculate/revalidate skipped - no bindings', 'font-style: italic; background: #90a4ae; color:lightgrey; padding:0.3rem 5rem 0.3rem 0.3rem;display:block;width:100%;');
             return;
         }
+*/
         this.recalculate();
         this.revalidate();
+        // console.log('updateModel finished with modelItems ', this.modelItems);
+
         // console.timeEnd('updateModel');
     }
 
     rebuild() {
-        console.info('%crebuild', 'font-style: italic; background: #90a4ae; color:white; padding:0.3rem 5rem 0.3rem 0.3rem;display:block;width:100%;');
         this.mainGraph = new DepGraph(false); // do: should be moved down below binds.length check but causes errors in tests.
         this.modelItems = [];
 
@@ -171,15 +178,12 @@ export class FxModel extends HTMLElement {
             bind.init(this);
         });
 
-        console.log(`mainGraph`, this.mainGraph);
+        // console.log(`mainGraph`, this.mainGraph);
         // console.log(`rebuild mainGraph calc order`, this.mainGraph.overallOrder());
 
         // this.dispatchEvent(new CustomEvent('rebuild-done', {detail: {maingraph: this.mainGraph}}));
         Fore.dispatch(this,'rebuild-done',{maingraph:this.mainGraph});
-        console.log(
-            `rebuild finished with modelItems ${this.modelItems.length} item(s)`,
-            this.modelItems,
-        );
+        console.log('mainGraph', this.mainGraph);
     }
 
     /**
@@ -188,20 +192,15 @@ export class FxModel extends HTMLElement {
      * todo: use 'changed' flag on modelItems to determine subgraph for recalculation. Flag already exists but is not used.
      */
     recalculate() {
-        console.info('%crecalculate', 'font-style: italic; background: #90a4ae; color:white; padding:0.3rem 5rem 0.3rem 0.3rem;display:block;width:100%;');
-
         if (!this.mainGraph) {
             return;
         }
 
-        console.group('### recalculate');
-        console.log('changed nodes ', this.changed);
-
-
-        console.time('recalculate');
+        // console.log('changed nodes ', this.changed);
         this.computes = 0;
 
         this.subgraph = new DepGraph(false);
+        // ### create the subgraph for all changed modelItems
         if (this.changed.length !== 0) {
             // ### build the subgraph
             this.changed.forEach(modelItem => {
@@ -246,22 +245,16 @@ export class FxModel extends HTMLElement {
             const toRefresh = [...this.changed];
             this.formElement.toRefresh = toRefresh;
             this.changed = [];
-            console.log('subgraph', this.subgraph);
-            this.dispatchEvent(
-                new CustomEvent('recalculate-done', {detail: {subgraph: this.subgraph}}),
-            );
+            Fore.dispatch(this,'recalculate-done',{graph:this.subgraph,computes:this.computes})
         } else {
             const v = this.mainGraph.overallOrder(false);
             v.forEach(path => {
                 const node = this.mainGraph.getNodeData(path);
                 this.compute(node, path);
             });
+            Fore.dispatch(this,'recalculate-done',{graph:this.mainGraph,computes:this.computes})
         }
-        console.log(`recalculated ${this.computes} modelItems`);
-
-        console.timeEnd('recalculate');
         console.log('recalculate finished with modelItems ', this.modelItems);
-        console.groupEnd();
     }
 
     /*
@@ -323,13 +316,13 @@ export class FxModel extends HTMLElement {
                             }
                         }
         */
+                const expr = modelItem.bind[property];
                 if (property === 'calculate') {
-                    const expr = modelItem.bind[property];
                     const compute = evaluateXPath(expr, modelItem.node, this);
                     modelItem.value = compute;
                     modelItem.readonly = true; // calculated nodes are always readonly
                 } else if (property !== 'constraint' && property !== 'type') {
-                    const expr = modelItem.bind[property];
+                    // ### re-compute the Boolean value of all facets expect 'constraint' and 'type' which are handled in revalidate()
                     if (expr) {
                         const compute = evaluateXPathToBoolean(expr, modelItem.node, this);
                         modelItem[property] = compute;
@@ -363,11 +356,9 @@ export class FxModel extends HTMLElement {
      *
      */
     revalidate() {
-        console.info('%crevalidate', 'font-style: italic; background: #90a4ae; color:white; padding:0.3rem 5rem 0.3rem 0.3rem;display:block;width:100%;');
 
         if (this.modelItems.length === 0) return true;
 
-        console.group('### revalidate');
         console.time('revalidate');
 
         // reset submission validation
@@ -384,7 +375,7 @@ export class FxModel extends HTMLElement {
                         */
                 if (typeof bind.hasAttribute === 'function' && bind.hasAttribute('constraint')) {
                     const constraint = bind.getAttribute('constraint');
-                    if (constraint) {
+                    if (constraint && modelItem.node) {
                         const compute = evaluateXPathToBoolean(constraint, modelItem.node, this);
                         // console.log('modelItem validity computed: ', compute);
                         modelItem.constraint = compute;
@@ -400,7 +391,6 @@ export class FxModel extends HTMLElement {
                         modelItem.required = compute;
                         this.formElement.addToRefresh(modelItem); // let fore know that modelItem needs refresh
                         if (!modelItem.node.textContent) {
-                            console.log('modelItem required check failed: ');
                             valid = false;
                         }
                         // if (!compute) valid = false;
@@ -417,12 +407,16 @@ export class FxModel extends HTMLElement {
                 }
             }
         });
-        console.timeEnd('revalidate');
         console.log('modelItems after revalidate: ', this.modelItems);
-        console.groupEnd();
         return valid;
     }
 
+    addChanged(modelItem){
+        if(this.inited){
+            this.changed.push(modelItem);
+        }
+    }
+
     /**
      *
      * @param node
@@ -455,7 +449,11 @@ export class FxModel extends HTMLElement {
         // console.log('instances array ',Array.from(this.instances));
 
         const instArray = Array.from(this.instances);
-        return instArray.find(inst => inst.id === id);
+        const found = instArray.find(inst => inst.id === id);
+        if(!found){
+            return this.getDefaultInstance(); // if id is not found always defaults to first in doc order
+        }
+        return found;
     }
 
     evalBinding(bindingExpr) {

package/src/fx-submission.js

@@ -3,6 +3,7 @@ import {Relevance} from './relevance.js';
 import {foreElementMixin} from './ForeElementMixin.js';
 import {evaluateXPathToString, evaluateXPath} from './xpath-evaluation.js';
 import getInScopeContext from './getInScopeContext.js';
+import {XPathUtil} from "./xpath-util.js";
 
 /**
  * todo: validate='false'
@@ -11,6 +12,7 @@ export class FxSubmission extends foreElementMixin(HTMLElement) {
     constructor() {
         super();
         this.attachShadow({mode: 'open'});
+        this.parameters = new Map();
     }
 
     connectedCallback() {
@@ -45,9 +47,7 @@ export class FxSubmission extends foreElementMixin(HTMLElement) {
             ? this.getAttribute('serialization')
             : 'xml';
 
-        // if (!this.hasAttribute('url')) throw new Error(`url is required for submission: ${this.id}`);
-        if (!this.hasAttribute('url')) console.warn(`url is required for submission: ${this.id}`);
-        this.url = this.getAttribute('url');
+        this.url = this.hasAttribute('url') ? this.getAttribute('url'):null;
 
         this.targetref = this.hasAttribute('targetref') ? this.getAttribute('targetref') : null;
 
@@ -90,31 +90,15 @@ export class FxSubmission extends foreElementMixin(HTMLElement) {
                 return;
             }
         }
-        console.log('model updated....');
         await this._serializeAndSend();
     }
 
-    /**
-     * resolves template expressions for a single attribute
-     * @param expr the attribute value to evaluate
-     * @param node the attribute node used for scoped resolution
-     * @returns {*}
-     * @private
-     */
-    _evaluateAttributeTemplateExpression(expr, node) {
-        const matches = expr.match(/{[^}]*}/g);
-        if (matches) {
-            matches.forEach(match => {
-                console.log('match ', match);
-                const naked = match.substring(1, match.length - 1);
-                const inscope = getInScopeContext(node, naked);
-                const result = evaluateXPathToString(naked, inscope, this.getOwnerForm());
-                const replaced = expr.replaceAll(match, result);
-                console.log('replacing ', expr, ' with ', replaced);
-                expr = replaced;
-            });
+    _getProperty(attrName){
+        if(this.parameters.has(attrName)){
+            return this.parameters.get(attrName);
+        } else {
+            return this.getAttribute(attrName);
         }
-        return expr;
     }
 
     /**
@@ -123,18 +107,23 @@ export class FxSubmission extends foreElementMixin(HTMLElement) {
      * @private
      */
     async _serializeAndSend() {
-        const resolvedUrl = this._evaluateAttributeTemplateExpression(this.url, this);
-
+        const url = this._getProperty('url');
+        const resolvedUrl = this.evaluateAttributeTemplateExpression(url,this);
+        console.log('resolvedUrl',resolvedUrl);
         const instance = this.getInstance();
-        console.log('instance type', instance.type);
+        if (!instance) {
+            Fore.dispatch(this, 'warn', {message: `instance not found ${instance.getAttribute('id')}`})
+        }
+        const instType = instance.getAttribute('type');
+        // console.log('instance type', instance.type);
 
         let serialized;
         if (this.serialization === 'none') {
             serialized = undefined;
         } else {
             // const relevant = this.selectRelevant(instance.type);
-            const relevant = Relevance.selectRelevant(this, instance.type);
-            serialized = this._serialize(instance.type, relevant);
+            const relevant = Relevance.selectRelevant(this, instType);
+            serialized = this._serialize(instType, relevant);
         }
 
         // let serialized = serializer.serializeToString(relevant);
@@ -150,6 +139,7 @@ export class FxSubmission extends foreElementMixin(HTMLElement) {
             this._handleResponse(data);
             // this.dispatch('submit-done', {});
             Fore.dispatch(this, 'submit-done', {});
+            this.parameters.clear();
             return;
         }
 
@@ -162,9 +152,10 @@ export class FxSubmission extends foreElementMixin(HTMLElement) {
                 const serialized = localStorage.getItem(key);
                 if (!serialized) {
                     Fore.dispatch(this, 'submit-error', {message: `Error reading key ${key} from localstorage`});
+                    this.parameters.clear();
                     return;
                 }
-                let data = this._parse(serialized, instance);
+                const data = this._parse(serialized, instance);
                 this._handleResponse(data);
                 if (this.method === 'consume') {
                     localStorage.removeItem(key);
@@ -191,7 +182,6 @@ export class FxSubmission extends foreElementMixin(HTMLElement) {
 
         // ### setting headers
         const headers = this._getHeaders();
-        console.log('headers', headers);
 
         if (!this.methods.includes(this.method.toLowerCase())) {
             // this.dispatch('error', { message: `Unknown method ${this.method}` });
@@ -201,8 +191,10 @@ export class FxSubmission extends foreElementMixin(HTMLElement) {
         try {
             const response = await fetch(resolvedUrl, {
                 method: this.method,
-                mode: 'cors',
-                credentials: 'include',
+                /*
+                                mode: 'cors',
+                                credentials: 'include',
+                */
                 headers,
                 body: serialized,
             });
@@ -220,32 +212,34 @@ export class FxSubmission extends foreElementMixin(HTMLElement) {
                 contentType.startsWith('text/markdown')
             ) {
                 const text = await response.text();
-                this._handleResponse(text);
+                this._handleResponse(text, resolvedUrl,contentType);
             } else if (contentType.startsWith('application/json')) {
                 const json = await response.json();
-                this._handleResponse(json);
+                this._handleResponse(json, resolvedUrl,contentType);
             } else if (contentType.startsWith('application/xml')) {
                 const text = await response.text();
                 const xml = new DOMParser().parseFromString(text, 'application/xml');
-                this._handleResponse(xml);
+                this._handleResponse(xml, resolvedUrl,contentType);
             } else {
                 const blob = await response.blob();
-                this._handleResponse(blob);
+                this._handleResponse(blob, resolvedUrl,contentType);
             }
 
             // this.dispatch('submit-done', {});
             Fore.dispatch(this, 'submit-done', {});
         } catch (error) {
             Fore.dispatch(this, 'submit-error', {error: error.message});
+        } finally {
+            this.parameters.clear();
         }
     }
 
     _parse(serialized, instance) {
         let data = null;
-        if (serialized && instance.type === 'xml') {
+        if (serialized && instance.getAttribute('type') === 'xml') {
             data = new DOMParser().parseFromString(serialized, 'application/xml');
         }
-        if (serialized && instance.type === 'json') {
+        if (serialized && instance.getAttribute('type') === 'json') {
             data = JSON.parse(serialized);
         }
         return data;
@@ -319,8 +313,8 @@ export class FxSubmission extends foreElementMixin(HTMLElement) {
      * @param data
      * @private
      */
-    _handleResponse(data) {
-        console.log('_handleResponse ', data);
+    _handleResponse(data, resolvedUrl, contentType) {
+        // console.log('_handleResponse ', data);
 
         /*
         // ### responses need to be handled depending on their type.
@@ -358,8 +352,8 @@ export class FxSubmission extends foreElementMixin(HTMLElement) {
                 } else {
                     const instanceData = data;
                     targetInstance.instanceData = instanceData;
-                    console.log('### replaced instance ', this.getModel().instances);
-                    console.log('### replaced instance ', targetInstance.instanceData);
+                    // console.log('### replaced instance ', this.getModel().instances);
+                    // console.log('### replaced instance ', targetInstance.instanceData);
                 }
 
                 // Skip any refreshes if the model is not yet inited
@@ -373,12 +367,21 @@ export class FxSubmission extends foreElementMixin(HTMLElement) {
         }
 
         if (this.replace === 'all') {
-            document.getElementsByTagName('html')[0].innerHTML = data;
+            document.open();
+            document.write(data);
+            document.close();
+            window.location.href = resolvedUrl;
+            // document.getElementsByTagName('html')[0].innerHTML = data;
         }
-        if (this.replace === 'target') {
-            const target = this.getAttribute('target');
+        if (this.replace === 'target' && contentType.startsWith('text/html')) {
+            // const target = this.getAttribute('target');
+            const target = this._getProperty('target');
             const targetNode = document.querySelector(target);
-            targetNode.innerHTML = data;
+            if(targetNode){
+                targetNode.innerHTML = data;
+            }else{
+                Fore.dispatch(this, 'submit-error', {message:`targetNode for selector ${target} not found`});
+            }
         }
         if (this.replace === 'redirect') {
             window.location.href = data;

package/src/getInScopeContext.js

@@ -1,6 +1,4 @@
-import {evaluateXPathToFirstNode} from './xpath-evaluation.js';
-import {Fore} from './fore.js';
-
+import { evaluateXPathToFirstNode } from './xpath-evaluation.js';
 import {XPathUtil} from './xpath-util.js';
 
 function _getElement(node) {
@@ -29,8 +27,8 @@ function _getModelInContext(node) {
 }
 
 function _getInitialContext(node, ref) {
-    const parentBind = Fore.getClosest('[ref]', node);
-    const localFore = Fore.getClosest('fx-fore', node);
+    const parentBind = XPathUtil.getClosest('[ref]', node);
+    const localFore = XPathUtil.getClosest('fx-fore', node);
 
     const model = _getModelInContext(node);
 
@@ -62,12 +60,12 @@ export default function getInScopeContext(node, ref) {
     if(parentElement.nodeName === 'FX-FORE'){
         return parentElement.getModel().getDefaultInstance().getDefaultContext();
     }
-    const parentBind = Fore.getClosest('[ref]', parentElement.parentNode);
-    if (parentBind && parentBind.nodeName === 'FX-GROUP') {
+    const parentBind = XPathUtil.getClosest('[ref]', parentElement.parentNode);
+    if (parentBind && (parentBind.nodeName === 'FX-GROUP' || parentBind.nodeName === 'FX-CONTROL')) {
         return parentBind.nodeset;
     }
 
-    const repeatItem = Fore.getClosest('fx-repeatitem', parentElement);
+    const repeatItem = XPathUtil.getClosest('fx-repeatitem', parentElement);
     if (repeatItem) {
         if (node.nodeName === 'context') {
             return evaluateXPathToFirstNode(
@@ -79,6 +77,22 @@ export default function getInScopeContext(node, ref) {
         return repeatItem.nodeset;
     }
 
+  // ### check for repeatitems created by fx-repeat-attributes - this could possibly be unified with standard repeats
+  // const repeatItemFromAttrs = XPathUtil.getClosest('.fx-repeatitem', parentElement);
+  // const repeatItemFromAttrs = XPathUtil.getClosest('.fx-repeatitem', parentElement);
+  const repeatItemFromAttrs = parentElement.closest('.fx-repeatitem');
+
+  if (repeatItemFromAttrs) {
+    // ### determine correct inscopecontext by determining the index of the repeatitem in its parent list and
+    // ### using that as an index on the repeat nodeset
+    const parent = repeatItemFromAttrs.parentNode;
+    const index = Array.from(parent.children).indexOf(repeatItemFromAttrs);
+
+    // ### fetching nodeset from fx-repeat-attributes element
+    const repeatFromAttributes = XPathUtil.getClosest('fx-repeat-attributes', parentElement);
+    return repeatFromAttributes.nodeset[index];
+  }
+
     if (parentElement.hasAttribute('context')) {
         const initialContext = _getInitialContext(parentElement.parentNode, ref);
         const contextAttr = parentElement.getAttribute('context');