@fnet/cli 0.3.14 → 0.4.0

package/template/fnet/node/src/default/types/block.js.njk

@@ -0,0 +1,133 @@
+{% macro header() %}
+
+  {% include "src/default/macros/block-header.js.njk" %}
+
+  {% include "src/default/macros/block-next-header.js.njk" %}
+
+  {% include "src/default/macros/block-modules-header.js.njk" %}
+
+  {{ caller() }}
+
+{% endmacro %}
+
+{% macro definition() %}
+
+  export default function Block(context){
+
+    {% include "src/default/macros/block-body-header.js.njk" %}
+
+    this.run= function (){
+        
+      {% include "src/default/macros/block-entry-args.js.njk" %}
+
+      return new Promise((resolve,reject)=>{
+
+        (async () => {
+          try{
+              {% include "src/default/macros/block-run-header.js.njk" %}
+
+              {% include "src/default/macros/page.js.njk" %}
+
+              {% include "src/default/macros/block-modules.js.njk" %}
+
+              {% if (context.next and context.transform.wait==='next') or waitForNext === true %}
+              flow.waitForNext({
+                key:'{{indexKey}}',
+                next: async () => {
+                  {% if context.transform.return %}
+                    resolve({type:'return',value: {{context.transform.return | safe}}});
+                  {% elseif context.next %}
+                    {% include "src/default/macros/block-next.js.njk" %}
+                  {% else %}
+                    resolve();
+                  {% endif %}
+                }
+              });
+              {% endif %}
+
+              {{ caller() }}
+
+              {% if result === true %}
+                {% for assign in context.transform.result %}
+                  flow.set({{assign.key | safe}},{{assign.value | safe}});
+                {% endfor%}
+              {% endif %}
+
+              {% if assign === true %}
+                {% include "src/default/macros/block-assign.js.njk" %}
+              {% endif %}
+
+              {% if signal === true %}
+                {% include "src/default/macros/block-signal.js.njk" %}
+              {% endif %}
+
+              {% if resolve === true %}
+                {% if context.transform.return %}
+                  resolve({type:'return',value: {{context.transform.return | safe}}});
+                {% elseif context.next and context.transform.wait!=='next'%}
+                  {% include "src/default/macros/block-next.js.njk" %}
+                {% elseif not context.next%}
+                  resolve();
+                {% endif %}
+              {% endif %}
+
+              {% include "src/default/macros/block-run-footer.js.njk" %}
+          }
+          catch(error){
+            reject(error);
+          }
+        })();
+      });
+    }
+
+    Object.freeze(this);  
+  }
+
+{% endmacro %}
+
+{% macro footer() %}
+  {% include "src/default/macros/block-footer.js.njk" %}
+  {{ caller() }}
+{% endmacro %}
+
+{% macro runner({ step: null }) %}
+  {% if step.definition.dynamic %}
+    const { default: {{step.codeKey}} } = await import("./{{step.codeKey}}.js");
+  {% endif %}
+
+  let current=new {{step.codeKey}}({ parent:_this, engine, flow, caller:c, error });
+  let currentArgs=args;
+
+  do {
+
+    const nextBlock= typeof currentArgs==='undefined'? await current.run()
+      : Array.isArray(currentArgs)? await current.run.apply(current,currentArgs) : await current.run.call(current, currentArgs) ;
+
+    if(nextBlock?.type==='return') return resolve(nextBlock);
+    else if(nextBlock?.type!=='block') break;
+
+    if(nextBlock.toType.ParentTypeId!==_this.constructor.TypeId)
+      return resolve(nextBlock);
+
+    current=new nextBlock.toType({ parent:_this, engine, flow, caller:c, error });
+    currentArgs=nextBlock.input;
+
+  } while(true);
+{% endmacro %}
+
+{# USAGE #}
+{# 
+
+{% import "src/default/types/block.js.njk" as block with context %}
+
+{% call block.header() %}
+{% endcall %}
+
+{% call block.definition() %}
+
+{% endcall %}
+
+{% call block.footer()%} 
+{% endcall %}
+
+#}

package/template/fnet/node/src/default/workflow.js.njk

@@ -99,7 +99,7 @@ export default class Workflow extends Object {
         if(nextBlock.toType.ParentTypeId!==this.constructor.TypeId)
           throw new Error('Unknown situation');
 
-        current=new nextBlock.toType({ parent:this, engine:this.engine, flow:this, caller:c, onError:nextBlock.onError, error:nextBlock.error });
+        current=new nextBlock.toType({ parent:this, engine:this.engine, flow:this, caller:c, error:nextBlock.error });
         currentArgs=nextBlock.input;
 
       } while(true);