@cmmn/tools 1.6.27 → 1.7.1

package/bin.js

@@ -4,11 +4,12 @@ import {bundle} from "./bundle/bundle.js";
 import {serve} from "./serve/serve.js";
 import {compile} from "./compile/compile.js";
 import {gen} from "./gen/gen.js";
+import {spawn} from "./spawn/index.js";
 
 const [action, ...args] = process.argv.slice(2);
 
 const actions = {
-    bundle, compile, gen, serve
+    bundle, compile, gen, serve, spawn
 }
 
 if (action in actions) {

package/bundle/bundle.js

@@ -2,7 +2,7 @@ import {rollup, watch} from "rollup";
 import {getConfigOptions} from "./getConfigs.js";
 import {ConfigCreator} from "./rollup.config.js";
 import fs from "fs";
-import path from "path";
+import path, {relative} from "path";
 
 export async function bundle(...options) {
     const configOptions = getConfigOptions({
@@ -27,7 +27,24 @@ export async function bundle(...options) {
 
             }
         }
-        return;
+    }else {
+        await runWatching(configs)
+    }
+}
+
+async function runWatching(configs){
+    let counter = 0;
+    while(true){
+        console.log('Check input existence');
+        const missed = await checkMissed(configs);
+        if (!missed.length)
+            break;
+        console.log('missed files:');
+        missed.forEach(x => console.log('\t', relative(process.cwd(), x)));
+        counter = Math.min(++counter, 5);
+        console.log(`wait ${counter} sec...`);
+        await new Promise(resolve => setTimeout(resolve, 1000 * counter));
+        console.clear();
     }
     const watcher = watch(configs);
     watcher.on('event', (event) => {
@@ -63,6 +80,11 @@ export async function bundle(...options) {
                     case 'MISSING_EXPORT':
                         console.warn('MISSING_EXPORT: \t', event.error.message);
                         break;
+                    case 'UNRESOLVED_ENTRY':
+                        console.warn('UNRESOLVED_ENTRY:\t',event.error.message);
+                        watcher.close();
+                        runWatching(configs);
+                        break;
                     default:
                         console.warn('Unknown error:', event.error.code);
                         console.error(event.error);
@@ -74,3 +96,20 @@ export async function bundle(...options) {
         }
     });
 }
+
+/**
+ * @param configs {RollupOptions[]}
+ */
+async function checkMissed(configs) {
+    const missed = [];
+    for (let config of configs) {
+        for (let key in config.input) {
+            try {
+                await fs.promises.stat(config.input[key]);
+            }catch (e) {
+                missed.push(config.input[key]);
+            }
+        }
+    }
+    return missed;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cmmn/tools",
-  "version": "1.6.27",
+  "version": "1.7.1",
   "description": "Compilation, bundling, code generator, testing.",
   "main": "dist/rollup.config.js",
   "type": "module",
@@ -36,6 +36,7 @@
     "bundle/*",
     "serve/*",
     "plugins/*",
+    "spawn/*",
     "test/*"
   ],
   "dependencies": {
@@ -83,5 +84,5 @@
   },
   "author": "",
   "license": "ISC",
-  "gitHead": "e4e3cb40b5249ed8022dbec45db78c2c1a91b6c5"
+  "gitHead": "2755b333808bf97f1d9454601c2a2c9a88e4a021"
 }

package/serve/serve.js

@@ -9,13 +9,13 @@ export function serve(...options) {
     const configs = getConfigOptions({
         project: options.includes('-b'),
     });
-    configs.filter(x => x.port).forEach(async x => {
+    configs.filter(x => x.port).forEach(async (x,i) => {
         const absRoot = path.join(x.rootDir, x.outDir ?? 'dist/bundle');
         const root = path.relative(process.cwd(), absRoot);
         const server = await liveServer.start({
             root: root,
             file: 'index.html',
-            port: process.env.PORT || x.port,
+            port: process.env.PORT ? (process.env.PORT + i) : x.port,
             open: false,
             mount: x.mount && Object.entries(x.mount)
                 .map(([from, to]) => [from, path.resolve(x.rootDir, to)])

package/spawn/index.js

@@ -0,0 +1,81 @@
+import cp from "child_process";
+import {platform} from "os";
+
+export function spawn(...options){
+    const commands = [];
+    for (let i = 0; i < options.length; i++) {
+        if (options[i].startsWith('-')){
+            commands[commands.length - 1].push(options[i]);
+        }else{
+            commands.push([options[i]]);
+        }
+    }
+    for (let command of commands) {
+        console.log('run: ', command.join(' '));
+        spawnCommand('npx cmmn '+command.join(' '), command[0]+'\t', {
+            color: 'red',
+            shell: true,
+            stdio: "pipe"
+        });
+    }
+}
+
+
+/**
+ * @param command {string}
+ * @param prefix {string}
+ * @param options {cp.SpawnOptions}
+ */
+export const spawnCommand = (command, prefix, options) => {
+    if (!options?.stdio && (platform() === 'linux')) {
+        options = { ...(options ?? {}), stdio: 'inherit' };
+    }
+    const proc = cp.spawn(command, options);
+    if (options?.stdio !== 'inherit') {
+        if (prefix) {
+            proc.stdin.pipe(process.stdin);
+            pipe(proc.stdout, process.stdout, prefix);
+            pipe(proc.stderr, process.stderr, prefix);
+        } else {
+            proc.stdin.pipe(process.stdin);
+            proc.stdout.pipe(process.stdout);
+            proc.stderr.pipe(process.stderr);
+        }
+    }
+    return proc;
+}
+function pipe(stream, target, prefix){
+    let _offset = 0;
+    const _NEWLINE = '\n'.charCodeAt(0);
+    const _prefix = Buffer.from(prefix, 'utf-8');
+    const _buffer = Buffer.alloc(1024 * 128);
+    const addBytes = (bytes) => {
+        for (const byte of bytes) {
+            _buffer[_offset] = byte;
+            _offset += 1;
+        }
+    }
+    const addBuffer = (buf) => {
+        buf.copy(_buffer, _offset);
+        _offset += buf.length;
+    }
+    const flush = () => {
+        if (_offset > 0) {
+            target.write(_buffer.slice(0, _offset));
+            _offset = 0;
+        }
+    }
+    addBuffer(_prefix);
+    stream.on('readable', () => {
+        const data = stream.read();
+        if (data) {
+            for (const [ , byte ] of data.entries()) {
+                addBytes([byte]);
+                if (byte === _NEWLINE) {
+                    flush();
+                    addBuffer(_prefix);
+                }
+            }
+        }
+    });
+}