@fnet/cli 0.111.0 → 0.111.2

package/template/fnode/bun/src/default/to.args.js.njk

@@ -0,0 +1,120 @@
+{% if atom.doc.features.project.format === 'esm' %}
+  import fnetArgs from '@fnet/args';
+  import validate from "./validate_input";
+{% elif atom.doc.features.project.format === 'cjs' %}
+  const fnetArgs = require('@fnet/args');
+  const validate = require("./validate_input");
+{% 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 = {{options | dump | safe}};
+    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 = {{options | dump | safe}};
+    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/fnode/bun/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/fnode/node/.gitignore.njk

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

package/template/fnode/node/fnode.yaml.njk

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

package/template/fnode/node/package.json.njk

@@ -0,0 +1,90 @@
+{
+  "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": "rollup --config",
+    "watch": "rollup --config --watch --sourcemap --environment DEVELOPMENT",
+    "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/node/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/node/rollup.config.mjs.njk

@@ -0,0 +1,363 @@
+import commonjs from "@rollup/plugin-commonjs";
+import { nodeResolve as resolve } from "@rollup/plugin-node-resolve";
+import external from "rollup-plugin-peer-deps-external";
+
+import fs from 'fs-extra';
+import path from 'path';
+
+const DEVELOPMENT = process.env.DEVELOPMENT ? true : false;
+const extensions = [".ts", ".tsx", ".js", ".jsx", ".json"];
+
+{% if atom.doc.features.copy_enabled===true %}
+const copyFiles = async (src, dest) => {
+  try {
+    await fs.copy(src, dest);
+    console.log(`Copied files from ${src} to ${dest}`);
+  } catch (err) {
+    console.error('Error copying files:', err);
+  }
+};
+
+const watchFiles = async (targets) => {
+  const chokidar = await import('chokidar');
+  targets.forEach(target => {
+    const watcher = chokidar.watch(target.src, { persistent: true });
+
+    watcher.on('add', async filePath => {
+      const destPath = target.dest;
+      const relativePath = path.relative(path.dirname(target.src), filePath);
+      await copyFiles(filePath, path.join(destPath, relativePath));
+    });
+
+    watcher.on('change', async filePath => {
+      const destPath = target.dest;
+      const relativePath = path.relative(path.dirname(target.src), filePath);
+      await copyFiles(filePath, path.join(destPath, relativePath));
+    });
+
+    watcher.on('unlink', async filePath => {
+      const destPath = target.dest;
+      const relativePath = path.relative(path.dirname(target.src), filePath);
+      try {
+        await fs.remove(path.join(destPath, relativePath));
+        console.log(`Removed files from ${path.join(destPath, relativePath)}`);
+      } catch (err) {
+        console.error('Error removing files:', err);
+      }
+    });
+  });
+};
+{% endif %}
+
+const initPlugins = async (options) => {
+  const plugins = [];
+
+  {# DELETE #}
+  if (options.delete) {
+    const {default:del} = await import('@fnet/rollup-plugin-delete');
+    plugins.push(del(options.delete));
+  }
+
+  {# REPLACE #}
+  if (options.replace) {
+    const {default:replace} = await import("@rollup/plugin-replace");
+    plugins.push(replace({
+      "process.env.NODE_ENV": JSON.stringify(DEVELOPMENT ? 'development' : 'production'),
+      preventAssignment: true,
+      ...options.replace
+    }));
+  }
+
+  {# ALIAS #}
+  if (options.alias) {
+    const {default:alias} = await import('@rollup/plugin-alias');
+    plugins.push(alias(options.alias));
+  }
+
+  {# NUNJUCKS #}
+  {% if atom.doc.features.nunjucks_enabled===true %}
+  if (options.nunjucks) {
+    const {default:nunjucks} = await import('@fnet/rollup-plugin-nunjucks');
+    plugins.push(nunjucks(options.nunjucks.options));
+  }
+  {% endif %}
+
+  {# COPY #}
+  {% if atom.doc.features.copy_enabled===true %}
+  if (options.copy) {
+    const {default:copy} = await import('rollup-plugin-copy');
+    plugins.push(copy(options.copy.options));
+
+    if (DEVELOPMENT) watchFiles(options.copy.options.targets);
+  }
+  {% endif %}
+
+  {# STRING #}
+  {% if atom.doc.features.string_enabled===true %}
+  if (options.string) {
+    const { string } = await import('rollup-plugin-string');
+    plugins.push(string(options.string.options));
+  }
+  {% endif %}
+
+  {# IMAGE #}
+  {% if atom.doc.features.image_enabled===true %}
+  if (options.image) {
+    const {default:image} = await import('@rollup/plugin-image');
+    plugins.push(image(options.image.options));
+  }
+  {% endif %}
+
+  {# WASM #}
+  {% if atom.doc.features.wasm_enabled===true %}
+  if (options.wasm) {
+    const { wasm } = await import('@rollup/plugin-wasm');
+    plugins.push(wasm(options.wasm.options));
+  }
+  {% endif %}
+
+  {# POSTCSS #}
+  {% if atom.doc.features.css_enabled===true %}
+  if (options.postcss) {
+    const {default:postcss} = await import('rollup-plugin-postcss');
+    const { plugins: cssPlugins, ...cssOptions } = options.postcss.options;
+    const postcssPlugins = [];
+
+    if (cssPlugins) {
+      for (const plugin of cssPlugins) {
+        let pluginLib;
+        switch (plugin.name) {
+          case "postcss-import":
+            pluginLib = (await import("postcss-import")).default;
+            break;
+          case "postcss-url":
+            pluginLib = (await import("postcss-url")).default;
+            break;
+          case "postcss-preset-env":
+            pluginLib = (await import("postcss-preset-env")).default;
+            break;
+          case "autoprefixer":
+            pluginLib = (await import("autoprefixer")).default;
+            break;
+          case "cssnano":
+            pluginLib = (await import("cssnano")).default;
+            break;
+          default:
+            continue;
+        }
+        postcssPlugins.push(pluginLib(plugin.options));
+      }
+    }
+
+    plugins.push(postcss({
+      ...cssOptions,
+      plugins: postcssPlugins
+    }));
+  }
+  {% endif %}
+
+  {# JSON #}
+  {% if atom.doc.features.json_enabled===true %}
+  if (options.json) {
+    const {default:json} = await import('@rollup/plugin-json');
+    plugins.push(json(options.json.options));
+  }
+  {% endif %}
+
+  {# EXTERNAL #}
+  plugins.push(external({
+    includeDependencies: !options.browser
+  }));
+
+  {# RESOLVE #}
+  plugins.push(resolve({
+    extensions: extensions,
+    browser: options?.browser === true,
+    preferBuiltins: true,
+    modulePaths: ['./node_modules']
+  }));
+
+  {# COMMONJS #}
+  plugins.push(commonjs({
+    {% if atom.doc.features.project.format ==='esm' %}
+    include: /node_modules/,
+    ignore: ["fsevents"],
+    {% endif %}    
+  }));
+  
+
+  {# POLYFILL #}
+  {% if atom.doc.features.polyfill_enabled===true %}
+  if(options.polyfill){
+    const {default:polyfills} = await import('rollup-plugin-node-polyfills');
+    plugins.push(polyfills(options.polyfill.options));
+  }
+  {% endif %}
+  
+  {# WORKBOX #}
+  {% if atom.doc.features.workbox_enabled===true %}
+  if (options?.workbox) {
+    const {generateSW,injectManifest} = await import('rollup-plugin-workbox');
+    if(options.workbox.options?.generate) plugins.push(generateSW(options.workbox.options.generate));
+    if(options.workbox.options?.inject) plugins.push(injectManifest(options.workbox.options.inject));
+  }
+  {% endif %}
+
+  {# BABEL #}
+  {% if atom.doc.features.babel_enabled===true %}
+  if (options?.babel) {
+    const { babel } = await import('@rollup/plugin-babel');
+    plugins.push(
+      babel({
+        babelHelpers: "bundled",
+        presets: [
+          ["@babel/preset-env", {
+            targets: options.babel.targets || "defaults",
+          }],
+          ["@babel/preset-react"]
+        ],
+        extensions: extensions,
+        exclude: "node_modules/**",
+        plugins: options.babel.plugins || [],
+        sourceMaps: DEVELOPMENT
+      })
+    );
+  }
+  {% endif %}
+
+  {# TERSER #}
+  {% if atom.doc.features.terser_enabled===true %}
+  if (options.terser) {
+    const {default:terser} = await import("@rollup/plugin-terser");
+    plugins.push(terser(options.terser.options));
+  }
+  {% endif %}
+
+  {# GZIP #}
+  {% if atom.doc.features.gzip_enabled===true %}
+  if (options.gzip) {
+    const {default:gzip} = await import('rollup-plugin-gzip');
+    if(options.gzip.options) plugins.push(gzip(options.gzip.options));
+  }
+  {% endif %}
+
+  {# ANALYZER #}
+  {% if atom.doc.features.analyzer_enabled===true %}
+  if (options.analyzer) {
+    const { default: analyzer } = await import("rollup-plugin-analyzer");
+    plugins.push(analyzer(options.analyzer.options));
+  }
+  {% endif %}
+
+  {# VISUALIZER #}
+  {% if atom.doc.features.visualizer_enabled===true %}
+  if (options.visualizer) {
+    const { visualizer } = await import("rollup-plugin-visualizer");
+    plugins.push(visualizer(options.visualizer.options));
+  }
+  {% endif %}
+
+  {# BROWSERSYNC #}
+  {% if atom.doc.features.browsersync_enabled===true %}
+  if (options.browsersync && DEVELOPMENT) {
+    const {default:browsersync} = await import('@fnet/rollup-plugin-browsersync');
+    options.browsersync.middleware = function (req, res, next) {
+      if (req.method === 'OPTIONS') {
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'X-Requested-With,content-type');
+        res.setHeader('Access-Control-Allow-Credentials', true);
+        res.end();
+      } else {
+        next();
+      }
+    };
+    plugins.push(browsersync(options.browsersync));
+  }
+  {% endif %}
+
+  return plugins;
+}
+
+const groups = [
+  { name: "default" }
+];
+
+const configs = [];
+
+const createConfigs = async () => {
+  for (const group of groups) {
+    let groupDir = path.normalize(`./dist/${group.name}/`);
+    if (!fs.existsSync(groupDir)) {
+      fs.mkdirSync(groupDir, { recursive: true });
+    }
+    
+    {% for key, value in atom.doc.features.rollup_output %}
+    {% if value and value.enabled !== false %}
+    {
+      // {{key | upper}}
+      const config = {
+        input: path.normalize(`{{value.input or 'src/${group.name}/index.js'}}`),
+        output: {
+          dir: path.normalize(`{{value.output_dir or 'dist/${group.name}/' + key}}`),
+          format: "{{value.format}}",
+          {% if atom.doc.features.sourcemap === true %}
+          sourcemap: true,
+          {% endif %}
+          {% if value.format === 'cjs' %}
+          exports: "{{value.output_exports or 'named'}}",
+          interop: "auto",
+          entryFileNames: "[name].cjs",
+          chunkFileNames: "[name]-[hash].cjs",
+          {% endif %}
+          {% include 'rollup_config_output_name.njk' %}
+          {% include 'rollup_config_output_globals.njk' %}
+          {% include 'rollup_config_output_banner.njk' %}
+          {% include 'rollup_config_output_footer.njk' %}
+        },
+        {% if value.context %}
+        context: "{{value.context}}",
+        {% endif %}
+        {% include 'rollup_config_external.njk' %}
+        {% include 'rollup_config_onwarn.njk' %}
+        {% include 'rollup_config_plugins.njk' %}
+      }
+      configs.push(config);
+    }
+    {% endif %}
+    {% endfor %}
+  }
+
+  {# DTS #}
+  {% if atom.doc.features.dts_enabled ===true %}
+    const { dts } = await import("rollup-plugin-dts");
+    const typesConfig = {
+      input: path.normalize('{{atom.typesDir}}/default/index.d.ts'),
+      output: {
+        file: path.normalize("./dist/default/types/index.d.ts"),
+        format: "es"
+      },
+      plugins: [dts()],
+    }
+    configs.push(typesConfig);
+  {% endif %}
+}
+
+{% if atom.doc.features.render and atom.doc.features.render.enabled !== false  %}
+async function render(){
+  const { default:fnetRender } = await import('@flownet/lib-render-templates-dir');
+
+  const dirs={{atom.doc.features.render.dirs | default([]) | dump | safe}};
+
+  for (const dir of dirs) {
+    await fnetRender(dir);
+  }
+}
+{% endif %}
+export default async () => {
+  {% if atom.doc.features.render and atom.doc.features.render.enabled !== false  %}
+  await render();
+  {% endif %}
+  await createConfigs();
+  return configs;
+};

package/template/fnode/node/rollup_config_external.njk

@@ -0,0 +1,8 @@
+
+{% if value.external_enabled %}
+external: [
+    {% for external in value.external %}
+        "{{external}}" {% if not loop.last %},{% endif %}
+    {% endfor %}
+],
+{% endif %}

package/template/fnode/node/rollup_config_onwarn.njk

@@ -0,0 +1,9 @@
+onwarn(warning, warn) {
+    switch (warning.code) {
+    case 'MODULE_LEVEL_DIRECTIVE':
+    case 'CIRCULAR_DEPENDENCY':
+        return;
+    default:
+        warn(warning);
+    }
+},

package/template/fnode/node/rollup_config_output_banner.njk

@@ -0,0 +1,3 @@
+{% if value.banner %}
+banner:'{{value.banner}}',
+{% endif %}

package/template/fnode/node/rollup_config_output_footer.njk

@@ -0,0 +1,5 @@
+{% if value.format==='iife' %}
+    {% if atom.type==='workflow'%}
+    {# footer: "new {{atom.doc.bundleName}}().run().catch(e=>{});" #}
+    {% endif %}
+{% endif %}

package/template/fnode/node/rollup_config_output_globals.njk

@@ -0,0 +1,9 @@
+{% if value.browser===true %}
+{% if value.globals.length %}
+globals: {
+    {% for global in value.globals %}
+        "{{global.key}}":"{{global.value}}" {% if not loop.last %},{% endif %}
+    {% endfor %}
+},
+{% endif %}
+{% endif %}

package/template/fnode/node/rollup_config_output_name.njk

@@ -0,0 +1,3 @@
+{% if value.format==='iife' or value.format==='umd'%}
+name: "{{atom.doc.bundleName}}",
+{% endif %}