@jinntec/fore 0.25.0 → 1.0.0-2

package/src/actions/fx-insert.js

@@ -38,28 +38,32 @@ export class FxInsert extends AbstractAction {
     this.at = Number(this.hasAttribute('at') ? this.getAttribute('at') : 0); // default: size of nodeset, determined later
     this.position = this.hasAttribute('position') ? this.getAttribute('position') : 'after';
     this.origin = this.hasAttribute('origin') ? this.getAttribute('origin') : null; // last item of context seq
-    this.keepValues = this.hasAttribute('keep-values') ? true : false;
+    this.keepValues = !!this.hasAttribute('keep-values');
   }
 
-  _getOriginSequence(inscope, targetSequence) {
-    let originSequence;
+  _cloneOriginSequence(inscope, targetSequence) {
+    let originSequenceClone;
     if (this.origin) {
       // ### if there's an origin attribute use it
-      const originTarget = evaluateXPathToFirstNode(this.origin, inscope, this.getOwnerForm());
-      if (Array.isArray(originTarget) && originTarget.length === 0) {
+      let originTarget;
+      try {
+        originTarget = evaluateXPathToFirstNode(this.origin, inscope, this.getOwnerForm());
+        if (Array.isArray(originTarget) && originTarget.length === 0) {
+          console.warn('invalid origin for this insert action - ignoring...', this);
+          originSequenceClone = null;
+        }
+        originSequenceClone = originTarget.cloneNode(true);
+      } catch (error) {
         console.warn('invalid origin for this insert action - ignoring...', this);
-        // return;
-        originSequence = null;
       }
-      originSequence = originTarget.cloneNode(true);
     } else if (targetSequence) {
       // ### use last item of targetSequence
-      originSequence = this._cloneTargetSequence(targetSequence);
-      if (originSequence && !this.keepValues) {
-        this._clear(originSequence);
+      originSequenceClone = this._cloneTargetSequence(targetSequence);
+      if (originSequenceClone && !this.keepValues) {
+        this._clear(originSequenceClone);
       }
     }
-    return originSequence;
+    return originSequenceClone;
   }
 
   _getInsertIndex(inscope, targetSequence) {
@@ -73,7 +77,7 @@ export class FxInsert extends AbstractAction {
   }
 
   perform() {
-    super.perform();
+    // super.perform();
 
     /*
          todo: !!! calling super here does not correctly give the nodeset - it's likely still a bug in ForeElementMixin !!!
@@ -86,7 +90,7 @@ export class FxInsert extends AbstractAction {
 
     // @ts-ignore
     const targetSequence = evaluateXPathToNodes(this.ref, inscope, this.getOwnerForm());
-    console.log('insert nodeset ', targetSequence);
+    // console.log('insert nodeset ', targetSequence);
 
     // ### obtaining originSequence
     /*
@@ -107,19 +111,19 @@ export class FxInsert extends AbstractAction {
             }
         }
 */
-    const originSequence = this._getOriginSequence(inscope, targetSequence);
-    if (!originSequence) return; // if no origin back out without effect
+    const originSequenceClone = this._cloneOriginSequence(inscope, targetSequence);
+    if (!originSequenceClone) return; // if no origin back out without effect
 
     let insertLocationNode;
     let index;
 
-    let idx = this._getInsertIndex(inscope, targetSequence);
-    console.log('insert index', idx);
+    // const idx = this._getInsertIndex(inscope, targetSequence);
+    // console.log('insert index', idx);
 
     // if the targetSequence is empty but we got an originSequence use inscope as context and ignore 'at' and 'position'
     if (targetSequence.length === 0) {
       insertLocationNode = inscope;
-      inscope.appendChild(originSequence);
+      inscope.appendChild(originSequenceClone);
       index = 1;
       console.log('appended', inscope);
     } else {
@@ -147,38 +151,39 @@ export class FxInsert extends AbstractAction {
 
         insertLocationNode = targetSequence;
         const context = evaluateXPath('count(preceding::*)', targetSequence, this.getOwnerForm());
-        console.log('context', context);
+        // console.log('context', context);
         index = context + 1;
         // index = targetSequence.findIndex(insertLocationNode);
       }
 
       if (this.position && this.position === 'before') {
         // this.at -= 1;
-        insertLocationNode.parentNode.insertBefore(
-          originSequence.cloneNode(true),
-          insertLocationNode,
-        );
+        insertLocationNode.parentNode.insertBefore(originSequenceClone, insertLocationNode);
       }
 
       if (this.position && this.position === 'after') {
         // insertLocationNode.parentNode.append(originSequence);
         // const nextSibl = insertLocationNode.nextSibling;
         index += 1;
-        insertLocationNode.insertAdjacentElement('afterend', originSequence.cloneNode(true));
+        insertLocationNode.insertAdjacentElement('afterend', originSequenceClone);
       }
     }
 
     // console.log('insert context item ', insertLocationNode);
     // console.log('parent ', insertLocationNode.parentNode);
-    console.log('instance ', this.getModel().getDefaultContext());
+    // console.log('instance ', this.getModel().getDefaultContext());
 
-    console.log('<<<<<<< at', this.at);
-    console.log('<<<<<<< index', index);
+    // console.log('<<<<<<< at', this.at);
+    // console.log('<<<<<<< index', index);
+    // todo: this actually should dispatch to respective instance
     document.dispatchEvent(
       new CustomEvent('insert', {
         composed: true,
         bubbles: true,
-        detail: { insertedNodes: originSequence, position: index },
+        detail: {
+          insertedNodes: originSequenceClone,
+          position: index,
+        },
       }),
     );
 
@@ -209,7 +214,7 @@ export class FxInsert extends AbstractAction {
   _clear(n) {
     const attrs = n.attributes;
 
-    //clear attrs
+    // clear attrs
     for (let i = 0; i < attrs.length; i += 1) {
       // n.setAttribute(attrs[i].name,'');
       attrs[i].value = '';

package/src/actions/fx-message.js

@@ -44,7 +44,13 @@ class FxMessage extends AbstractAction {
 
   perform() {
     super.perform();
-    const message = this.textContent;
+    let message;
+    if (this.hasAttribute('value')) {
+      message = this.getValue();
+    } else {
+      message = this.textContent;
+    }
+
     this.dispatchEvent(
       new CustomEvent('message', {
         composed: true,

package/src/actions/fx-send.js

@@ -17,7 +17,7 @@ class FxSend extends AbstractAction {
   connectedCallback() {
     // eslint-disable-next-line wc/guard-super-call
     super.connectedCallback();
-    console.log('connectedCallback ', this);
+    // console.log('connectedCallback ', this);
     this.submission = this.getAttribute('submission');
   }
 

package/src/actions/fx-setvalue.js

@@ -44,12 +44,7 @@ export default class FxSetvalue extends AbstractAction {
     super.perform();
     let { value } = this;
     if (this.valueAttr !== null) {
-      value = evaluateXPath(
-        this.valueAttr,
-        this.getInScopeContext(),
-        this.getOwnerForm(),
-        this.detail,
-      );
+      value = evaluateXPath(this.valueAttr, this.nodeset, this.getOwnerForm(), this.detail);
     } else if (this.textContent !== '') {
       value = this.textContent;
     } else {
@@ -67,10 +62,8 @@ export default class FxSetvalue extends AbstractAction {
 
     if (item.value !== newVal) {
       item.value = newVal;
-      item.changed = true;
-
+      this.getModel().changed.push(modelItem);
       this.needsUpdate = true;
-
       console.log('setvalue[2] ', item, newVal);
     }
   }

package/src/dep_graph.js

@@ -320,6 +320,15 @@ DepGraph.prototype = {
     }
     throw new Error(`Node does not exist: ${node}`);
   },
+
+  /**
+   * Get an array of nodes that have no dependants (i.e. nothing depends on them).
+   */
+  entryNodes() {
+    const self = this;
+    return Object.keys(this.nodes).filter(node => self.incomingEdges[node].length === 0);
+  },
+
   /**
    * Construct the overall processing order for the dependency graph.
    *

package/src/drawdown.js

@@ -0,0 +1,172 @@
+/**
+ * drawdown.js
+ * (c) Adam Leggett
+ */
+
+function markdown(src) {
+  var rx_lt = /</g;
+  var rx_gt = />/g;
+  var rx_space = /\t|\r|\uf8ff/g;
+  var rx_escape = /\\([\\\|`*_{}\[\]()#+\-~])/g;
+  var rx_hr = /^([*\-=_] *){3,}$/gm;
+  var rx_blockquote = /\n *&gt; *([^]*?)(?=(\n|$){2})/g;
+  var rx_list = /\n( *)(?:[*\-+]|((\d+)|([a-z])|[A-Z])[.)]) +([^]*?)(?=(\n|$){2})/g;
+  var rx_listjoin = /<\/(ol|ul)>\n\n<\1>/g;
+  var rx_highlight = /(^|[^A-Za-z\d\\])(([*_])|(~)|(\^)|(--)|(\+\+)|`)(\2?)([^<]*?)\2\8(?!\2)(?=\W|_|$)/g;
+  var rx_code = /\n((```|~~~).*\n?([^]*?)\n?\2|((    .*?\n)+))/g;
+  var rx_link = /((!?)\[(.*?)\]\((.*?)( ".*")?\)|\\([\\`*_{}\[\]()#+\-.!~]))/g;
+  var rx_table = /\n(( *\|.*?\| *\n)+)/g;
+  var rx_thead = /^.*\n( *\|( *\:?-+\:?-+\:? *\|)* *\n|)/;
+  var rx_row = /.*\n/g;
+  var rx_cell = /\||(.*?[^\\])\|/g;
+  var rx_heading = /(?=^|>|\n)([>\s]*?)(#{1,6}) (.*?)( #*)? *(?=\n|$)/g;
+  var rx_para = /(?=^|>|\n)\s*\n+([^<]+?)\n+\s*(?=\n|<|$)/g;
+  var rx_stash = /-\d+\uf8ff/g;
+
+  function replace(rex, fn) {
+    src = src.replace(rex, fn);
+  }
+
+  function element(tag, content) {
+    return '<' + tag + '>' + content + '</' + tag + '>';
+  }
+
+  function blockquote(src) {
+    return src.replace(rx_blockquote, function(all, content) {
+      return element('blockquote', blockquote(highlight(content.replace(/^ *&gt; */gm, ''))));
+    });
+  }
+
+  function list(src) {
+    return src.replace(rx_list, function(all, ind, ol, num, low, content) {
+      var entry = element(
+        'li',
+        highlight(
+          content
+            .split(RegExp('\n ?' + ind + '(?:(?:\\d+|[a-zA-Z])[.)]|[*\\-+]) +', 'g'))
+            .map(list)
+            .join('</li><li>'),
+        ),
+      );
+
+      return (
+        '\n' +
+        (ol
+          ? '<ol start="' +
+            (num
+              ? ol + '">'
+              : parseInt(ol, 36) -
+                9 +
+                '" style="list-style-type:' +
+                (low ? 'low' : 'upp') +
+                'er-alpha">') +
+            entry +
+            '</ol>'
+          : element('ul', entry))
+      );
+    });
+  }
+
+  function highlight(src) {
+    return src.replace(rx_highlight, function(all, _, p1, emp, sub, sup, small, big, p2, content) {
+      return (
+        _ +
+        element(
+          emp
+            ? p2
+              ? 'strong'
+              : 'em'
+            : sub
+            ? p2
+              ? 's'
+              : 'sub'
+            : sup
+            ? 'sup'
+            : small
+            ? 'small'
+            : big
+            ? 'big'
+            : 'code',
+          highlight(content),
+        )
+      );
+    });
+  }
+
+  function unesc(str) {
+    return str.replace(rx_escape, '$1');
+  }
+
+  var stash = [];
+  var si = 0;
+
+  src = '\n' + src + '\n';
+
+  replace(rx_lt, '&lt;');
+  replace(rx_gt, '&gt;');
+  replace(rx_space, '  ');
+
+  // blockquote
+  src = blockquote(src);
+
+  // horizontal rule
+  replace(rx_hr, '<hr/>');
+
+  // list
+  src = list(src);
+  replace(rx_listjoin, '');
+
+  // code
+  replace(rx_code, function(all, p1, p2, p3, p4) {
+    stash[--si] = element('pre', element('code', p3 || p4.replace(/^    /gm, '')));
+    return si + '\uf8ff';
+  });
+
+  // link or image
+  replace(rx_link, function(all, p1, p2, p3, p4, p5, p6) {
+    stash[--si] = p4
+      ? p2
+        ? '<img src="' + p4 + '" alt="' + p3 + '"/>'
+        : '<a href="' + p4 + '">' + unesc(highlight(p3)) + '</a>'
+      : p6;
+    return si + '\uf8ff';
+  });
+
+  // table
+  replace(rx_table, function(all, table) {
+    var sep = table.match(rx_thead)[1];
+    return (
+      '\n' +
+      element(
+        'table',
+        table.replace(rx_row, function(row, ri) {
+          return row == sep
+            ? ''
+            : element(
+                'tr',
+                row.replace(rx_cell, function(all, cell, ci) {
+                  return ci ? element(sep && !ri ? 'th' : 'td', unesc(highlight(cell || ''))) : '';
+                }),
+              );
+        }),
+      )
+    );
+  });
+
+  // heading
+  replace(rx_heading, function(all, _, p1, p2) {
+    return _ + element('h' + p1.length, unesc(highlight(p2)));
+  });
+
+  // paragraph
+  replace(rx_para, function(all, content) {
+    return element('p', unesc(highlight(content)));
+  });
+
+  // stash
+  replace(rx_stash, function(all) {
+    return stash[parseInt(all)];
+  });
+
+  return src.trim();
+}

package/src/fore.js

@@ -34,6 +34,21 @@ export class Fore {
     ];
   }
 
+  static createUUID() {
+    // http://www.ietf.org/rfc/rfc4122.txt
+    const s = [];
+    const hexDigits = '0123456789abcdef';
+    for (let i = 0; i < 36; i += 1) {
+      s[i] = hexDigits.substr(Math.floor(Math.random() * 0x10), 1);
+    }
+    s[14] = '4'; // bits 12-15 of the time_hi_and_version field to 0010
+    s[19] = hexDigits.substr((s[19] & 0x3) | 0x8, 1); // bits 6-7 of the clock_seq_hi_and_reserved to 01
+    s[8] = s[13] = s[18] = s[23] = '-';
+
+    const uuid = s.join('');
+    return uuid;
+  }
+
   static get XFORMS_NAMESPACE_URI() {
     // todo: should be centralized somewhere as constant. Exists in several? places
     return 'http://www.w3.org/2002/xforms';
@@ -55,7 +70,7 @@ export class Fore {
       'FX-GROUP',
       'FX-HINT',
       'FX-INPUT',
-      'FX-ITEMSET',
+      'FX-ITEMS',
       'FX-LABEL',
       'FX-OUTPUT',
       'FX-RANGE',
@@ -79,17 +94,40 @@ export class Fore {
     return Fore.UI_ELEMENTS.includes(elementName);
   }
 
-  // static async refreshChildren(startElement){
-  static async refreshChildren(startElement) {
+  /**
+   * recursively refreshes all UI Elements.
+   *
+   * todo: this could probably made more efficient with significant impact on rendering perf
+   *
+   * @param startElement
+   * @param force
+   * @returns {Promise<unknown>}
+   */
+  static async refreshChildren(startElement, force) {
     const refreshed = new Promise(resolve => {
+      /*
+      if there's an 'refresh-on-view' attribute the element wants to be handled by
+      handleIntersect function that calls the refresh of the respective element and
+      not the global one.
+       */
+      // if(!force && startElement.hasAttribute('refresh-on-view')) return;
+
+      /*  ### attempt with querySelectorAll is even slower than iterating recursively
+
+      const children = startElement.querySelectorAll('[ref]');
+      Array.from(children).forEach(uiElement => {
+        if (Fore.isUiElement(uiElement.nodeName) && typeof uiElement.refresh === 'function') {
+          uiElement.refresh();
+        }
+      });
+*/
       const { children } = startElement;
       if (children) {
         Array.from(children).forEach(element => {
-          // todo: later - check for AVTs
           if (Fore.isUiElement(element.nodeName) && typeof element.refresh === 'function') {
             element.refresh();
-          } else if (element.nodeName !== 'fx-MODEL') {
-            Fore.refreshChildren(element);
+          } else if (element.nodeName.toUpperCase() !== 'FX-MODEL') {
+            Fore.refreshChildren(element, force);
           }
         });
       }
@@ -109,24 +147,94 @@ export class Fore {
     return target;
   }
 
+  /**
+   * returns the proper content-type for instance.
+   *
+   * @param instance an fx-instance element
+   * @returns {string|null}
+   */
+  static getContentType(instance, method) {
+    if (method === 'urlencoded-post') {
+      return 'application/x-www-form-urlencoded; charset=UTF-8';
+    }
+    if (instance.type === 'xml') {
+      return 'application/xml; charset=UTF-8';
+    }
+    if (instance.type === 'json') {
+      return 'application/json';
+    }
+    console.warn('content-type unknown ', instance.type);
+    return null;
+  }
+
+  static fadeInElement(element) {
+    const duration = 600;
+    let fadeIn = () => {
+      // Stop all current animations
+      if (element.getAnimations) {
+        element.getAnimations().map(anim => anim.finish());
+      }
+
+      // Play the animation with the newly specified duration
+      fadeIn = element.animate(
+        {
+          opacity: [0, 1],
+        },
+        duration,
+      );
+      return fadeIn.finished;
+    };
+    return fadeIn();
+  }
+
+  static fadeOutElement(element) {
+    const duration = 2600;
+    let fadeOut = () => {
+      // Stop all current animations
+      if (element.getAnimations) {
+        element.getAnimations().map(anim => anim.finish());
+      }
+
+      // Play the animation with the newly specified duration
+      fadeOut = element.animate(
+        {
+          opacity: [1, 0],
+        },
+        duration,
+      );
+      return fadeOut.finished;
+    };
+    return fadeOut();
+  }
+
+  static dispatch(target, eventName, detail) {
+    const event = new CustomEvent(eventName, {
+      composed: true,
+      bubbles: true,
+      detail,
+    });
+    console.log('firing', event);
+    target.dispatchEvent(event);
+  }
+
   /**
    * clear all text nodes and attribute values to get a 'clean' template.
    * @param n
    * @private
    */
   /*
-  static clear(n) {
-    n.textContent = '';
-    if (n.hasAttributes()) {
-      const attrs = n.attributes;
-      for (let i = 0; i < attrs.length; i+= 1) {
-        attrs[i].value = '';
+    static clear(n) {
+      n.textContent = '';
+      if (n.hasAttributes()) {
+        const attrs = n.attributes;
+        for (let i = 0; i < attrs.length; i+= 1) {
+          attrs[i].value = '';
+        }
+      }
+      const { children } = n;
+      for (let i = 0; i < children.length; i+= 1) {
+        Fore.clear(children[i]);
       }
     }
-    const { children } = n;
-    for (let i = 0; i < children.length; i+= 1) {
-      Fore.clear(children[i]);
-    }
-  }
-*/
+  */
 }

package/src/functions/fx-function.js

@@ -28,9 +28,9 @@ export class FxFunction extends foreElementMixin(HTMLElement) {
     const type = this.getAttribute('type') || 'text/xpath';
 
     // Parse the signature to something useful
-    // Signature is of the form `my:sumproduct($p as xs:decimal*, $q as xs:decimal*) as xs:decimal`
+    // Signature is of the form `my:sumproduct($p as xs:decimal*, $q as xs:decimal*) as xs:decimal` or local:something($a as item()*) as item()*
     const signatureParseResult = this.signature.match(
-      /(?:(?<prefix>[^:]*):)?(?<localName>[^(]+)\((?<params>[^)]*)\)(?: as (?<returnType>.*))?/,
+      /(?:(?<prefix>[^:]*):)?(?<localName>[^(]+)\((?<params>(?:\(\)|[^)])*)\)(?: as (?<returnType>.*))?/,
     );
 
     if (!signatureParseResult) {

package/src/fx-bind.js

@@ -182,12 +182,11 @@ export class FxBind extends foreElementMixin(HTMLElement) {
     if (this.bindType === 'xml') {
       this.nodeset.forEach(node => {
         const path = XPathUtil.getPath(node);
+        this.model.mainGraph.addNode(path, node);
 
         if (this.calculate) {
           this.model.mainGraph.addNode(`${path}:calculate`, node);
           // Calculated values are a dependency of the model item.
-          // Make `model1` depend on `model1:calculate`
-          this.model.mainGraph.addNode(path, node);
           this.model.mainGraph.addDependency(path, `${path}:calculate`);
         }
 
@@ -196,11 +195,13 @@ export class FxBind extends foreElementMixin(HTMLElement) {
           this._addDependencies(calculateRefs, node, path, 'calculate');
         }
 
-        const readonlyRefs = this._getReferencesForProperty(this.readonly, node);
-        if (readonlyRefs.length !== 0) {
-          this._addDependencies(readonlyRefs, node, path, 'readonly');
-        } else if (this.readonly) {
-          this.model.mainGraph.addNode(`${path}:readonly`, node);
+        if (!this.calculate) {
+          const readonlyRefs = this._getReferencesForProperty(this.readonly, node);
+          if (readonlyRefs.length !== 0) {
+            this._addDependencies(readonlyRefs, node, path, 'readonly');
+          } else if (this.readonly) {
+            this.model.mainGraph.addNode(`${path}:readonly`, node);
+          }
         }
 
         // const requiredRefs = this.requiredReferences;
@@ -466,6 +467,7 @@ export class FxBind extends foreElementMixin(HTMLElement) {
 
     // let value = null;
     // const mItem = {};
+    /*
     let targetNode = {};
     if (node.nodeType === node.TEXT_NODE) {
       // const parent = node.parentNode;
@@ -474,6 +476,8 @@ export class FxBind extends foreElementMixin(HTMLElement) {
     } else {
       targetNode = node;
     }
+*/
+    const targetNode = node;
 
     // const path = fx.evaluateXPath('path()',node);
     // const path = this.getPath(node);