@fnet/cli 0.4.25 → 0.5.0

package/template/fnet/node/src/default/macros/block-assign.js.njk

@@ -0,0 +1,3 @@
+{% for assign in context.transform.assign %}
+flow.set({{assign.key | safe}},{{assign.value | safe}});
+{% endfor%}

package/template/fnet/node/src/default/macros/block-body-header.js.njk

@@ -0,0 +1,7 @@
+if (this.constructor !== Block) throw Error(Message.USE_CONSTRUCTOR);
+
+this.context=context;
+
+const { engine, flow, caller, error }=context || {};
+
+const _this=this;

package/template/fnet/node/src/default/macros/block-entry-args.js.njk

@@ -0,0 +1,2 @@
+const args=Array.from(arguments);
+const input=arguments[0];

package/template/fnet/node/src/default/macros/block-footer.js.njk

@@ -0,0 +1,3 @@
+Block.TypeId="{{ typeId }}";
+Block.ParentTypeId="{{ parent.typeId }}";
+Block.IndexKey="{{ indexKey }}";

package/template/fnet/node/src/default/macros/block-header.js.njk

@@ -0,0 +1,11 @@
+// BLOCK: {{indexKey}}
+
+import Message from "../../core/message.js";
+
+{% if context.transform.sleep %}
+import sleep from "../../core/sleep.js";
+{% endif %}
+
+{% if context.transform.assert %}
+import assert from "../../core/assert.js";
+{% endif %}

package/template/fnet/node/src/default/macros/block-library-header.js.njk

@@ -0,0 +1,43 @@
+{% if context.lib.type==='atom'%}
+  {# Check if this is a use: protocol (native JS) #}
+  {% if context.lib.atom.protocol==='use:' %}
+    {# NO IMPORT for use: protocol - it's native JS #}
+    // LIBRARY: {{context.lib.atom.name}} (native)
+  {% else %}
+    // LIBRARY: {{context.lib.atom.name}}
+    {% if context.lib.atom.relativePath %}
+      {% if context.transform.from and context.transform.import %}
+        {# NEW: from + import pattern (e.g., from: npm:eventemitter3, import: EventEmitter) #}
+        import { {{ context.transform.import | safe }} as LIBRARY } from "{{context.lib.atom.relativePath}}";
+      {% elseif context.transform.import %}
+        {# EXISTING: import pattern (e.g., import: npm:lodash, call: cloneDeep) #}
+        {% if context.transform.libExp %}
+          import { default as LIBRARY } from "{{context.lib.atom.relativePath}}";
+        {% else %}
+          import { {{ context.transform.call | safe  }} as LIBRARY } from "{{context.lib.atom.relativePath}}";
+        {% endif %}
+      {% else %}
+        {# EXISTING: default import #}
+        import { default as LIBRARY } from "{{context.lib.atom.relativePath}}";
+      {% endif %}
+    {% else %}
+      {% if context.transform.from and context.transform.import %}
+        {# NEW: from + import pattern for non-relative paths #}
+        {% if context.transform.libExp %}
+          import { default as LIBRARY } from "../../libs/{{context.lib.atom.id or context.lib.atom.name}}";
+        {% else %}
+          import { {{ context.transform.import | safe }} as LIBRARY } from "../../libs/{{context.lib.atom.id or context.lib.atom.name}}";
+        {% endif %}
+      {% elseif context.transform.import %}
+        {# EXISTING: import pattern for non-relative paths #}
+        import { {{ context.transform.call | safe }} as LIBRARY } from "../../libs/{{context.lib.atom.id or context.lib.atom.name}}";
+      {% else %}
+        {# EXISTING: default import for non-relative paths #}
+        import { default as LIBRARY } from "../../libs/{{context.lib.atom.id or context.lib.atom.name}}";
+      {% endif %}
+    {% endif %}
+  {% endif %}
+{% elseif context.lib.type==='subworkflow' %}
+  // LIBRARY: {{context.lib.indexKey}}
+  import { default as {{context.lib.codeKey}} } from "../{{context.lib.codeKey}}.js";
+{% endif %}

package/template/fnet/node/src/default/macros/block-modules-header.js.njk

@@ -0,0 +1,8 @@
+{% for child in childs %}
+  {% if child.module===true%}
+    {% if not child.definition.dynamic %}
+    // MODULE : {{child.indexKey}}
+    import { default as {{child.codeKey}} } from "./{{child.codeKey}}.js";
+    {% endif %}
+  {% endif %}
+{% endfor%}

package/template/fnet/node/src/default/macros/block-modules.js.njk

@@ -0,0 +1,29 @@
+{% for child in childs %}
+
+  {% if child.module===true%}
+
+    // MODULE : {{child.indexKey}}
+    {% if child.definition.dynamic %}
+      const { default: {{child.codeKey}} } = await import("./{{child.codeKey}}.js");
+    {% endif %}
+
+    m['{{child.name}}']=async function(){
+      const entry=new {{child.codeKey}}({engine,flow,parent:_this,caller:c,module:true});
+      const nextBlock=await entry.run.apply(entry,arguments);
+
+      if(nextBlock?.type==='return') return nextBlock.value;
+      else if(nextBlock?.type==='block') {
+        {% if workflow.parent.context.atom.doc.features.print_module_final_next %}
+          console.log('MODULE FINAL NEXT:',nextBlock);
+        {% endif %}
+        resolve(nextBlock);
+      }
+    }
+    
+    {% if child.context.transform.export %}
+      flow.setModule({{child.context.transform.export | safe}}, m['{{child.name}}']);
+    {% endif %}
+
+  {% endif %}
+
+{% endfor%}

package/template/fnet/node/src/default/macros/block-next-header.js.njk

@@ -0,0 +1,6 @@
+{% if context.next %}
+  {% if not context.next.definition.dynamic %}
+    // NEXT : {{context.next.indexKey}}
+    import { default as {{context.next.codeKey}} } from "./{{context.next.codeKey}}.js";
+  {% endif %}
+{% endif %}

package/template/fnet/node/src/default/macros/block-next.js.njk

@@ -0,0 +1,21 @@
+{% if context.next %}
+
+  // NEXT : {{context.next.indexKey}}
+  {% if context.next.definition.dynamic %}
+    const { default: {{context.next.codeKey}} } = await import("./{{context.next.codeKey}}.js");
+  {% endif %}
+
+
+resolve ({
+    type: 'block',
+    from: _this,
+    fromType: _this.constructor,
+    fromClosure: c,
+    toType:{{context.next.codeKey}},
+    error,
+    {% if context.transform.output %}
+    input: {{context.transform.output | safe}},
+    {% endif %}
+});
+
+{% endif %}

package/template/fnet/node/src/default/macros/block-run-footer.js.njk

@@ -0,0 +1,7 @@
+{% if context.transform.print %}
+console.log({{context.transform.print | safe}});
+{% endif%}
+
+{% if context.transform.assert %}
+assert({{context.transform.assert | safe}});
+{% endif%}

package/template/fnet/node/src/default/macros/block-run-form.js.njk

@@ -0,0 +1,32 @@
+{% if context.transform.props %}
+  const formProps ={{context.transform.props | safe}} ;
+{% else %}
+  const formProps={};
+{% endif %}
+
+function actionClick(){
+  flow.continueForNext({key:'{{indexKey}}'});
+}
+
+formProps.form=form;
+
+formProps.actionClick=actionClick;
+
+function Form(){
+  React.useEffect(()=>{
+
+    {% if workflow.parent.context.atom.doc.features.print_form_mounts %}
+      console.log('MOUNT:','{{indexKey}}');
+    {% endif %}
+
+    return ()=>{
+      {% if workflow.parent.context.atom.doc.features.print_form_mounts %}
+        console.log('UNMOUNT:','{{indexKey}}');
+      {% endif %}
+    }
+  },[]);
+  
+  return React.createElement(formLib,formProps);
+}
+
+engine.setActiveForm({ form: Form, props:formProps });

package/template/fnet/node/src/default/macros/block-run-header.js.njk

@@ -0,0 +1,43 @@
+{# variables #}
+const v=flow.get();
+
+{# module #}
+{% if hasModules %}
+const m={};
+{% else %}
+const m = null;
+{% endif %}
+
+{# form #}
+{% if type === 'form' %}
+const form={};
+{% else %}
+const form=null;
+{% endif %}
+
+{# closure #}
+const c={
+  caller,
+  resolve,
+  reject,
+  args,
+  get form(){return form||caller?.form},
+  get module(){return m||caller?.module},
+  get for(){
+    // Proxy pattern for nested loop variable resolution with closure semantics
+    // Inner loops shadow outer loops, but parent scope is accessible via fallback
+    return caller?.for || {};
+  }
+};
+
+{% if workflow.parent.context.atom.doc.features.print_steps %}
+console.log(new Date().toLocaleString(),'{{indexKey}}');
+{% endif %}
+
+{% if context.transform.debugger %}
+debugger;
+{% endif %}
+
+{% if context.transform.sleep %}
+await sleep({{context.transform.sleep}});
+{% endif %}

package/template/fnet/node/src/default/macros/block-signal.js.njk

@@ -0,0 +1,3 @@
+{% if context.transform.signal==='next' %}
+  flow.continueForNext({key:'{{indexKey}}'});
+{% endif %}

package/template/fnet/node/src/default/macros/page.js.njk

@@ -0,0 +1,8 @@
+{% if context.transform.page %}
+    const page= {{context.transform.page | safe}};
+    
+    {% if context.transform.page.title %}
+        document? document.title=page.title:undefined;
+    {% endif %}
+    
+{% endif %}

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

@@ -0,0 +1,125 @@
+// WORKFLOW: {{ indexKey }}
+
+import Object from "../core/object.js";
+
+{% if context.next %}
+  {% if not context.next.definition.dynamic %}
+    // NEXT: {{context.next.indexKey}}
+    import {{context.next.codeKey}} from "./blocks/{{context.next.codeKey}}.js";
+  {% endif %}
+{% endif %}
+
+export default class Workflow extends Object {
+
+  #waitContext;
+
+  constructor(context) {
+    super(context);
+
+    this.engine=context.engine;
+  }
+
+  async init(context) {
+
+    {% if context.transform.params %}
+      const params = context?.params;
+      
+      {% for param in context.transform.params %}
+        {% if param.hasDefault%}
+          {% if param.type ==='string'%}
+            this.set('{{param.key}}',  Reflect.has(params,'{{param.key}}')? params['{{param.key}}']:'{{param.default}}');
+          {% elif param.type ==='object' %}
+            this.set('{{param.key}}',  Reflect.has(params,'{{param.key}}')? params['{{param.key}}']:{{param.default | dump | safe}});
+          {% else %}
+            this.set('{{param.key}}',  Reflect.has(params,'{{param.key}}')? params['{{param.key}}']:{{param.default | dump}});
+          {% endif %}
+        {% else %}
+        this.set('{{param.key}}',this.getValue(params,'{{param.key}}'));
+        {% endif %}
+      {% endfor%}
+
+      this.set('$params',params);
+
+    {% endif %}
+  }
+
+  waitForNext(context){
+    this.#waitContext=context;
+    this.#waitContext?.timeoutId && clearTimeout(this.#waitContext.timeoutId) && (this.#waitContext.timeoutId=undefined);
+    this.#waitContext.timeoutId = setInterval(() => {}, 0x7FFFFFFF);
+  }
+
+  async continueForNext(context){
+    const next=this.#waitContext?.next;
+    this.#waitContext?.timeoutId && clearTimeout(this.#waitContext.timeoutId) && (this.#waitContext.timeoutId=undefined);
+    this.#waitContext=undefined;
+    next && await next();
+  }
+
+  async run(context) {
+
+    {% if workflow.parent.context.atom.doc.features.print_steps %}
+      console.log(new Date().toLocaleString(),'{{indexKey}}');
+    {% endif %}
+
+    {% if context.transform.debugger %}
+      debugger;
+    {% endif %}
+
+    {% if context.transform.sleep %}
+      await sleep({{context.transform.sleep}});
+    {% endif %}
+
+    await this.init(context);
+
+    {% if context.next %}
+
+      {% if context.next.definition.dynamic %}
+        // NEXT : {{context.next.indexKey}}
+        const { default: {{context.next.codeKey}} } = await import("./blocks/{{context.next.codeKey}}.js");
+      {% endif %}
+      
+      {# closure #}
+      const c={};
+
+      let current=new {{context.next.codeKey}}({ parent:this, engine:this.engine, flow:this, caller:c });
+      let currentArgs;
+
+      do {
+
+        {% if workflow.parent.context.atom.doc.features.print_runners %}
+          console.log(new Date().toLocaleString(),' * ', this.constructor.IndexKey,' -> ',current.constructor.IndexKey);
+        {% endif %}
+
+        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 nextBlock;
+        else if(nextBlock?.type!=='block') break;
+
+        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, error:nextBlock.error });
+        currentArgs=nextBlock.input;
+
+      } while(true);
+
+    {% endif %}
+
+    
+    {% if context.transform.print %}
+      console.log({{context.transform.print | safe}});
+    {% endif%}
+
+    {% if context.transform.assert %}
+      assert({{context.transform.assert | safe}});
+    {% endif%}
+
+    return this.result;
+  }
+}
+
+Workflow.TypeId="{{typeId}}";
+Workflow.IndexKey="{{indexKey}}";

package/template/fnet/node/tsconfig.json.njk

@@ -0,0 +1,16 @@
+{
+    "include": [
+        "src/**/*.js"
+    ],
+    "compilerOptions": {
+        "outDir": "./types",
+        "declaration": true,
+        "allowJs": true,
+        "emitDeclarationOnly": true,
+        "target": "es5",
+        "strict": true,
+        "forceConsistentCasingInFileNames": true,
+        "skipLibCheck": true,
+        "jsx": "react-jsx"
+    }
+}

package/template/fnet/project/.gitignore.njk

@@ -0,0 +1,7 @@
+.DS_Store
+.workspace
+.fnet
+.out
+.package
+.npmrc
+.vscode

package/template/fnet/project/.vscode/launch.json.njk

@@ -0,0 +1,41 @@
+{
+  // Use IntelliSense to learn about possible attributes.
+  // Hover to view descriptions of existing attributes.
+  // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "debug-fnet-cli",
+      "type": "node",
+      "request": "launch",
+      "skipFiles": [
+        "<node_internals>/**"
+      ],
+      "program": "${workspaceFolder}/.workspace/src/cli/index.js",
+      "cwd": "${workspaceFolder}/.workspace",
+      "preLaunchTask": "fnet-watch",
+      "console": "integratedTerminal"
+    },
+    {
+      "name": "debug-fnet-app",
+      "type": "chrome",
+      "request": "launch",
+      "url": "http://localhost:3000/dist/app/esm/",
+      "webRoot": "${workspaceFolder}/.workspace",
+      "preLaunchTask": "fnet-watch",
+      // "userDataDir": false,
+      // "runtimeArgs": [
+      //   "--profile-directory=<profile-name>",
+      // ]
+    },
+  ],
+  // "compounds": [
+  //   {
+  //     "name": "debug-fnet-all",
+  //     "configurations": [
+  //       "debug-fnet-cli",
+  //       "debug-fnet-app"
+  //     ]
+  //   }
+  // ]
+}

package/template/fnet/project/.vscode/tasks.json.njk

@@ -0,0 +1,46 @@
+{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "label": "fnet-build",
+      "type": "shell",
+      "command": "fnet build",
+    },
+    {
+      "label": "fnet-watch",
+      "type": "shell",
+      "command": "fnet watch",
+      "isBackground": true
+    },
+    {
+      "label": "fnet-deploy",
+      "type": "shell",
+      "command": "fnet deploy",
+    },
+    {
+      "label": "fnet-cli",
+      "type": "shell",
+      "command": "fnet cli",
+    },
+    {
+      "label": "fnet-app",
+      "type": "shell",
+      "command": "fnet app",
+    },
+    {
+      "label": "fnet-project-update",
+      "type": "shell",
+      "command": "fnet project -u",
+    },
+    {
+      "label": "fnet-npm-update",
+      "type": "shell",
+      "command": "fnet npm update",
+    },
+    {
+      "label": "fnet-npm-outdated",
+      "type": "shell",
+      "command": "fnet npm outdated",
+    }
+  ]
+}

package/template/fnet/project/fnet/flows.yaml.njk

@@ -0,0 +1,4 @@
+main:
+  steps:
+    - hello-world:        
+        return: Hello World!

package/template/fnet/project/fnet/targets.yaml.njk

@@ -0,0 +1,7 @@
+npm-default:
+  type: npm
+  enabled: false
+  version: "{{npm.version or "0.1.0"}}"  
+  params:
+    # bin: some-bin-name
+    name: "{{npm.name or "@fnet/"+name}}"

package/template/fnet/project/fnet.yaml.njk

@@ -0,0 +1,3 @@
+name: {{name}}
+
+flows: g::file://./fnet/flows.yaml

package/template/fnode/node/.gitignore.njk

@@ -0,0 +1,9 @@
+node_modules
+.DS_Store
+.fnet
+.out
+.package
+.vscode
+.output
+.npmrc
+.bin