@deot/dev-shared 2.4.0 → 2.6.0

package/dist/index.cjs

@@ -5,7 +5,6 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const os = require('node:os');
 const path = require('node:path');
 const childProcess = require('node:child_process');
-const util = require('node:util');
 const fs = require('node:fs');
 const node_module = require('node:module');
 
@@ -28,7 +27,6 @@ function _interopNamespaceDefault(e) {
 
 const path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
 const childProcess__namespace = /*#__PURE__*/_interopNamespaceDefault(childProcess);
-const util__namespace = /*#__PURE__*/_interopNamespaceDefault(util);
 const fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
 
 const getHost = () => {
@@ -85,6 +83,13 @@ const logger = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
 
 const SPACE = " ";
 const binDirectory = path__namespace.resolve(process.cwd(), "./node_modules/.bin");
+const toPromise = (target, promise) => {
+  let instance = target;
+  instance.then = (resolve, reject) => promise.then(resolve, reject);
+  instance.catch = (callback) => promise.catch(callback);
+  instance.finally = (callback) => promise.finally(callback);
+  return instance;
+};
 /* istanbul ignore next -- @preserve */
 const LOCAL_COMMAND_MAP = fs__namespace.existsSync(binDirectory) ? fs__namespace.readdirSync(binDirectory).reduce((pre, file) => {
   const fullpath = path__namespace.resolve(binDirectory, file);
@@ -98,33 +103,68 @@ const command = (command$, args) => {
   const v = (command$ + SPACE + (args || []).join(SPACE)).match(/[^\s'"]+|'[^']*'|"[^"]*"/g);
   return v || [];
 };
-const exec = (command$, args) => {
-  return util__namespace.promisify(childProcess__namespace.exec)(command(command$, args).join(SPACE));
+const exec = (command$, args, options) => {
+  let command$$ = command(command$, args).join(SPACE);
+  let reject;
+  let resolve;
+  const promise = new Promise((resolve$, reject$) => {
+    reject = reject$;
+    resolve = resolve$;
+  });
+  const subprocess = childProcess__namespace.exec(command$$, options, (error, stdout, stderr) => {
+    process.off("beforeExit", handler);
+    if (error) {
+      reject(error);
+      return;
+    }
+    resolve({
+      stderr: stderr.toString(),
+      stdout: stdout.toString()
+    });
+  });
+  const handler = (
+    /* istanbul ignore next */
+    () => {
+      !subprocess.killed && subprocess.kill("SIGHUP");
+    }
+  );
+  process.on("beforeExit", handler);
+  return toPromise(subprocess, promise);
 };
 const spawn = (command$, args, options) => {
   let [command$$, ...args$] = command(command$, args).map((i) => LOCAL_COMMAND_MAP[i] || i);
   args$ = args$.map((i) => i.replace(/^['"]|['"]$/g, ""));
-  return new Promise((resolve, reject) => {
-    const emit = childProcess__namespace.spawn(
-      command$$,
-      args$,
-      {
-        stdio: "inherit",
-        ...options
-      }
-    );
-    emit.on("close", (code) => {
+  const subprocess = childProcess__namespace.spawn(
+    command$$,
+    args$,
+    {
+      stdio: "inherit",
+      ...options
+    }
+  );
+  const promise = new Promise((resolve, reject) => {
+    subprocess.on("close", (code) => {
+      process.off("beforeExit", handler);
       if (code === 0) {
         resolve(code);
       } else {
         reject(code);
       }
     });
-    emit.on("error", (error) => {
+    subprocess.on("error", (error) => {
+      process.off("beforeExit", handler);
       !process.exitCode && (process.exitCode = 1);
       reject(error);
     });
   });
+  const handler = (
+    /* istanbul ignore next */
+    () => {
+      !subprocess.killed && subprocess.kill("SIGHUP");
+    }
+  );
+  process.on("beforeExit", handler);
+  return toPromise(subprocess, promise);
 };
 
 const shell = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
@@ -233,6 +273,18 @@ const impl = (cwd) => {
     pre[packagesOptions.name] = Object.keys(deps).filter((i) => new RegExp(`${packageName}`).test(i));
     return pre;
   }, {});
+  const subpackagesMap = packageFolderNames.reduce((pre, packageFolderName$) => {
+    let dir = path__namespace.resolve(packageDir, packageFolderName$);
+    pre[packageFolderName$] = workspace && fs__namespace.existsSync(`${dir}/index.ts`) && !fs__namespace.existsSync(`${dir}/src`) ? fs__namespace.readdirSync(dir).filter((file) => {
+      const fullpath = path__namespace.join(dir, file);
+      const stat = fs__namespace.statSync(fullpath);
+      if (stat.isDirectory()) {
+        return fs__namespace.existsSync(`${fullpath}/__tests__`);
+      }
+      return false;
+    }) : [];
+    return pre;
+  }, {});
   const normalizePackageNames = getNormalizePackage(packageRelation);
   const normalizePackageFolderNames = normalizePackageNames.map((i) => i.replace(new RegExp(`${packageName}-?`), "") || packageFolderName);
   const homepage = (rootPackageOptions.repository || packageOptions.repository || {}).url || "";
@@ -251,7 +303,8 @@ const impl = (cwd) => {
     packageDirsMap,
     packageRelation,
     normalizePackageNames,
-    normalizePackageFolderNames
+    normalizePackageFolderNames,
+    subpackagesMap
   };
   configMap[cwd] = config;
   return config;

package/dist/index.d.ts

@@ -17,10 +17,10 @@ declare const error: {
     (message?: any, ...optionalParams: any[]): void;
 };
 
-declare const exec: (command$: string, args?: string[]) => childProcess.PromiseWithChild<{
-    stdout: string;
+declare const exec: (command$: string, args?: string[], options?: any) => childProcess.ChildProcess & IPromise<{
     stderr: string;
-}>;
+    stdout: string;
+}, any>;
 
 declare const formatBytes: (size: number, suffix?: number) => string;
 
@@ -50,6 +50,7 @@ declare const impl: (cwd?: string) => {
     packageRelation: {};
     normalizePackageNames: string[];
     normalizePackageFolderNames: string[];
+    subpackagesMap: {};
 };
 
 export declare type Indexable<T = any> = {
@@ -61,6 +62,12 @@ declare const info: {
     (message?: any, ...optionalParams: any[]): void;
 };
 
+declare interface IPromise<T = any, K = any> {
+    then: (resolve: (a: T) => void, reject: (b: K) => void) => Promise<any>;
+    catch: (callback?: (b: K) => void) => Promise<any>;
+    finally: (callback?: () => void) => Promise<any>;
+}
+
 declare const LOCAL_COMMAND_MAP: any;
 
 declare namespace Locals {
@@ -101,7 +108,7 @@ declare namespace Shell {
 }
 export { Shell }
 
-declare const spawn: (command$: string, args?: string[], options?: any) => Promise<unknown>;
+declare const spawn: (command$: string, args?: string[], options?: any) => childProcess.ChildProcessWithoutNullStreams & IPromise<unknown, any>;
 
 export declare type TimeoutHandle = ReturnType<typeof global.setTimeout>;
 

package/dist/{index.es.js → index.js}

@@ -1,7 +1,6 @@
 import os from 'node:os';
 import * as path from 'node:path';
 import * as childProcess from 'node:child_process';
-import * as util from 'node:util';
 import * as fs from 'node:fs';
 import { createRequire } from 'node:module';
 
@@ -59,6 +58,13 @@ const logger = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
 
 const SPACE = " ";
 const binDirectory = path.resolve(process.cwd(), "./node_modules/.bin");
+const toPromise = (target, promise) => {
+  let instance = target;
+  instance.then = (resolve, reject) => promise.then(resolve, reject);
+  instance.catch = (callback) => promise.catch(callback);
+  instance.finally = (callback) => promise.finally(callback);
+  return instance;
+};
 /* istanbul ignore next -- @preserve */
 const LOCAL_COMMAND_MAP = fs.existsSync(binDirectory) ? fs.readdirSync(binDirectory).reduce((pre, file) => {
   const fullpath = path.resolve(binDirectory, file);
@@ -72,33 +78,68 @@ const command = (command$, args) => {
   const v = (command$ + SPACE + (args || []).join(SPACE)).match(/[^\s'"]+|'[^']*'|"[^"]*"/g);
   return v || [];
 };
-const exec = (command$, args) => {
-  return util.promisify(childProcess.exec)(command(command$, args).join(SPACE));
+const exec = (command$, args, options) => {
+  let command$$ = command(command$, args).join(SPACE);
+  let reject;
+  let resolve;
+  const promise = new Promise((resolve$, reject$) => {
+    reject = reject$;
+    resolve = resolve$;
+  });
+  const subprocess = childProcess.exec(command$$, options, (error, stdout, stderr) => {
+    process.off("beforeExit", handler);
+    if (error) {
+      reject(error);
+      return;
+    }
+    resolve({
+      stderr: stderr.toString(),
+      stdout: stdout.toString()
+    });
+  });
+  const handler = (
+    /* istanbul ignore next */
+    () => {
+      !subprocess.killed && subprocess.kill("SIGHUP");
+    }
+  );
+  process.on("beforeExit", handler);
+  return toPromise(subprocess, promise);
 };
 const spawn = (command$, args, options) => {
   let [command$$, ...args$] = command(command$, args).map((i) => LOCAL_COMMAND_MAP[i] || i);
   args$ = args$.map((i) => i.replace(/^['"]|['"]$/g, ""));
-  return new Promise((resolve, reject) => {
-    const emit = childProcess.spawn(
-      command$$,
-      args$,
-      {
-        stdio: "inherit",
-        ...options
-      }
-    );
-    emit.on("close", (code) => {
+  const subprocess = childProcess.spawn(
+    command$$,
+    args$,
+    {
+      stdio: "inherit",
+      ...options
+    }
+  );
+  const promise = new Promise((resolve, reject) => {
+    subprocess.on("close", (code) => {
+      process.off("beforeExit", handler);
       if (code === 0) {
         resolve(code);
       } else {
         reject(code);
       }
     });
-    emit.on("error", (error) => {
+    subprocess.on("error", (error) => {
+      process.off("beforeExit", handler);
       !process.exitCode && (process.exitCode = 1);
       reject(error);
     });
   });
+  const handler = (
+    /* istanbul ignore next */
+    () => {
+      !subprocess.killed && subprocess.kill("SIGHUP");
+    }
+  );
+  process.on("beforeExit", handler);
+  return toPromise(subprocess, promise);
 };
 
 const shell = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
@@ -207,6 +248,18 @@ const impl = (cwd) => {
     pre[packagesOptions.name] = Object.keys(deps).filter((i) => new RegExp(`${packageName}`).test(i));
     return pre;
   }, {});
+  const subpackagesMap = packageFolderNames.reduce((pre, packageFolderName$) => {
+    let dir = path.resolve(packageDir, packageFolderName$);
+    pre[packageFolderName$] = workspace && fs.existsSync(`${dir}/index.ts`) && !fs.existsSync(`${dir}/src`) ? fs.readdirSync(dir).filter((file) => {
+      const fullpath = path.join(dir, file);
+      const stat = fs.statSync(fullpath);
+      if (stat.isDirectory()) {
+        return fs.existsSync(`${fullpath}/__tests__`);
+      }
+      return false;
+    }) : [];
+    return pre;
+  }, {});
   const normalizePackageNames = getNormalizePackage(packageRelation);
   const normalizePackageFolderNames = normalizePackageNames.map((i) => i.replace(new RegExp(`${packageName}-?`), "") || packageFolderName);
   const homepage = (rootPackageOptions.repository || packageOptions.repository || {}).url || "";
@@ -225,7 +278,8 @@ const impl = (cwd) => {
     packageDirsMap,
     packageRelation,
     normalizePackageNames,
-    normalizePackageFolderNames
+    normalizePackageFolderNames,
+    subpackagesMap
   };
   configMap[cwd] = config;
   return config;

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@deot/dev-shared",
-  "version": "2.4.0",
+  "version": "2.6.0",
   "type": "module",
-  "main": "dist/index.es.js",
+  "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
     ".": {
-      "import": "./dist/index.es.js",
+      "import": "./dist/index.js",
       "require": "./dist/index.cjs",
       "types": "./dist/index.d.ts"
     }