@fnet/cli 0.2.0

package/template/fnet/node/src/default/input.args.js.njk

@@ -0,0 +1,122 @@
+{% if atom.doc.features.project.format === 'esm' %}
+  import fnetArgs from '@fnet/args';
+  import validate,{schema as inputSchema} from "./validate_input.js";
+
+{% elif atom.doc.features.project.format === 'cjs' %}
+  const fnetArgs = require('@fnet/args');
+  const validate,{schema as inputSchema} = require("./validate_input.js");
+{% endif %}
+
+{% if atom.doc.features.cli.fargs and atom.doc.features.cli.fargs?.enabled !== false %}
+
+  const get_fargs = (argv) => {
+    const fargsIndex = argv.indexOf('--fargs');
+    if (fargsIndex !== -1 && argv[fargsIndex + 1]) return argv[fargsIndex + 1];
+    {% if atom.doc.features.cli.fargs.default %}
+    else return "{{atom.doc.features.cli.fargs.default}}";
+    {% endif %}
+  };
+
+  const get_ftags = (argv) => {
+    const ftags = [];
+    for (let i = 0; i < argv.length; i++) {
+      if (argv[i] === '--ftag' && argv[i + 1]) {
+        ftags.push(argv[i + 1]);
+        i++;
+      }
+    }
+    
+    {% if atom.doc.features.cli.fargs.tags %}
+      return ftags.length > 0 ? ftags : {{atom.doc.features.cli.fargs.tags | dump | safe}};
+    {% else %}
+      return ftags.length > 0 ? ftags : undefined;
+    {% endif %}
+  };
+
+{% endif %}
+
+{% if atom.doc.features.project.format === 'esm' %}
+
+  export default async () => {
+
+    let schema = inputSchema;
+    let initial;
+
+    {% if atom.doc.features.cli.fargs and atom.doc.features.cli.fargs?.enabled !== false %}    
+    const fargs = get_fargs(process.argv.slice(2));
+    const ftags = get_ftags(process.argv.slice(2));
+
+    if (fargs) {
+      const { default: fnetConfig } = await import("@fnet/config");
+      const config = await fnetConfig({ name: fargs, tags: ftags });
+      if (config?.data) {
+        initial=config.data;
+      }
+    }
+    {% endif %}
+
+    const packageCallback = async () => {
+      const { default: url } = await import("node:url");
+      const { default: path } = await import("node:path");
+      const { default: fs } = await import("node:fs");
+      let currentDir = path.dirname(url.fileURLToPath(import.meta.url));
+      let firstPackageJson = path.join(currentDir, "package.json");
+      while (currentDir !== path.parse(currentDir).root && !fs.existsSync(firstPackageJson)) {
+        currentDir = path.dirname(currentDir);
+        firstPackageJson = path.join(currentDir, "package.json");
+      }
+      if (!fs.existsSync(firstPackageJson)) return {
+        name: "Unknown",
+        version: "Unknown"
+      }
+      else return await JSON.parse(fs.readFileSync(firstPackageJson, "utf8"));
+    };
+
+    return await fnetArgs({schema,initial,validate,packageCallback});
+  };
+
+{% elif atom.doc.features.project.format === 'cjs' %}
+
+  module.exports = async () => {
+
+    let schema = inputSchema;
+    let initial;
+
+    {% if atom.doc.features.cli.fargs and atom.doc.features.cli.fargs?.enabled !== false %}    
+    const fargs = get_fargs(process.argv.slice(2));
+    const ftags = get_ftags(process.argv.slice(2));
+
+    if (fargs) {
+      const { default: fnetConfig } = await import("@fnet/config");
+      const config = await fnetConfig({ name: fargs, tags: ftags });
+      if (config?.data) {
+        initial=config.data;
+      }
+    }
+    {% endif %}
+
+    const packageCallback = async () => {
+      const path = require("node:path");
+      const fs = require("node:fs");
+
+      let currentDir = __dirname;
+      let firstPackageJson = path.join(currentDir, "package.json");
+
+      while (currentDir !== path.parse(currentDir).root && !fs.existsSync(firstPackageJson)) {
+        currentDir = path.dirname(currentDir);
+        firstPackageJson = path.join(currentDir, "package.json");
+      }
+
+      if (!fs.existsSync(firstPackageJson)) {
+        return {
+          name: "Unknown",
+          version: "Unknown"
+        };
+      } else {
+        return JSON.parse(fs.readFileSync(firstPackageJson, "utf8"));
+      }
+    };
+
+    return await fnetArgs({schema,initial,validate,packageCallback});
+  };
+{% endif %}

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, onError, 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,14 @@
+// BLOCK: {{indexKey}}
+
+import Message from "../../core/message.js";
+{% if context.transform.print %}
+import print from "../../core/print.js";
+{% endif %}
+
+{% 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}},
+    onError,
+    {% 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 %}
+print({{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,31 @@
+{# 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} };
+
+{% if workflow.parent.context.atom.doc.features.print_steps %}
+console.log(new Date().toLocaleString(),'{{indexKey}}');
+{% endif %}
+
+{% if definition.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 definition.page.title %}
+        document? document.title=page.title:undefined;
+    {% endif %}
+    
+{% endif %}

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

@@ -0,0 +1,7 @@
+// WORKFLOW: {{ indexKey }}
+
+import Object from "../core/object.js";
+
+{% if context.transform.print %}
+import print from "../core/print.js";
+{% endif %}

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

@@ -0,0 +1,123 @@
+{% include "src/default/macros/workflow-header.js.njk" %}
+
+{% 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 definition.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 });
+        currentArgs=nextBlock.input;
+
+      } while(true);
+
+    {% endif %}
+
+    
+    {% if context.transform.print %}
+      print({{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