@fnet/cli 0.111.0 → 0.111.2

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

@@ -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/bun/.gitignore.njk

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

package/template/fnode/bun/build.js.njk

@@ -0,0 +1,156 @@
+#!/usr/bin/env bun
+/**
+ * Build script for Bun projects
+ * This script uses Bun's built-in bundler instead of Rollup
+ */
+
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import fs from 'node:fs';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+async function ensureDir(dir) {
+  try {
+    await mkdir(dir, { recursive: true });
+  } catch (err) {
+    if (err.code !== 'EEXIST') throw err;
+  }
+}
+
+async function buildOutput(name, config) {
+  console.log(`Building ${name}...`);
+
+  const outdir = config.outdir || join(__dirname, `dist/${name}`);
+  await ensureDir(outdir);
+
+  {% if atom.doc.features.app.enabled !== false %}
+  // Copy HTML file if it exists and this is an app build
+  if (name === 'app') {
+    try {
+      const htmlPath = './src/app/index.html';
+      if (fs.existsSync(htmlPath)) {
+        const htmlContent = await Bun.file(htmlPath).text();
+        await writeFile(join(outdir, 'index.html'), htmlContent);
+      }
+    } catch (err) {
+      if (err.code !== 'ENOENT') {
+        console.warn('Warning: Could not copy HTML file:', err.message);
+      }
+    }
+  }
+  {% endif %}
+
+  // Build with Bun.build
+  const result = await Bun.build({
+    entrypoints: config.entrypoints || [`./src/${name}/index.js`],
+    outdir: outdir,
+    format: config.format || 'esm',
+    target: config.target || 'browser',
+    minify: config.minify !== undefined ? config.minify : false,
+    sourcemap: config.sourcemap || 'external',
+
+    // Mark npm dependencies as external to prevent bundling issues
+    external: (() => {
+      try {
+        const pkg = JSON.parse(fs.readFileSync('./package.json', 'utf8'));
+        return [...Object.keys(pkg.dependencies || {}), ...Object.keys(pkg.devDependencies || {})];
+      } catch (err) {
+        console.warn('Could not read package.json:', err.message);
+        return [];
+      }
+    })(),
+
+    // Add environment variables to help with module resolution
+    define: {
+      'process.env.NODE_PATH': JSON.stringify('./node_modules')
+    },
+
+    plugins: [
+      ...(config.plugins || [])
+    ]
+  });
+
+  if (!result.success) {
+    console.error(`${name} build failed:`, result.logs);
+    process.exit(1);
+  }
+
+  return result;
+}
+
+async function main() {
+  try {
+    {% if atom.doc.features.project.format === 'esm' or atom.doc.features.project.format === undefined %}
+    // Build default ESM
+    await buildOutput('default', {
+      format: "esm",
+      target: "browser",
+      minify: false,
+      sourcemap: "external",
+      entrypoints: ["./src/default/index.js"],
+      outdir: "./dist/default/esm"
+    });
+    {% endif %}
+
+    {% if atom.doc.features.project.format !== 'esm' %}
+    // Build default CJS
+    await buildOutput('defaultCjs', {
+      format: "cjs",
+      target: "node",
+      minify: false,
+      sourcemap: "external",
+      entrypoints: ["./src/default/index.js"],
+      outdir: "./dist/default/cjs"
+    });
+    {% endif %}
+
+    {% if atom.doc.features.cli.enabled !== false %}
+    // Build CLI if exists
+    try {
+      if (fs.existsSync('./src/cli/index.js')) {
+        await buildOutput('cli', {
+          format: "esm",
+          target: "node",
+          minify: false,
+          sourcemap: "external",
+          entrypoints: ["./src/cli/index.js"],
+          outdir: "{{ atom.doc.features.cli.dir | default('./dist/cli/esm') }}"
+        });
+      } else {
+        console.log('CLI not found, skipping CLI build');
+      }
+    } catch (err) {
+      console.log('Error building CLI:', err.message);
+    }
+    {% endif %}
+
+    {% if atom.doc.features.app.enabled !== false %}
+    // Build App if exists
+    try {
+      if (fs.existsSync('./src/app/index.js')) {
+        await buildOutput('app', {
+          format: "esm",
+          target: "browser",
+          minify: false,
+          sourcemap: "external",
+          entrypoints: ["./src/app/index.js"],
+          outdir: "{{ atom.doc.features.app.dir | default('./dist/app/esm') }}"
+        });
+      } else {
+        console.log('App not found, skipping App build');
+      }
+    } catch (err) {
+      console.log('Error building App:', err.message);
+    }
+    {% endif %}
+
+    console.log('Build completed successfully!');
+  } catch (err) {
+    console.error('Build failed:', err);
+    process.exit(1);
+  }
+}
+
+main();

package/template/fnode/bun/fnode.yaml.njk

@@ -0,0 +1 @@
+{{content | safe}}

package/template/fnode/bun/package.json.njk

@@ -0,0 +1,89 @@
+{
+  "name": "{{atom.doc['npm::name'] or atom.doc['name'] or atom['id']}}",
+  "version": "{{atom.doc['npm::version'] or '0.1.0'}}",
+  "files": [
+    "dist/*",
+    "fnet/input.yaml",
+    "fnet/output.yaml"
+  ],
+  {# "sideEffects": false, #}
+  {% if atom.doc['npm::author'] %}
+  "author": "{{atom.doc['npm::author'] | safe}}",
+  {% endif %}
+
+  {% if atom.doc['npm::description'] %}
+  "description": "{{atom.doc['npm::description'] | safe}}",
+  {% endif %}
+
+  {% if atom.doc.features.project.format ==='cjs' %}
+    {% if atom.doc.features.rollup_output.esm.enabled === true%}
+  "main": "dist/default/esm/index.js",
+  "type":"module",
+    {% else %}
+  "main": "dist/default/cjs/index.cjs",
+    {% endif %}
+  {% if atom.doc.features.dts_enabled ===true %}
+  "types": "dist/default/types/index.d.ts",
+  {% endif %}
+  "exports":{
+    ".":{
+      "import":"./dist/default/esm/index.js",
+      "require":"./dist/default/cjs/index.cjs"
+    }
+  },
+  {% else %}
+  "main": "dist/default/esm/index.js",
+  {% if atom.doc.features.dts_enabled ===true %}
+  "types": "dist/default/types/index.d.ts",
+  {% endif %}
+  "type":"module",
+  "exports":{
+    ".":{
+      "import":"./dist/default/esm/index.js",
+      "require":"./dist/default/cjs/index.cjs"
+    }
+  },
+  {% endif %}
+
+  {% if atom.doc.repo.url %}
+    "repository": {
+        "type": "{{atom.doc.repo.type or 'git'}}",
+        "url": "{{atom.doc.repo.url}}"
+    },
+  {% endif %}
+  "license": "{{atom.doc.license or 'MIT'}}",
+  "scripts": {
+    "build": "bun ./build.js",
+    "watch": "bun --watch --watch-mode=poll --watch-ignore-dirs=node_modules,dist --watch-paths=./src ./build.js",
+    "serve": "bunx serve ./"
+    {% if atom.doc.features.cli.enabled %}
+    {% if atom.doc.features.project.format ==='cjs' %}
+    ,"cli": "bun {{atom.doc.features.cli.node_options}} {{atom.doc.features.cli.dir}}/index.cjs"
+    {% else %}
+    ,"cli": "bun {{atom.doc.features.cli.node_options}} {{atom.doc.features.cli.dir}}/"
+    {% endif %}
+    {% endif %}
+    {% if atom.doc.features.app.enabled %}
+    ,"app": "bunx serve {{atom.doc.features.app.dir}}/"
+    {% endif %}
+  },
+  "devDependencies": {
+    {% for dep in packageDevDependencies %}
+    "{{dep.package}}":"{{dep.version}}" {% if not loop.last%},{%endif%}
+    {% endfor%}
+  },
+  "dependencies": {
+    {% for dep in packageDependencies %}
+    "{{dep.package}}":"{{dep.version}}" {% if not loop.last%},{%endif%}
+    {% endfor%}
+    }
+    {% if atom.doc.features.cli.enabled and atom.doc['npm::bin'] %}
+    ,"bin":{
+      {% if atom.doc.features.project.format ==='cjs' %}
+      "{{atom.doc['npm::bin']}}":"{{atom.doc.features.cli.dir}}/index.cjs"
+      {% else %}
+      "{{atom.doc['npm::bin']}}":"{{atom.doc.features.cli.dir}}/index.js"
+      {% endif %}
+    }
+    {% endif %}
+}

package/template/fnode/bun/readme.md.njk

@@ -0,0 +1,21 @@
+{{content | safe}}
+
+{% if howto %}
+{{howto | safe}}
+{% endif %}
+
+{% if input %}
+# Input Schema
+
+```yaml
+{{ input | safe}}
+```
+{% endif %}
+
+{% if output %}
+# Output Schema
+
+```yaml
+{{ output | safe}}
+```
+{% endif %}

package/template/fnode/bun/src/app/index-js-with-react-host.njk

@@ -0,0 +1,50 @@
+{% if not atom.doc.features.react_version or atom.doc.features.react_version > 17 %}
+  import React from 'react';
+  import { createRoot } from 'react-dom/client';
+{% else %}
+  import React from 'react';
+  import ReactDOM from 'react-dom';
+{% endif %}
+
+{% if atom.doc.features.react_app_state_enabled===true %}
+  import { Provider } from "@fnet/react-app-state";
+{% endif%}
+
+{% if atom.doc.features.app.extend===true %}
+import Library from '../../../app';
+{% elif atom.doc.features.multiple===true %}
+const Library = React.Fragment;
+{% else %}
+import Library from '../../../src';
+{% endif%}
+
+export default function App(props) {
+    return (
+        {% if atom.doc.features.react_app_state_enabled===true %}
+        <Provider>
+        {% endif %}
+            <Library {...props} />
+        {% if atom.doc.features.react_app_state_enabled===true %}
+        </Provider>
+        {% endif %}
+    )
+}
+
+{% if not atom.doc.features.react_version or atom.doc.features.react_version > 17 %}
+const createApp = ({ container }) => {
+    return (props) => {
+        const root = createRoot(container);      
+        root.render(<App {...props} />);
+        return ()=> root.unmount();
+    }
+}
+{% else %}
+const createApp = ({ container }) => {
+    return (props) => {
+        ReactDOM.render(<App {...props} />, container);
+        return () => ReactDOM.unmountComponentAtNode(container);
+    }
+}
+{% endif %}
+
+export { createApp };

package/template/fnode/bun/src/app/index-js-without-react-host.njk

@@ -0,0 +1,23 @@
+{% if atom.doc.features.app.export===true %}
+    {% if atom.doc.features.app.extend===true %}
+      import init from '../../../app';
+      const createApp = ({ container }) => {
+        return init({container});
+      };
+      export { createApp };
+    {% else %}
+      import Node from "../default";
+      const createApp = ({ container }) => {
+        return (props) => Node({ ...props, container });
+      };
+      export { createApp };
+    {% endif %}
+{% else %}
+    {% if atom.doc.features.app.extend===true %}        
+        import run from '../../../app';
+        run();
+    {% else %} 
+        import Node from "../default";
+        Node();
+    {% endif %}    
+{% endif %}

package/template/fnode/bun/src/app/index.html.njk

@@ -0,0 +1,67 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>{{atom.doc.title or atom.doc.name}}</title>
+
+    {% if atom.doc.features.css.options.extract===true %}
+    <link rel="stylesheet" href="./index.css" />    
+    {% endif %}
+
+    {% if atom.doc.features.app.format==='iife' %}
+    <script src="./index.js"></script>
+    {% endif %}
+
+  </head>
+  <body style="height:100vh;margin:0;padding:0;background-color: #eeeeee;">
+    <div id="container" style="height:100%;"></div>
+    {% if atom.doc.features.app.export===true %}    
+        {% if atom.doc.features.app.format==='esm' %}
+            <script type="module">
+                import { createApp } from "./index.js";
+                const run = createApp({container: document.getElementById("container")});
+                {% if atom.doc.features.app.props %}
+                  const dispose=run({{ atom.doc.features.app.props | dump | safe }});
+                {% else %}
+                  const dispose=run();
+                {% endif %}
+            </script>
+        {% endif %}
+        
+        {% if atom.doc.features.app.format==='iife' %}
+            <script>
+                const { createApp } = window['{{atom.doc.bundleName}}'];
+                const run = createApp({container: document.getElementById("container")});
+                {% if atom.doc.features.app.props %}
+                  const dispose=run({{ atom.doc.features.app.props | dump | safe }});
+                {% else %}
+                  const dispose=run();
+                {% endif %}
+            </script>
+        {% endif %}
+    {% endif %}
+
+    {% if atom.doc.features.workbox_enabled %}
+    {% if atom.doc.features.rollup_output.app.workbox.enabled %}
+      <!-- Service Worker Registration -->
+      <script>
+        if ('serviceWorker' in navigator) {
+          window.addEventListener('load', () => {
+            navigator
+              .serviceWorker
+              .register('./sw.js', {scope: './'}) // Optionally add scope
+              .then((registration) => {
+                console.log('Service Worker registered with scope:', registration.scope);
+              })
+              .catch((error) => {
+                console.log('Service Worker registration failed:', error);
+              });
+          });
+        }
+      </script>
+    {% endif%}
+    {% endif%}    
+  </body>
+</html>

package/template/fnode/bun/src/app/index.js.njk

@@ -0,0 +1,9 @@
+{% if atom.doc.features.app.enabled===true %}
+
+    {% if atom.doc.features.app.react===true %}
+        {% include "index-js-with-react-host.njk" %}
+    {% else %}
+        {% include "index-js-without-react-host.njk" %}
+    {% endif %}
+
+{% endif %}

package/template/fnode/bun/src/cli/index.js.njk

@@ -0,0 +1,81 @@
+{% if atom.doc.features.cli.enabled===true %}
+
+{% if atom.doc.features.project.format==='esm' %}
+
+import argv from '../default/to.args.js';
+
+{% if atom.doc.features.cli.extend===true %}
+
+import Node from '../../../cli';
+const run=async ()=>await Node(await argv());
+run()
+  .then(() => {    
+    {# process.exit(0);     #}
+  })
+  .catch((error) => {    
+    console.error(error.message);
+    process.exit(1);
+  });
+
+{% else %}
+import Node from '../../../src';
+const run=async ()=>await Node(await argv());
+
+run()
+  .then((result) => {
+    if (typeof result !== 'undefined')
+    {
+      // TODO: REMOVE THIS LINE
+      const stdout_format=process.argv.slice(2).indexOf()!==-1? process.argv.slice(2)[process.argv.slice(2).indexOf('--stdout_format')+1]:null;
+      if(stdout_format==='json') console.log(JSON.stringify(result,null,2));
+      else console.log(result);
+    }
+    {# process.exit(0); #}
+  })
+  .catch((error) => {
+    console.error(error.message);
+    process.exit(1);
+  });
+{% endif %}
+
+{% elif atom.doc.features.project.format==='cjs' %}
+
+const argv = require('../default/to.args.js');
+
+{% if atom.doc.features.cli.extend===true %}
+
+const Node = require('../../../cli');
+const run = async () => await Node(await argv());
+
+run()
+  .then(() => {
+    {# process.exit(0); #}
+  })
+  .catch((error) => {
+    console.error(error.message);
+    process.exit(1);
+  });
+
+{% else %}
+const Node = require('../../../src');
+const run = async () => await Node(await argv());
+
+run()
+  .then((result) => {
+    if (typeof result !== 'undefined') {
+      // TODO: REMOVE THIS LINE
+      const stdout_format=process.argv.slice(2).indexOf()!==-1? process.argv.slice(2)[process.argv.slice(2).indexOf('--stdout_format')+1]:null;
+      if (stdout_format === 'json') console.log(JSON.stringify(result, null, 2));
+      else console.log(result);
+    }
+    {# process.exit(0); #}
+  })
+  .catch((error) => {
+    console.error(error.message);
+    process.exit(1);
+  });
+{% endif %}
+
+{% endif %}
+
+{% endif %}

package/template/fnode/bun/src/default/engine.js.njk

@@ -0,0 +1,17 @@
+{% if atom.doc.features.project.format === 'esm' %}
+  {% if atom.relativePath %}
+    export * from "{{atom.relativePath}}";
+    export { default } from "{{atom.relativePath}}";
+  {% else %}
+    export * from "../libs/{{atom.id or atom.doc.name}}";
+    export { default } from "../libs/{{atom.id or atom.doc.name}}";
+  {% endif %}
+{% elif atom.doc.features.project.format === 'cjs' %}
+  {% if atom.relativePath %}
+    const moduleExports = require("{{atom.relativePath}}");
+    module.exports = { ...moduleExports, default: moduleExports.default || moduleExports };
+  {% else %}
+    const moduleExports = require("../libs/{{atom.id or atom.doc.name}}");
+    module.exports = { ...moduleExports, default: moduleExports.default || moduleExports };
+  {% endif %}
+{% endif %}