@jinntec/fore 1.0.0-3 → 1.0.0

package/src/fx-bind.js

@@ -1,5 +1,6 @@
 import { DependencyNotifyingDomFacade } from './DependencyNotifyingDomFacade.js';
 import { foreElementMixin } from './ForeElementMixin.js';
+import { Fore } from './fore.js';
 import { ModelItem } from './modelitem.js';
 import {
   evaluateXPathToBoolean,
@@ -32,98 +33,8 @@ export class FxBind extends foreElementMixin(HTMLElement) {
 
   static TYPE_DEFAULT = 'xs:string';
 
-  /*
-    static get styles() {
-        return css`
-            :host {
-                display: none;
-            }
-        `;
-    }
-*/
-
-  /*
-    static get properties() {
-        return {
-            ...super.properties,
-
-            /!**
-             * allows to calculate a value. This value will become readonly.
-             *!/
-            calculate: {
-                type: String
-            },
-            contextNode:{
-                type:Object
-            },
-            /!**
-             * arbitrary XPath resolving to xs:boolean - defaults to 'true()'
-             *!/
-            constraint: {
-                type: String
-            },
-            /!**
-             * id of this bind
-             *!/
-            id:{
-                type:String
-            },
-            /!**
-             * the nodeset the bind is referring to by it's binding expression (ref attribute)
-             *!/
-            nodeset: {
-                type: Array
-            },
-            /!**
-             * the owning model of this bind
-             *!/
-            model:{
-                type:Object
-            },
-            /!**
-             * XPath statement resolving to xs:boolean to switch between readonly and readwrite mode - defaults to 'false()'
-             *!/
-            readonly: {
-                type: String
-            },
-            /!**
-             * the XPath binding expression of this bind
-             *!/
-            ref: {
-                type: String
-            },
-            /!**
-             * XPath statement resolving to xs:boolean to switch between relevant and non-relevant mode - defaults to 'true()'
-             *!/
-            relevant: {
-                type: String
-            },
-            /!**
-             * XPath statement resolving to xs:boolean to switch between required and optional - defaults to 'false'.
-             *!/
-            required: {
-                type: String
-            },
-            /!**
-             * XPath statement
-             *!/
-            type: {
-                type: String
-            }
-        };
-    }
-*/
-
   constructor() {
     super();
-    // this.id='';
-    // this.ref = '';
-    // this.readonly = 'false()';
-    // this.required = 'false()';
-    // this.relevant = 'true()';
-    // this.constraint = 'true()';
-    // this.type = 'xs:string';
-    // this.calculate = '';
     this.nodeset = [];
     this.model = {};
     this.contextNode = {};
@@ -165,26 +76,23 @@ export class FxBind extends foreElementMixin(HTMLElement) {
     this._processChildren(model);
   }
 
-  /*
-    //todo: certainly not ideal to rely on duplicating instance id on instance document - better way later ;)
-    static getPath(node){
-        let path = fx.evaluateXPath('path()',node);
-        const instanceId = node.ownerDocument.firstElementChild.getAttribute('id');
-        if(instanceId !== 'default'){
-            return '#' + instanceId + FxBind.shortenPath(path);
-        }else {
-            return FxBind.shortenPath(path);
-        }
-
-    }
-*/
-
   _buildBindGraph() {
     if (this.bindType === 'xml') {
       this.nodeset.forEach(node => {
         const path = XPathUtil.getPath(node);
         this.model.mainGraph.addNode(path, node);
 
+        /* ### catching references in the 'ref' itself...
+        todo: investigate cases where 'ref' attributes use predicates pointing to other nodes. These would not be handled
+        in current implementation.
+
+        General question: are there valid use-cases for using a 'filter' expression to narrow the nodeset
+          where to apply constraints? Guess yes and if it's 'just' for reducing the amount of necessary modelItem objects.
+
+
+        */
+        // const foreignRefs = this.getReferences(this.ref);
+
         if (this.calculate) {
           this.model.mainGraph.addNode(`${path}:calculate`, node);
           // Calculated values are a dependency of the model item.
@@ -251,7 +159,7 @@ export class FxBind extends foreElementMixin(HTMLElement) {
         // console.log('otherPath', otherPath)
 
         // todo: nasty hack to prevent duplicate pathes like 'a[1]' and 'a[1]/text()[1]' to end up as separate nodes in the graph
-        if(!otherPath.endsWith('text()[1]')){
+        if (!otherPath.endsWith('text()[1]')) {
           if (!this.model.mainGraph.hasNode(otherPath)) {
             this.model.mainGraph.addNode(otherPath, ref);
           }
@@ -271,14 +179,6 @@ export class FxBind extends foreElementMixin(HTMLElement) {
     });
   }
 
-  /*
-    render() {
-        return html`
-             <slot></slot>
-        `;
-    }
-*/
-
   getAlert() {
     if (this.hasAttribute('alert')) {
       return this.getAttribute('alert');
@@ -290,33 +190,6 @@ export class FxBind extends foreElementMixin(HTMLElement) {
     return null;
   }
 
-  /*
-        firstUpdated(_changedProperties) {
-            super.firstUpdated(_changedProperties);
-        }
-    */
-
-  /*
-  namespaceResolver(prefix) {
-    // TODO: Do proper namespace resolving. Look at the ancestry / namespacesInScope of the declaration
-
-    /!**
-     * for (let ancestor = this; ancestor; ancestor = ancestor.parentNode) {
-     * 	if (ancestor.getAttribute(`xmlns:${prefix}`)) {
-     *   // Return value
-     *  }
-     * }
-     *!/
-
-    // console.log('namespaceResolver  prefix', prefix);
-    const ns = {
-      xhtml: 'http://www.w3.org/1999/xhtml',
-      // ''    : Fore.XFORMS_NAMESPACE_URI
-    };
-    return ns[prefix] || null;
-  }
-*/
-
   /**
    * overwrites
    */
@@ -335,7 +208,7 @@ export class FxBind extends foreElementMixin(HTMLElement) {
         } else {
           // eslint-disable-next-line no-lonely-if
           if (this.ref) {
-            const localResult = evaluateXPathToNodes(this.ref, n, this.getOwnerForm());
+            const localResult = evaluateXPathToNodes(this.ref, n, this);
             localResult.forEach(item => {
               this.nodeset.push(item);
             });
@@ -351,7 +224,7 @@ export class FxBind extends foreElementMixin(HTMLElement) {
     } else {
       const inst = this.getModel().getInstance(this.instanceId);
       if (inst.type === 'xml') {
-        this.nodeset = evaluateXPathToNodes(this.ref, inscopeContext, this.getOwnerForm());
+        this.nodeset = evaluateXPathToNodes(this.ref, inscopeContext, this);
       } else {
         this.nodeset = this.ref;
       }
@@ -361,11 +234,6 @@ export class FxBind extends foreElementMixin(HTMLElement) {
   _createModelItems() {
     // console.log('#### ', thi+s.nodeset);
 
-    /*
-                if(XPathUtil.isSelfReference(this.ref)){
-                    return;
-                }
-        */
     if (Array.isArray(this.nodeset)) {
       // todo - iterate and create
       // console.log('################################################ ', this.nodeset);
@@ -380,54 +248,6 @@ export class FxBind extends foreElementMixin(HTMLElement) {
     }
   }
 
-  static lazyCreateModelitems(model, ref, nodeset) {
-    if (Array.isArray(nodeset)) {
-      Array.from(nodeset).forEach(n => {
-        FxBind.lazyCreateModelItem(model, ref, n);
-      });
-    } else {
-      FxBind.lazyCreateModelItem(model, ref, nodeset);
-    }
-  }
-
-  /*
-    static lazyCreateModelItem(model,ref,node){
-        console.log('lazyCreateModelItem ', node);
-
-        let mItem = {};
-        let targetNode = {};
-        if(node === null) return null;
-        if(node.nodeType === node.TEXT_NODE){
-            // const parent = node.parentNode;
-            // console.log('PARENT ', parent);
-            targetNode = node.parentNode;
-        }else {
-            targetNode = node;
-        }
-
-        // const path = fx.evaluateXPath('path()',node);
-        const path = FxBind.getPath(node);
-
-        // const path = Fore.evaluateXPath ('path()', node, this, Fore.namespaceResolver) ;
-
-        // ### intializing ModelItem with default values (as there is no <fx-bind> matching for given ref)
-        const mi = new ModelItem(path,
-            ref,
-            FxBind.READONLY_DEFAULT,
-            FxBind.RELEVANT_DEFAULT,
-            FxBind.REQUIRED_DEFAULT,
-            FxBind.CONSTRAINT_DEFAULT,
-            FxBind.TYPE_DEFAULT,
-            targetNode,
-            this);
-
-
-        // console.log('new ModelItem is instanceof ModelItem ', mi instanceof ModelItem);
-        model.registerModelItem(mi);
-        return mi;
-    }
-*/
-
   /**
    * creates a ModelItem for given instance node.
    *
@@ -452,7 +272,7 @@ export class FxBind extends foreElementMixin(HTMLElement) {
         if bind is the dot expression we use the modelitem of the parent
          */
     if (XPathUtil.isSelfReference(this.ref)) {
-      const parentBoundElement = this.parentElement.closest('fx-bind[ref]');
+      const parentBoundElement = Fore.getClosest('fx-bind[ref]', this.parentElement);
       console.log('parent bound element ', parentBoundElement);
 
       if (parentBoundElement) {
@@ -514,16 +334,34 @@ export class FxBind extends foreElementMixin(HTMLElement) {
    */
   _getReferencesForProperty(propertyExpr) {
     if (propertyExpr) {
-      const touchedNodes = new Set();
-      const domFacade = new DependencyNotifyingDomFacade(otherNode => touchedNodes.add(otherNode));
-      this.nodeset.forEach(node => {
-        evaluateXPathToString(propertyExpr, node, this.getOwnerForm(), domFacade);
-      });
+      return this.getReferences(propertyExpr);
+    }
+    return [];
+  }
+
+  getReferences(propertyExpr) {
+    const touchedNodes = new Set();
+    const domFacade = new DependencyNotifyingDomFacade(otherNode => touchedNodes.add(otherNode));
+    this.nodeset.forEach(node => {
+      evaluateXPathToString(propertyExpr, node, this, domFacade);
+    });
+    return Array.from(touchedNodes.values());
+  }
+
+  /*
+    static getReferencesForRef(ref,nodeset){
+      if (ref && nodeset) {
+        const touchedNodes = new Set();
+        const domFacade = new DependencyNotifyingDomFacade(otherNode => touchedNodes.add(otherNode));
+        nodeset.forEach(node => {
+          evaluateXPathToString(ref, node, this, domFacade);
+        });
 
       return Array.from(touchedNodes.values());
     }
     return [];
   }
+  */
 
   _initBooleanModelItemProperty(property, node) {
     // evaluate expression to boolean
@@ -562,4 +400,6 @@ export class FxBind extends foreElementMixin(HTMLElement) {
     return 'default';
   }
 }
-customElements.define('fx-bind', FxBind);
+if (!customElements.get('fx-bind')) {
+  customElements.define('fx-bind', FxBind);
+}