@cmmn/tools 1.6.26 → 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/bundle/styles.js

@@ -1,4 +1,3 @@
-import loader from 'postcss-modules/build/css-loader-core/loader.js';
 import postCssImport from 'postcss-import';
 import postCssAssets from 'postcss-assets';
 import cssModules from '@modular-css/rollup';
@@ -6,22 +5,6 @@ import slug from "unique-slug";
 import styles from "rollup-plugin-styles";
 import {images} from "./images.js";
 
-class Loader extends loader.default {
-    failStart = '/' + process.cwd();
-
-    fetch(_newPath, relativeTo, _trace) {
-        if (relativeTo.startsWith(this.failStart))
-            relativeTo = relativeTo.substring(1);
-        // let newPath = _newPath.replace(/^["']|["']$/g, "");
-        // let relativeDir = path.dirname(relativeTo),
-        //     rootRelativePath = path.resolve(relativeDir, newPath),
-        //     fileRelativePath = path.resolve(path.join(this.root, relativeDir), newPath);
-        // relativeTo = path.relative(process.cwd(), relativeTo);
-        // console.log({root: this.root, newPath, relativeTo, relativeDir, rootRelativePath, fileRelativePath});
-        return super.fetch(_newPath, relativeTo, _trace);
-    }
-}
-
 /**
  *
  * @param {ConfigCreator} config

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cmmn/tools",
-  "version": "1.6.26",
+  "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": "c817edf78be83ca444f7eb3ba9516f0faf0f40cc"
+  "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: 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)])
@@ -36,15 +36,23 @@ function getModuleName(path) {
 
 const mappingCache = {};
 
-async function getFileName(moduleName, root){
+// for resolve modules and files inside modules
+async function getFileName(moduleName, root) {
     // console.log(moduleName, root);
     if (moduleName in mappingCache)
         return mappingCache[moduleName];
-    const file = (await moduleResolve(moduleName, root, new Set(['module','import', 'browser', 'node'])));
-    mappingCache[moduleName] = file.href;
-    return file.href;
+    let file;
+    if (moduleName.match('\.[cm]?js')) {
+        const module = moduleName.match(/^(@[^/]+\/)?[^/]+/)[0];
+        const main = (await moduleResolve(module, root, new Set(['module', 'import', 'browser', 'main', 'node'])));
+        const file = main.href.replace(new RegExp('node_modules/' + module + '.*$'), 'node_modules/' + moduleName);
+        console.log(file)
+        return mappingCache[moduleName] = file;
+    } else {
+        const file = (await moduleResolve(moduleName, root, new Set(['module', 'import', 'browser', 'main', 'node'])));
+        return mappingCache[moduleName] = file.href;
+    }
 }
-
 const resolveESModule = (rootDir, configs) => async function (req, res, next) {
     const name = getModuleName(req.url);
     if (!name)
@@ -79,4 +87,4 @@ const resolveESModule = (rootDir, configs) => async function (req, res, next) {
     }
     res.end();
     return;
-}
+}

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);
+                }
+            }
+        }
+    });
+}