datagrok-tools 5.1.7 → 5.1.8

package/bin/commands/api.js

@@ -15,6 +15,9 @@ const annotationForApiFile = `/**\nThis file is auto-generated by the grok api c
 const sep = '\n';
 const packageFuncDirs = ['package.ts', 'package.g.ts'];
 const apiFile = 'package-api.ts';
+function normEol(s) {
+  return s.replace(/\r\n/g, '\n');
+}
 const curDir = process.cwd();
 const srcDir = _path.default.join(curDir, 'src');
 const funcFilePath = _path.default.join(_fs.default.existsSync(srcDir) ? srcDir : curDir, apiFile);
@@ -107,11 +110,11 @@ function saveWrappersToFile(namespaceName, wrappers) {
   if (wrappers.length === 0) return;
   if (!_fs.default.existsSync(funcFilePath)) createApiFile();
   const scriptApi = new utils.TemplateBuilder(utils.namespaceTemplate).replace('PACKAGE_NAMESPACE', namespaceName).replace('NAME', wrappers.join(sep.repeat(2)));
-  _fs.default.appendFileSync(funcFilePath, sep + scriptApi.build() + sep);
+  _fs.default.appendFileSync(funcFilePath, normEol(sep + scriptApi.build() + sep));
   color.log(`Successfully generated file ${apiFile}${sep}`, 'success');
 }
 function createApiFile() {
-  _fs.default.writeFileSync(funcFilePath, annotationForApiFile + utils.dgImports + sep, 'utf8');
+  _fs.default.writeFileSync(funcFilePath, normEol(annotationForApiFile + utils.dgImports + sep), 'utf8');
 }
 function checkNameColision(name) {
   if (names.has(name)) console.log('There is collision in name ' + name);

package/bin/commands/build.js

@@ -0,0 +1,209 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.applyFilter = applyFilter;
+exports.build = build;
+exports.confirm = confirm;
+exports.discoverPackages = discoverPackages;
+exports.getNestedValue = getNestedValue;
+var _fs = _interopRequireDefault(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+var _util = require("util");
+var _child_process = require("child_process");
+var readline = _interopRequireWildcard(require("readline"));
+var utils = _interopRequireWildcard(require("../utils/utils"));
+var color = _interopRequireWildcard(require("../utils/color-utils"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+const execAsync = (0, _util.promisify)(_child_process.exec);
+async function build(args) {
+  if (args.verbose) color.setVerbose(true);
+  const buildCmd = args['no-incremental'] ? 'npm run build' : 'npm run build -- --env incremental';
+  if (args.recursive) return await buildRecursive(process.cwd(), args, buildCmd);else return await buildSingle(process.cwd(), buildCmd);
+}
+async function buildSingle(dir, buildCmd) {
+  if (!utils.isPackageDir(dir)) {
+    color.error('Not a package directory (no package.json found)');
+    return false;
+  }
+  const packageJson = JSON.parse(_fs.default.readFileSync(_path.default.join(dir, 'package.json'), 'utf-8'));
+  const name = packageJson.friendlyName || packageJson.name;
+  console.log(`Building ${name}...`);
+  try {
+    await utils.runScript('npm install', dir, color.isVerbose());
+    await utils.runScript(buildCmd, dir, color.isVerbose());
+    color.success(`Successfully built ${name}`);
+    return true;
+  } catch (error) {
+    color.error(`Failed to build ${name}`);
+    if (error.message) color.error(error.message);
+    return false;
+  }
+}
+async function buildRecursive(baseDir, args, buildCmd) {
+  const packages = discoverPackages(baseDir);
+  if (packages.length === 0) {
+    color.warn('No packages found in the current directory');
+    return false;
+  }
+  const filtered = args.filter ? applyFilter(packages, args.filter) : packages;
+  if (filtered.length === 0) {
+    color.warn('No packages match the filter');
+    return false;
+  }
+  console.log(`Found ${filtered.length} package(s): ${filtered.map(p => p.friendlyName).join(', ')}`);
+  if (!args.silent) {
+    const confirmed = await confirm(`\nBuild ${filtered.length} package(s)?`);
+    if (!confirmed) {
+      console.log('Aborted.');
+      return false;
+    }
+  }
+  const maxParallel = args.parallel || 4;
+  const results = await buildParallel(filtered, buildCmd, maxParallel);
+  return results.every(r => r.success);
+}
+function discoverPackages(baseDir) {
+  const entries = _fs.default.readdirSync(baseDir);
+  const packages = [];
+  for (const entry of entries) {
+    if (entry.startsWith('.') || entry === 'node_modules') continue;
+    const dir = _path.default.join(baseDir, entry);
+    try {
+      if (!_fs.default.statSync(dir).isDirectory()) continue;
+    } catch (_) {
+      continue;
+    }
+    const packageJsonPath = _path.default.join(dir, 'package.json');
+    if (!_fs.default.existsSync(packageJsonPath)) continue;
+    try {
+      const packageJson = JSON.parse(_fs.default.readFileSync(packageJsonPath, 'utf-8'));
+      packages.push({
+        dir,
+        name: packageJson.name || entry,
+        friendlyName: packageJson.friendlyName || packageJson.name || entry,
+        version: packageJson.version || '0.0.0',
+        packageJson
+      });
+    } catch (_) {
+      continue;
+    }
+  }
+  return packages.sort((a, b) => a.friendlyName.localeCompare(b.friendlyName));
+}
+function applyFilter(packages, filterStr) {
+  const conditions = filterStr.split('&&').map(s => s.trim());
+  const parsedConditions = conditions.map(cond => {
+    const colonIdx = cond.indexOf(':');
+    if (colonIdx === -1) return {
+      field: cond,
+      pattern: new RegExp('.')
+    };
+    const field = cond.substring(0, colonIdx).trim();
+    const pattern = new RegExp(cond.substring(colonIdx + 1).trim());
+    return {
+      field,
+      pattern
+    };
+  });
+  return packages.filter(pkg => {
+    for (const cond of parsedConditions) {
+      const value = getNestedValue(pkg.packageJson, cond.field);
+      if (value === undefined || !cond.pattern.test(String(value))) return false;
+    }
+    return true;
+  });
+}
+function getNestedValue(obj, path) {
+  const parts = path.split('.');
+  let current = obj;
+  for (const part of parts) {
+    if (current == null || typeof current !== 'object') return undefined;
+    current = current[part];
+  }
+  return current;
+}
+async function buildParallel(packages, buildCmd, maxParallel) {
+  const results = [];
+  const headers = ['Plugin', 'Version', 'Build time', 'Bundle size'];
+  const widths = [Math.max(headers[0].length, ...packages.map(p => p.friendlyName.length)), Math.max(headers[1].length, ...packages.map(p => p.version.length)), Math.max(headers[2].length, 10), Math.max(headers[3].length, 40)];
+  const pad = (s, w) => s + ' '.repeat(Math.max(0, w - s.length));
+  console.log(`\nBuilding with ${maxParallel} parallel job(s)...`);
+  console.log(headers.map((h, i) => pad(h, widths[i])).join(' | '));
+  console.log(widths.map(w => '-'.repeat(w)).join('-+-'));
+  const buildOne = async pkg => {
+    const start = Date.now();
+    let success = true;
+    let buildTime = '';
+    let bundleSize = '';
+    try {
+      await execAsync('npm install', {
+        cwd: pkg.dir,
+        maxBuffer: 10 * 1024 * 1024
+      });
+      await execAsync(buildCmd, {
+        cwd: pkg.dir,
+        maxBuffer: 10 * 1024 * 1024
+      });
+      const elapsed = (Date.now() - start) / 1000;
+      buildTime = `${elapsed.toFixed(1)}s`;
+      bundleSize = getBundleSize(pkg.dir);
+    } catch (error) {
+      success = false;
+      buildTime = 'Error';
+      const raw = (error.stderr || error.stdout || error.message || 'Unknown error').trim();
+      bundleSize = raw.replace(/\r?\n/g, ' ').replace(/\s+/g, ' ').substring(0, 40);
+    }
+    const result = {
+      name: pkg.friendlyName,
+      version: pkg.version,
+      buildTime,
+      bundleSize,
+      success
+    };
+    results.push(result);
+    const cells = [result.name, result.version, result.buildTime, result.bundleSize];
+    const line = cells.map((cell, j) => pad(cell, widths[j])).join(' | ');
+    if (success) color.info(line);else color.error(line);
+    return result;
+  };
+  let idx = 0;
+  const next = async () => {
+    while (idx < packages.length) {
+      const pkg = packages[idx++];
+      await buildOne(pkg);
+    }
+  };
+  const workers = Array.from({
+    length: Math.min(maxParallel, packages.length)
+  }, () => next());
+  await Promise.all(workers);
+  const succeeded = results.filter(r => r.success).length;
+  const failed = results.length - succeeded;
+  console.log('');
+  if (failed === 0) color.success(`All ${results.length} package(s) built successfully`);else color.warn(`${succeeded} succeeded, ${failed} failed`);
+  return results;
+}
+function getBundleSize(dir) {
+  const bundlePath = _path.default.join(dir, 'dist', 'package.js');
+  try {
+    const stats = _fs.default.statSync(bundlePath);
+    return `${(stats.size / 1024).toFixed(1)} KB`;
+  } catch (_) {
+    return 'N/A';
+  }
+}
+function confirm(message) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise(resolve => {
+    rl.question(`${message} [Y/n] `, answer => {
+      rl.close();
+      resolve(answer.trim().toLowerCase() !== 'n');
+    });
+  });
+}

package/bin/commands/check.js

@@ -8,6 +8,7 @@ exports.check = check;
 exports.checkChangelog = checkChangelog;
 exports.checkDatagrokApiImports = checkDatagrokApiImports;
 exports.checkFuncSignatures = checkFuncSignatures;
+exports.checkHeavyImports = checkHeavyImports;
 exports.checkImportStatements = checkImportStatements;
 exports.checkNpmIgnore = checkNpmIgnore;
 exports.checkPackageFile = checkPackageFile;
@@ -23,6 +24,30 @@ var _const = require("../utils/const");
 function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
 const warns = ['Latest package version', 'Datagrok API version should contain'];
 const forbiddenNames = ['function', 'class', 'export'];
+/** Static imports of these libraries significantly increase the main bundle size. */
+const HEAVY_IMPORT_RULES = [
+// Test utilities — should never reach production bundles
+{
+  pattern: '@datagrok-libraries/test',
+  reason: 'test-only library imported in production code',
+  suggestion: 'replace delay() with DG.delay(), testEvent() with alternatives from utils'
+},
+// Heavy UI/editor libraries — only flagged when not the package\'s core purpose
+{
+  pattern: 'codemirror',
+  reason: 'heavy text editor (~870 KB) statically bundled',
+  suggestion: 'use dynamic import() inside the function that opens the editor'
+}, {
+  pattern: 'konva',
+  reason: 'heavy canvas library (~410 KB) statically bundled',
+  suggestion: 'use dynamic import() to load on demand'
+},
+// Heavy data-processing libraries
+{
+  pattern: 'exceljs',
+  reason: 'heavy Excel library (~940 KB) statically bundled',
+  suggestion: 'offload to a web worker (see PowerPack/src/workers/exceljs-worker.ts)'
+}];
 const namesInFiles = new Map();
 function check(args) {
   if (args.verbose !== undefined || args.v !== undefined) color.setVerbose(args.verbose || args.v || false);
@@ -41,9 +66,9 @@ function runChecks(packagePath, soft = false, noExit = false) {
     path: packagePath,
     ignoreFiles: ['.npmignore', '.gitignore']
   }).filter(e => !e.includes('node_modules'));
-  const jsTsFiles = files.filter(f => (f.startsWith('src' + _path.default.sep) || f.startsWith('queries' + _path.default.sep) || f.startsWith('scripts' + _path.default.sep)) && (f.endsWith('.js') || f.endsWith('.ts') || f.endsWith('.sql') || f.endsWith('.py')));
+  const jsTsFiles = files.filter(f => (f.startsWith('src/') || f.startsWith('queries/') || f.startsWith('scripts/')) && (f.endsWith('.js') || f.endsWith('.ts') || f.endsWith('.sql') || f.endsWith('.py')));
   const packageFiles = ['src/package.ts', 'src/detectors.ts', 'src/package.js', 'src/detectors.js', 'src/package-test.ts', 'src/package-test.js', 'package.js', 'detectors.js'];
-  // const funcFiles = jsTsFiles.filter((f) => packageFiles.includes(f)); 
+  // const funcFiles = jsTsFiles.filter((f) => packageFiles.includes(f));
   const errors = [];
   const warnings = [];
   const packageFilePath = _path.default.join(packagePath, 'package.json');
@@ -67,6 +92,7 @@ function runChecks(packagePath, soft = false, noExit = false) {
     if (externals) errors.push(...checkImportStatements(packagePath, jsTsFiles, externals));
   }
   errors.push(...checkDatagrokApiImports(packagePath, jsTsFiles));
+  warnings.push(...checkHeavyImports(packagePath, jsTsFiles, _path.default.basename(packagePath)));
   if (!soft) errors.push(...checkSourceMap(packagePath));
   errors.push(...checkNpmIgnore(packagePath));
   warnings.push(...checkScriptNames(packagePath));
@@ -188,6 +214,31 @@ function checkDatagrokApiImports(packagePath, files) {
   }
   return errors;
 }
+function checkHeavyImports(packagePath, files, packageName = '') {
+  const warnings = [];
+  const isTestPackage = /tests?$/i.test(packageName);
+  const staticImportRegex = /^\s*import\s+(?!type\s).*['"]([^'"]+)['"]/;
+  for (const file of files) {
+    const isTestFile = file.includes('/tests/') || file.includes('/test/') || _path.default.basename(file).includes('-test.') || _path.default.basename(file).includes('-testing.') || _path.default.basename(file) === 'package-test.ts' || _path.default.basename(file) === 'package-test.js';
+    const isWorkerFile = file.includes('/workers/');
+    const isVendoredLib = file.includes('/libs/');
+    if (isWorkerFile || isVendoredLib) continue;
+    const content = _fs.default.readFileSync(_path.default.join(packagePath, file), {
+      encoding: 'utf-8'
+    });
+    for (const line of content.split('\n')) {
+      const m = line.match(staticImportRegex);
+      if (!m) continue;
+      const specifier = m[1];
+      for (const rule of HEAVY_IMPORT_RULES) {
+        if (!specifier.includes(rule.pattern)) continue;
+        if (isTestFile || isTestPackage) continue;
+        warnings.push(`File "${file}": ${rule.reason}.\n` + `  Found: ${line.trim()}\n` + `  Hint: ${rule.suggestion}\n`);
+      }
+    }
+  }
+  return warnings;
+}
 const TYPE_ALIASES = {
   file: ['fileinfo'],
   dynamic: ['searchprovider']

package/bin/commands/help.js

@@ -12,6 +12,7 @@ Datagrok's package management tool
 Commands:
     add       Add an object template
     api       Create wrapper functions
+    build     Build a package or multiple packages
     check     Check package content (function signatures, etc.)
     config    Create and manage config files
     create    Create a package
@@ -144,15 +145,15 @@ const HELP_TEST = `
 Usage: grok test
 
 Options:
-[--package] [--category] [--test] [--host] [--csv] [--gui] [--skip-build] [--skip-publish] [--link] [--catchUnhandled] [--report] [--record] [--verbose] [--platform] [--benchmark] [--stress-test] [--debug] [--all]
+[--package] [--category] [--test] [--host] [--csv] [--gui] [--skip-build] [--skip-publish] [--link] [--catchUnhandled] [--report] [--record] [--verbose] [--platform] [--benchmark] [--stress-test] [--debug] [--all] [-r | --recursive] [--filter] [--parallel N]
 
 --package           Specify a package name to run tests for
 --category          Specify a category name to run tests for
---test              Specify a test name to run 
+--test              Specify a test name to run
 --host              Host alias as in the config file
 --csv               Save the test report in a CSV file
 --gui               Launch graphical interface (non-headless mode)
---debug             Enables debug point on tests run (useless without gui mode) 
+--debug             Enables debug point on tests run (useless without gui mode)
 --verbose           Show debug information
 --retry --no-retry  Enables or disables browser reload after a failed test
 --report            Report failed tests to audit, notifies package author (default=false)
@@ -165,9 +166,18 @@ Options:
 --benchmark   	    Runs tests in benchmark mode
 --stress-test       Runs shuffled stress-test only
 --all               Runs tests for all available packages(run in packages directory)
- 
+--recursive         Test all packages in the current directory (parallel, table output)
+--filter            Filter packages by package.json fields (e.g. --filter "category:Cheminformatics")
+--parallel N        Max parallel test jobs (default: 4)
+
 Run package tests
 
+Examples:
+  grok test -r                                       Test all packages
+  grok test -r --filter "category:Cheminformatics"   Test matching packages
+  grok test -r --parallel 2 --host dev               Test with 2 jobs against dev
+  grok test -r --skip-build --skip-publish            Test without rebuilding
+
 See instructions:
 https://datagrok.ai/help/develop/how-to/test-packages#local-testing
 `;
@@ -227,6 +237,28 @@ Example:
   ⟶
   meta: { role: 'viewer,ml' }
 `;
+const HELP_BUILD = `
+Usage: grok build
+
+Build a package in the current directory, or recursively build multiple packages.
+
+Options:
+[-r | --recursive] [-s | --silent] [--filter] [--no-incremental] [--parallel N] [-v | --verbose]
+
+--recursive       Build all packages in the current directory
+--silent          Skip confirmation prompt (for recursive builds)
+--filter          Filter packages by package.json fields (e.g. --filter "category:Cheminformatics")
+--no-incremental  Run a full build instead of the default incremental build
+--parallel N      Max parallel builds (default: 4)
+--verbose         Print detailed output
+
+Examples:
+  grok build                                          Build the current package
+  grok build -r                                       Build all packages in the current directory
+  grok build -r -s                                    Build all packages without confirmation
+  grok build -r --filter "category:Cheminformatics"   Build only matching packages
+  grok build -r --parallel 8                          Build with 8 parallel jobs
+`;
 
 // const HELP_MIGRATE = `
 // Usage: grok migrate
@@ -238,6 +270,7 @@ Example:
 const help = exports.help = {
   add: HELP_ADD,
   api: HELP_API,
+  build: HELP_BUILD,
   check: HELP_CHECK,
   config: HELP_CONFIG,
   create: HELP_CREATE,

package/bin/commands/test.js

@@ -6,18 +6,22 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.test = test;
 var _child_process = require("child_process");
+var _util = require("util");
 var _fs = _interopRequireDefault(require("fs"));
 var _os = _interopRequireDefault(require("os"));
 var _path = _interopRequireDefault(require("path"));
 var _jsYaml = _interopRequireDefault(require("js-yaml"));
 var utils = _interopRequireWildcard(require("../utils/utils"));
 var color = _interopRequireWildcard(require("../utils/color-utils"));
+var _build = require("./build");
 var Papa = _interopRequireWildcard(require("papaparse"));
 var _testUtils = _interopRequireWildcard(require("../utils/test-utils"));
 var testUtils = _testUtils;
 function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
 /* eslint-disable max-len */
 
+const execAsync = (0, _util.promisify)(_child_process.exec);
+const execFileAsync = (0, _util.promisify)(_child_process.execFile);
 const testInvocationTimeout = 3600000;
 const availableCommandOptions = ['host', 'package', 'csv', 'gui', 'catchUnhandled', 'platform', 'core', 'report', 'skip-build', 'skip-publish', 'path', 'record', 'verbose', 'benchmark', 'category', 'test', 'stress-test', 'link', 'tag', 'ci-cd', 'debug', 'no-retry'];
 const curDir = process.cwd();
@@ -53,6 +57,7 @@ function findGitRoot(startDir) {
   }
 }
 async function test(args) {
+  if (args.recursive) return await testRecursive(process.cwd(), args);
   const config = _jsYaml.default.load(_fs.default.readFileSync(confPath, {
     encoding: 'utf-8'
   }));
@@ -312,4 +317,129 @@ function readCSVResultData(data) {
     headers: parsed.meta.fields || [],
     rows: parsed.data
   };
+}
+async function testRecursive(baseDir, args) {
+  const packages = (0, _build.discoverPackages)(baseDir);
+  if (packages.length === 0) {
+    color.warn('No packages found in the current directory');
+    return false;
+  }
+  const filtered = args.filter ? (0, _build.applyFilter)(packages, args.filter) : packages;
+  if (filtered.length === 0) {
+    color.warn('No packages match the filter');
+    return false;
+  }
+  console.log(`Found ${filtered.length} package(s): ${filtered.map(p => p.friendlyName).join(', ')}`);
+  const confirmed = await (0, _build.confirm)(`\nTest ${filtered.length} package(s)?`);
+  if (!confirmed) {
+    console.log('Aborted.');
+    return false;
+  }
+  const maxParallel = args.parallel || 4;
+  const results = await testParallel(filtered, args, maxParallel);
+  return results.every(r => r.success);
+}
+function buildTestArgs(args) {
+  const grokScript = _path.default.resolve(__dirname, '..', 'grok.js');
+  const parts = [grokScript, 'test'];
+  if (args.host) parts.push(`--host=${args.host}`);
+  if (args['skip-build']) parts.push('--skip-build');
+  if (args['skip-publish']) parts.push('--skip-publish');
+  if (args.link) parts.push('--link');
+  if (args.verbose) parts.push('--verbose');
+  if (args.csv) parts.push('--csv');
+  if (args.catchUnhandled) parts.push('--catchUnhandled');
+  if (args.report) parts.push('--report');
+  if (args.benchmark) parts.push('--benchmark');
+  if (args['stress-test']) parts.push('--stress-test');
+  if (args['ci-cd']) parts.push('--ci-cd');
+  if (args['no-retry']) parts.push('--no-retry');
+  return parts;
+}
+function parseTestOutput(stdout) {
+  const passedMatch = stdout.match(/Passed amount:\s*(\d+)/);
+  const failedMatch = stdout.match(/Failed amount:\s*(\d+)/);
+  const skippedMatch = stdout.match(/Skipped amount:\s*(\d+)/);
+  if (!passedMatch && !failedMatch) return null;
+  return {
+    passed: passedMatch ? parseInt(passedMatch[1]) : 0,
+    failed: failedMatch ? parseInt(failedMatch[1]) : 0,
+    skipped: skippedMatch ? parseInt(skippedMatch[1]) : 0
+  };
+}
+async function testParallel(packages, args, maxParallel) {
+  const results = [];
+  const cmdArgs = buildTestArgs(args);
+  const headers = ['Plugin', 'Version', 'Tests', 'Time'];
+  const widths = [Math.max(headers[0].length, ...packages.map(p => p.friendlyName.length)), Math.max(headers[1].length, ...packages.map(p => p.version.length)), Math.max(headers[2].length, 18), Math.max(headers[3].length, 8)];
+  const pad = (s, w) => s + ' '.repeat(Math.max(0, w - s.length));
+  console.log(`\nTesting with ${maxParallel} parallel job(s)...`);
+  console.log(headers.map((h, i) => pad(h, widths[i])).join(' | '));
+  console.log(widths.map(w => '-'.repeat(w)).join('-+-'));
+  const testOne = async pkg => {
+    const start = Date.now();
+    let success = true;
+    let tests = '';
+    let time = '';
+    try {
+      const {
+        stdout
+      } = await execFileAsync(process.execPath, cmdArgs, {
+        cwd: pkg.dir,
+        maxBuffer: 50 * 1024 * 1024,
+        timeout: testInvocationTimeout
+      });
+      const elapsed = (Date.now() - start) / 1000;
+      time = `${elapsed.toFixed(1)}s`;
+      const counts = parseTestOutput(stdout);
+      if (counts) {
+        const total = counts.passed + counts.failed + counts.skipped;
+        tests = `${counts.passed} of ${total} passed`;
+        success = counts.failed === 0;
+      } else {
+        tests = 'Done (no counts)';
+      }
+    } catch (error) {
+      success = false;
+      const elapsed = (Date.now() - start) / 1000;
+      time = `${elapsed.toFixed(1)}s`;
+      const stdout = error.stdout || '';
+      const counts = parseTestOutput(stdout);
+      if (counts) {
+        const total = counts.passed + counts.failed + counts.skipped;
+        tests = `${counts.passed} of ${total} passed`;
+      } else {
+        const raw = (error.stderr || error.stdout || error.message || 'Unknown error').trim();
+        tests = raw.replace(/\r?\n/g, ' ').replace(/\s+/g, ' ').substring(0, 30);
+      }
+    }
+    const result = {
+      name: pkg.friendlyName,
+      version: pkg.version,
+      tests,
+      time,
+      success
+    };
+    results.push(result);
+    const cells = [result.name, result.version, result.tests, result.time];
+    const line = cells.map((cell, j) => pad(cell, widths[j])).join(' | ');
+    if (success) color.info(line);else color.error(line);
+    return result;
+  };
+  let idx = 0;
+  const next = async () => {
+    while (idx < packages.length) {
+      const pkg = packages[idx++];
+      await testOne(pkg);
+    }
+  };
+  const workers = Array.from({
+    length: Math.min(maxParallel, packages.length)
+  }, () => next());
+  await Promise.all(workers);
+  const succeeded = results.filter(r => r.success).length;
+  const failed = results.length - succeeded;
+  console.log('');
+  if (failed === 0) color.success(`All ${results.length} package(s) passed`);else color.warn(`${succeeded} passed, ${failed} failed`);
+  return results;
 }

package/bin/grok.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 const argv = require('minimist')(process.argv.slice(2), {
-  alias: {k: 'key', h: 'help', r: 'recursive'},
+  alias: {k: 'key', h: 'help', r: 'recursive', s: 'silent'},
 });
 const help = require('./commands/help').help;
 const runAllCommand = require('./utils/utils').runAll;
@@ -8,6 +8,7 @@ const runAllCommand = require('./utils/utils').runAll;
 const commands = {
   add: require('./commands/add').add,
   api: require('./commands/api').api,
+  build: require('./commands/build').build,
   check: require('./commands/check').check,
   config: require('./commands/config').config,
   create: require('./commands/create').create,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "datagrok-tools",
-  "version": "5.1.7",
+  "version": "5.1.8",
   "description": "Utility to upload and publish packages to Datagrok",
   "homepage": "https://github.com/datagrok-ai/public/tree/master/tools#readme",
   "dependencies": {

package/plugins/func-gen-plugin.js

@@ -20,6 +20,10 @@ const {toCamelCase} = require('../bin/commands/migrate');
 const {api} = require('../bin/commands/api');
 
 const baseImport = 'import * as DG from \'datagrok-api/dg\';\n';
+
+function normEol(s) {
+  return s.replace(/\r\n/g, '\n');
+}
 // eslint-disable-next-line max-len
 const annotationForGeneratedFile = `/**\nThis file is auto-generated by the webpack command.\nIf you notice any changes, please push them to the repository.\nDo not edit this file manually.\n*/\n`;
 
@@ -85,7 +89,7 @@ class FuncGeneratorPlugin {
           }
         });
         this._insertImports([...imports]);
-        fs.appendFileSync(this.options.outputPath, functions.join(''), 'utf-8');
+        fs.appendFileSync(this.options.outputPath, normEol(functions.join('')), 'utf-8');
       }
       this._checkPackageFileForDecoratorsExport(packageFilePath);
       // Uncommment to add obvious import/export
@@ -512,7 +516,7 @@ class FuncGeneratorPlugin {
   }
 
   _clearGeneratedFile() {
-    fs.writeFileSync(this.options.outputPath, baseImport);
+    fs.writeFileSync(this.options.outputPath, normEol(baseImport));
   }
 
   _checkPackageFileForDecoratorsExport(packagePath) {
@@ -543,11 +547,11 @@ class FuncGeneratorPlugin {
       const content = fs.readFileSync(this.options.outputPath, 'utf-8');
       if (content) importArray.push(content);
       const output = importArray.join('');
-      fs.writeFileSync(this.options.outputPath, `${output}`, 'utf-8');
+      fs.writeFileSync(this.options.outputPath, normEol(output), 'utf-8');
     } else {
       fs.writeFileSync(
         this.options.outputPath,
-        `${annotationForGeneratedFile}${baseImport}\n${importArray.join('')}`,
+        normEol(`${annotationForGeneratedFile}${baseImport}\n${importArray.join('')}`),
         'utf-8',
       );
     }