@jinntec/fore 1.0.0-0 → 1.0.0-3

package/src/DependencyNotifyingDomFacade.js

@@ -9,7 +9,7 @@ import { getBucketsForNode } from 'fontoxpath';
  */
 export class DependencyNotifyingDomFacade {
   /**
-   * @param  {function(touchedNode: Node): void)} onNodeTouched A function what will be executed whenever a node is 'touched' by the XPath
+   * @param  onNodeTouched - onNodeTouched A function what will be executed whenever a node is 'touched' by the XPath
    */
   constructor(onNodeTouched) {
     this._onNodeTouched = onNodeTouched;
@@ -45,13 +45,21 @@ export class DependencyNotifyingDomFacade {
    * @param  bucket - The bucket that matches the attribute that will be used.
    */
   // eslint-disable-next-line class-methods-use-this
+/*
   getChildNodes(node, bucket) {
     const matchingNodes = Array.from(node.childNodes).filter(
       childNode => !bucket || getBucketsForNode(childNode).includes(bucket),
     );
     return matchingNodes;
   }
+*/
 
+  getChildNodes(node, bucket) {
+    const matchingNodes = Array.from(node.childNodes).filter(
+        childNode => !bucket || getBucketsForNode(childNode).includes(bucket));
+    matchingNodes.forEach(matchingNode => this._onNodeTouched(matchingNode));
+    return matchingNodes;
+  }
   /**
    * Get the data of this node.
    *

package/src/ForeElementMixin.js

@@ -23,12 +23,6 @@ export const foreElementMixin = superclass =>
         model: {
           type: Object,
         },
-        /**
-         * XPath binding expression pointing to bound node
-         */
-        ref: {
-          type: String,
-        },
         /**
          * The modelitem object associated to the bound node holding the evaluated state.
          */
@@ -41,6 +35,15 @@ export const foreElementMixin = superclass =>
         nodeset: {
           type: Object,
         },
+        /**
+         * XPath binding expression pointing to bound node
+         */
+        ref: {
+          type: String,
+        },
+        inScopeVariables: {
+          type: Map,
+        },
       };
     }
 
@@ -50,6 +53,7 @@ export const foreElementMixin = superclass =>
       this.model = null;
       this.modelItem = {};
       this.ref = this.hasAttribute('ref') ? this.getAttribute('ref') : '';
+      this.inScopeVariables = null;
     }
 
     getModel() {
@@ -90,7 +94,7 @@ export const foreElementMixin = superclass =>
      */
     evalInContext() {
       // const inscopeContext = this.getInScopeContext();
-      const inscopeContext = getInScopeContext(this, this.ref);
+      const inscopeContext = getInScopeContext(this.getAttributeNode('ref') || this, this.ref);
       if (!inscopeContext) {
         console.warn('no in scopeContext for ', this);
         return;
@@ -98,26 +102,26 @@ export const foreElementMixin = superclass =>
       if (this.ref === '') {
         this.nodeset = inscopeContext;
       } else if (Array.isArray(inscopeContext)) {
+        /*
         inscopeContext.forEach(n => {
           if (XPathUtil.isSelfReference(this.ref)) {
             this.nodeset = inscopeContext;
           } else {
-            const localResult = evaluateXPathToFirstNode(this.ref, n, null);
+            const localResult = evaluateXPathToFirstNode(this.ref, n, this);
             // console.log('local result: ', localResult);
             this.nodeset.push(localResult);
           }
         });
+*/
+        this.nodeset = evaluateXPathToFirstNode(this.ref, inscopeContext[0], this);
       } else {
         // this.nodeset = fx.evaluateXPathToFirstNode(this.ref, inscopeContext, null, {namespaceResolver: this.namespaceResolver});
-
-        // todo: code below fails - why?
-        const formElement = this.getOwnerForm();
-        if (inscopeContext.nodeType) {
-          this.nodeset = evaluateXPathToFirstNode(this.ref, inscopeContext, formElement);
+        const { nodeType } = inscopeContext;
+        if (nodeType) {
+          this.nodeset = evaluateXPathToFirstNode(this.ref, inscopeContext, this);
         } else {
-          this.nodeset = evaluateXPath(this.ref, inscopeContext, formElement);
+          this.nodeset = evaluateXPath(this.ref, inscopeContext, this);
         }
-        // this.nodeset = evaluateXPath(this.ref,inscopeContext,formElement)
       }
       // console.log('UiElement evaluated to nodeset: ', this.nodeset);
     }
@@ -217,7 +221,11 @@ export const foreElementMixin = superclass =>
     }
 
     getInScopeContext() {
-      return getInScopeContext(this, this.ref);
+      return getInScopeContext(this.getAttributeNode('ref') || this, this.ref);
+    }
+
+    setInScopeVariables(inScopeVariables) {
+      this.inScopeVariables = inScopeVariables;
     }
 
     dispatch(eventName, detail) {
@@ -226,7 +234,7 @@ export const foreElementMixin = superclass =>
         bubbles: true,
         detail,
       });
-      console.log('firing', event);
+      // console.log('firing', event);
       this.dispatchEvent(event);
     }
   };

package/src/actions/abstract-action.js

@@ -81,7 +81,9 @@ export class AbstractAction extends foreElementMixin(HTMLElement) {
 
     this.target = this.getAttribute('target');
     if (this.target) {
-      if (this.target === '#document') {
+      if (this.target === '#window') {
+        window.addEventListener(this.event, e => this.execute(e));
+      } else if (this.target === '#document') {
         document.addEventListener(this.event, e => this.execute(e));
       } else {
         this.targetElement = document.getElementById(this.target);
@@ -122,7 +124,7 @@ export class AbstractAction extends foreElementMixin(HTMLElement) {
     }
 
     // First check if 'if' condition is true - otherwise exist right away
-    if (this.ifExpr && !evaluateXPathToBoolean(this.ifExpr, this.nodeset, this.getOwnerForm())) {
+    if (this.ifExpr && !evaluateXPathToBoolean(this.ifExpr, this.nodeset, this)) {
       return;
     }
 
@@ -137,7 +139,7 @@ export class AbstractAction extends foreElementMixin(HTMLElement) {
           return;
         }
 
-        if (!evaluateXPathToBoolean(this.whileExpr, this.nodeset, this.getOwnerForm())) {
+        if (!evaluateXPathToBoolean(this.whileExpr, this.nodeset, this)) {
           // Done with iterating
           return;
         }
@@ -190,15 +192,14 @@ export class AbstractAction extends foreElementMixin(HTMLElement) {
       const model = this.getModel();
       model.recalculate();
       model.revalidate();
-      model.parentNode.refresh();
-      this._dispatchActionPerformed();
+      model.parentNode.refresh(true);
+      this.dispatchActionPerformed();
     }
   }
 
   /**
-   * @private
    */
-  _dispatchActionPerformed() {
+  dispatchActionPerformed() {
     console.log('action-performed ', this);
     this.dispatchEvent(
       new CustomEvent('action-performed', { composed: true, bubbles: true, detail: {} }),

package/src/actions/fx-action.js

@@ -41,11 +41,16 @@ export class FxAction extends AbstractAction {
       script.src = this.src;
       this.appendChild(script);
     } else {
-      Array.from(children).forEach(action => {
+      Array.from(children).forEach(actionOrVar => {
+        if (actionOrVar.localName === 'fx-var') {
+          return;
+        }
+        const action = actionOrVar;
         action.detail = this.detail;
         // action.perform();
         action.execute();
       });
+      this.dispatchActionPerformed();
       // this.needsUpdate = false;
     }
   }

package/src/actions/fx-dispatch.js

@@ -1,5 +1,6 @@
 import { AbstractAction } from './abstract-action.js';
-import { evaluateXPath } from '../xpath-evaluation.js';
+import { evaluateXPath, resolveId } from '../xpath-evaluation.js';
+import { XPathUtil } from '../xpath-util.js';
 
 /**
  * `fx-dispatch`
@@ -89,7 +90,14 @@ export class FxDispatch extends AbstractAction {
 
     // ### when targetid is given dispatch to that if present (throw an error if not) - otherwise dispatch to document
     if (this.targetid) {
-      const target = document.getElementById(this.targetid);
+      // const target = document.getElementById(this.targetid);
+      let target;
+      if (XPathUtil.isRepeated(this)) {
+        target = resolveId(this.targetid, this.parentNode, null);
+      } else {
+        target = document.getElementById(this.targetid);
+      }
+      console.log('target', target);
       if (!target) {
         throw new Error(`targetid ${this.targetid} does not exist in document`);
       }

package/src/actions/fx-hide.js

@@ -0,0 +1,23 @@
+import { FxAction } from './fx-action.js';
+
+/**
+ * `fx-hide`
+ * hides a dialog
+ *
+ * @customElement
+ * @demo demo/project.html
+ */
+export class FxHide extends FxAction {
+  connectedCallback() {
+    this.dialog = this.getAttribute('dialog');
+    if(!this.dialog){
+      this.dispatch('error',{message:'dialog does not exist'})
+    }
+  }
+
+  perform() {
+    document.getElementById(this.dialog).hide();
+  }
+}
+
+window.customElements.define('fx-hide', FxHide);

package/src/actions/fx-insert.js

@@ -77,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,11 +86,11 @@ export class FxInsert extends AbstractAction {
         */
 
     // ### obtaining targetSequence
-    const inscope = getInScopeContext(this, this.ref);
+    const inscope = getInScopeContext(this.getAttributeNode('ref'), this.ref);
 
     // @ts-ignore
     const targetSequence = evaluateXPathToNodes(this.ref, inscope, this.getOwnerForm());
-    console.log('insert nodeset ', targetSequence);
+    // console.log('insert nodeset ', targetSequence);
 
     // ### obtaining originSequence
     /*
@@ -117,8 +117,8 @@ export class FxInsert extends AbstractAction {
     let insertLocationNode;
     let index;
 
-    const 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) {
@@ -151,7 +151,7 @@ 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);
       }
@@ -171,15 +171,19 @@ export class FxInsert extends AbstractAction {
 
     // 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: originSequenceClone, position: index },
+        detail: {
+          insertedNodes: originSequenceClone,
+          position: index,
+        },
       }),
     );
 

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,7 +44,7 @@ export default class FxSetvalue extends AbstractAction {
     super.perform();
     let { value } = this;
     if (this.valueAttr !== null) {
-      value = evaluateXPath(this.valueAttr, this.nodeset, this.getOwnerForm(), this.detail);
+      value = evaluateXPath(this.valueAttr, this.nodeset, this, this.detail);
     } else if (this.textContent !== '') {
       value = this.textContent;
     } else {
@@ -62,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/actions/fx-show.js

@@ -0,0 +1,23 @@
+import { FxAction } from './fx-action.js';
+
+/**
+ * `fx-confirm`
+ * Displays a simple confirmation before actually executing the nested actions.
+ *
+ * @customElement
+ * @demo demo/project.html
+ */
+export class FxShow extends FxAction {
+  connectedCallback() {
+    this.dialog = this.getAttribute('dialog');
+    if(!this.dialog){
+      this.dispatch('error',{message:'dialog does not exist'})
+    }
+  }
+
+  perform() {
+    document.getElementById(this.dialog).open();
+  }
+}
+
+window.customElements.define('fx-show', FxShow);

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();
+}