@deot/dev-shared 1.0.1 → 1.1.0

package/dist/index.cjs.js

@@ -0,0 +1,275 @@
+'use strict';
+
+var os = require('node:os');
+var path = require('node:path');
+var childProcess = require('node:child_process');
+var util = require('node:util');
+var fs = require('node:fs');
+var node_module = require('node:module');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
+var childProcess__namespace = /*#__PURE__*/_interopNamespaceDefault(childProcess);
+var util__namespace = /*#__PURE__*/_interopNamespaceDefault(util);
+var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
+
+const getHost = () => {
+    const ips = [];
+    const ntwk = os.networkInterfaces();
+    for (const k in ntwk) {
+        for (let i = 0; i < ntwk[k].length; i++) {
+            const _add = ntwk[k][i].address;
+            if (_add && _add.split('.').length == 4 && !ntwk[k][i].internal && ntwk[k][i].family == 'IPv4') {
+                ips.push(_add);
+            }
+        }
+    }
+    return ips[0];
+};
+const formatBytes = (size, suffix = 2) => {
+    if (!size)
+        return "0B";
+    const base = 1024;
+    const units = ["B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+    const index = Math.floor(Math.log(size) / Math.log(base));
+    const value = parseFloat((size / (base ** index)).toFixed(suffix));
+    return value + units[index];
+};
+const autoCatch = async (impl, options = {}) => {
+    const { onError = console.error } = options;
+    let target = impl;
+    typeof target === 'function' && (target = target());
+    try {
+        const e = await target;
+        return e;
+    }
+    catch (e) {
+        onError(e);
+    }
+};
+
+var utils = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    autoCatch: autoCatch,
+    formatBytes: formatBytes,
+    getHost: getHost
+});
+
+const log = console.log;
+const error = console.error;
+const info = console.info;
+
+var logger = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    error: error,
+    info: info,
+    log: log
+});
+
+const SPACE = ' ';
+const binDirectory = path__namespace.resolve(process.cwd(), './node_modules/.bin');
+const LOCAL_COMMAND_MAP = fs__namespace.existsSync(binDirectory)
+    ? fs__namespace
+        .readdirSync(binDirectory)
+        .reduce((pre, file) => {
+        const fullpath = path__namespace.resolve(binDirectory, file);
+        const stat = fs__namespace.statSync(fullpath);
+        if (stat.isFile()) {
+            pre[file] = `./node_modules/.bin/${file}`;
+        }
+        return pre;
+    }, {})
+    : {};
+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 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) => {
+            if (code === 0) {
+                resolve(code);
+            }
+            else {
+                reject(code);
+            }
+        });
+        emit.on('error', (error) => {
+            !process.exitCode && (process.exitCode = 1);
+            reject(error);
+        });
+    });
+};
+
+var shell = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    LOCAL_COMMAND_MAP: LOCAL_COMMAND_MAP,
+    command: command,
+    exec: exec,
+    spawn: spawn
+});
+
+const cwd$ = process.cwd();
+const require$ = node_module.createRequire(cwd$);
+const getNormalizePackage = (dataMap) => {
+    Object.keys(dataMap).forEach(packageName => {
+        const relations = dataMap[packageName];
+        relations.forEach((packageName$) => {
+            if (dataMap[packageName$].includes(packageName)) {
+                throw new Error(`${packageName} ${packageName$} deps loop`);
+            }
+        });
+    });
+    const needUseMap = Object.keys(dataMap).reduce((pre, key) => (pre[key] = 0, pre), {});
+    const queue = [];
+    for (let key in dataMap) {
+        const dependencies = dataMap[key];
+        dependencies.forEach((dependency) => {
+            needUseMap[dependency] += 1;
+        });
+    }
+    for (let key in needUseMap) {
+        if (needUseMap[key] === 0) {
+            queue.push(key);
+        }
+    }
+    const result = [];
+    while (queue.length > 0) {
+        const node = queue.shift();
+        if (!node)
+            return [];
+        result.push(node);
+        const dependencies = dataMap[node];
+        for (let i = 0; i < dependencies.length; i++) {
+            const dependency = dependencies[i];
+            needUseMap[dependency] -= 1;
+            if (needUseMap[dependency] === 0) {
+                queue.push(dependency);
+            }
+        }
+    }
+    return result.reverse();
+};
+const getPackageName = (packageFolderName$) => {
+    const { workspace, packageFolderName, packageName } = impl();
+    if (!workspace
+        || !packageFolderName$
+        || packageFolderName$ === packageFolderName) {
+        return packageName;
+    }
+    else {
+        return `${packageName}-${packageFolderName$.replace(new RegExp(`${packageName}-?`), '')}`;
+    }
+};
+const getPackageFolderName = (packageName$) => {
+    const { workspace, packageFolderName, packageName } = impl();
+    if (!workspace)
+        return '';
+    if (packageName$ === packageName)
+        return packageFolderName;
+    return packageName$?.replace(new RegExp(`${packageName}-?`), '');
+};
+let configMap = {};
+const impl = (cwd) => {
+    cwd = cwd || cwd$;
+    if (configMap[cwd])
+        return configMap[cwd];
+    const rootPackageOptions = require$(`${cwd}/package.json`);
+    let workspace = 'packages';
+    let isMonorepo = fs__namespace.existsSync(path__namespace.resolve(cwd, workspace));
+    workspace = isMonorepo ? workspace : '';
+    const packageFolderName = isMonorepo ? 'index' : '';
+    const packageDir = path__namespace.resolve(cwd, workspace);
+    const packageOptions = require$(path__namespace.resolve(packageDir, packageFolderName, 'package.json'));
+    const packageName = packageOptions.name;
+    const packageVersion = packageOptions.version;
+    const packageFolderNames = !isMonorepo ? [] : fs__namespace
+        .readdirSync(packageDir)
+        .reduce((pre, file) => {
+        const fullpath = path__namespace.resolve(packageDir, file);
+        const stat = fs__namespace.statSync(fullpath);
+        if (!(/(^_|tpl)/.test(file))
+            && stat.isDirectory()) {
+            pre.push(file);
+        }
+        return pre;
+    }, []);
+    const packageOptionsMap = packageFolderNames.reduce((pre, packageFolderName$) => {
+        pre[packageFolderName$] = require$(path__namespace.resolve(packageDir, packageFolderName$, 'package.json'));
+        return pre;
+    }, {});
+    const packageDirsMap = packageFolderNames.reduce((pre, packageFolderName$) => {
+        pre[packageFolderName$] = path__namespace.resolve(packageDir, packageFolderName$);
+        return pre;
+    }, {});
+    const packageRelation = packageFolderNames.reduce((pre, packageFolderName$) => {
+        let packagesOptions = packageOptionsMap[packageFolderName$];
+        let deps = {
+            ...(packagesOptions.dependencies || {}),
+            ...(packagesOptions.devDependencies || {}),
+        };
+        pre[packagesOptions.name] = Object.keys(deps).filter(i => new RegExp(`${packageName}`).test(i));
+        return pre;
+    }, {});
+    const normalizePackageNames = getNormalizePackage(packageRelation);
+    const normalizePackageFolderNames = normalizePackageNames
+        .map(i => i.replace(new RegExp(`${packageName}-?`), '') || packageFolderName);
+    const homepage = (rootPackageOptions.repository || packageOptions.repository || {}).url || '';
+    const config = {
+        cwd,
+        workspace,
+        homepage: homepage.replace(/(.*)(https?:\/\/.*)(#|\.git)/, '$2'),
+        packageFolderName,
+        packageDir,
+        packageOptions,
+        packageName,
+        packageVersion,
+        packageFolderNames,
+        packageOptionsMap,
+        packageDirsMap,
+        packageRelation,
+        normalizePackageNames,
+        normalizePackageFolderNames
+    };
+    configMap[cwd] = config;
+    return config;
+};
+
+var locals = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    getNormalizePackage: getNormalizePackage,
+    getPackageFolderName: getPackageFolderName,
+    getPackageName: getPackageName,
+    impl: impl
+});
+
+exports.Locals = locals;
+exports.Logger = logger;
+exports.Shell = shell;
+exports.Utils = utils;

package/dist/index.d.ts

@@ -8,6 +8,8 @@ export declare interface AnyFunction<T = void> {
 
 declare const autoCatch: (impl: any, options?: Options) => Promise<any>;
 
+declare const command: (command$: string, args?: string[]) => RegExpMatchArray | [];
+
 export declare type Customized<Origin = any, Extend = any> = Origin & Extend;
 
 declare const error: {
@@ -15,14 +17,40 @@ declare const error: {
     (message?: any, ...optionalParams: any[]): void;
 };
 
-declare const exec: typeof childProcess.exec.__promisify__;
+declare const exec: (command$: string, args?: string[]) => childProcess.PromiseWithChild<{
+    stdout: string;
+    stderr: string;
+}>;
 
 declare const formatBytes: (size: number, suffix?: number) => string;
 
 declare const getHost: () => string;
 
+declare const getNormalizePackage: (dataMap: any) => string[];
+
+declare const getPackageFolderName: (packageName$: string) => string;
+
+declare const getPackageName: (packageFolderName$: string) => any;
+
 export declare type Hash<T> = Indexable<T>;
 
+declare const impl: (cwd?: string) => {
+    cwd: string;
+    workspace: string;
+    homepage: any;
+    packageFolderName: string;
+    packageDir: string;
+    packageOptions: any;
+    packageName: any;
+    packageVersion: any;
+    packageFolderNames: string[];
+    packageOptionsMap: {};
+    packageDirsMap: {};
+    packageRelation: {};
+    normalizePackageNames: string[];
+    normalizePackageFolderNames: string[];
+};
+
 export declare type Indexable<T = any> = {
     [key: string]: T;
 };
@@ -34,6 +62,16 @@ declare const info: {
 
 declare const LOCAL_COMMAND_MAP: any;
 
+declare namespace Locals {
+    export {
+        getNormalizePackage,
+        getPackageName,
+        getPackageFolderName,
+        impl
+    }
+}
+export { Locals }
+
 declare const log: {
     (...data: any[]): void;
     (message?: any, ...optionalParams: any[]): void;
@@ -55,13 +93,14 @@ export declare type Options<T = {}> = Indexable & T;
 declare namespace Shell {
     export {
         LOCAL_COMMAND_MAP,
+        command,
         exec,
         spawn
     }
 }
 export { Shell }
 
-declare const spawn: (command: string, args?: string[]) => Promise<unknown>;
+declare const spawn: (command$: string, args?: string[], options?: any) => Promise<unknown>;
 
 export declare type TimeoutHandle = ReturnType<typeof global.setTimeout>;
 

package/dist/index.es.js

@@ -0,0 +1,248 @@
+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';
+
+const getHost = () => {
+    const ips = [];
+    const ntwk = os.networkInterfaces();
+    for (const k in ntwk) {
+        for (let i = 0; i < ntwk[k].length; i++) {
+            const _add = ntwk[k][i].address;
+            if (_add && _add.split('.').length == 4 && !ntwk[k][i].internal && ntwk[k][i].family == 'IPv4') {
+                ips.push(_add);
+            }
+        }
+    }
+    return ips[0];
+};
+const formatBytes = (size, suffix = 2) => {
+    if (!size)
+        return "0B";
+    const base = 1024;
+    const units = ["B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+    const index = Math.floor(Math.log(size) / Math.log(base));
+    const value = parseFloat((size / (base ** index)).toFixed(suffix));
+    return value + units[index];
+};
+const autoCatch = async (impl, options = {}) => {
+    const { onError = console.error } = options;
+    let target = impl;
+    typeof target === 'function' && (target = target());
+    try {
+        const e = await target;
+        return e;
+    }
+    catch (e) {
+        onError(e);
+    }
+};
+
+var utils = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    autoCatch: autoCatch,
+    formatBytes: formatBytes,
+    getHost: getHost
+});
+
+const log = console.log;
+const error = console.error;
+const info = console.info;
+
+var logger = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    error: error,
+    info: info,
+    log: log
+});
+
+const SPACE = ' ';
+const binDirectory = path.resolve(process.cwd(), './node_modules/.bin');
+const LOCAL_COMMAND_MAP = fs.existsSync(binDirectory)
+    ? fs
+        .readdirSync(binDirectory)
+        .reduce((pre, file) => {
+        const fullpath = path.resolve(binDirectory, file);
+        const stat = fs.statSync(fullpath);
+        if (stat.isFile()) {
+            pre[file] = `./node_modules/.bin/${file}`;
+        }
+        return pre;
+    }, {})
+    : {};
+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 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) => {
+            if (code === 0) {
+                resolve(code);
+            }
+            else {
+                reject(code);
+            }
+        });
+        emit.on('error', (error) => {
+            !process.exitCode && (process.exitCode = 1);
+            reject(error);
+        });
+    });
+};
+
+var shell = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    LOCAL_COMMAND_MAP: LOCAL_COMMAND_MAP,
+    command: command,
+    exec: exec,
+    spawn: spawn
+});
+
+const cwd$ = process.cwd();
+const require$ = createRequire(cwd$);
+const getNormalizePackage = (dataMap) => {
+    Object.keys(dataMap).forEach(packageName => {
+        const relations = dataMap[packageName];
+        relations.forEach((packageName$) => {
+            if (dataMap[packageName$].includes(packageName)) {
+                throw new Error(`${packageName} ${packageName$} deps loop`);
+            }
+        });
+    });
+    const needUseMap = Object.keys(dataMap).reduce((pre, key) => (pre[key] = 0, pre), {});
+    const queue = [];
+    for (let key in dataMap) {
+        const dependencies = dataMap[key];
+        dependencies.forEach((dependency) => {
+            needUseMap[dependency] += 1;
+        });
+    }
+    for (let key in needUseMap) {
+        if (needUseMap[key] === 0) {
+            queue.push(key);
+        }
+    }
+    const result = [];
+    while (queue.length > 0) {
+        const node = queue.shift();
+        if (!node)
+            return [];
+        result.push(node);
+        const dependencies = dataMap[node];
+        for (let i = 0; i < dependencies.length; i++) {
+            const dependency = dependencies[i];
+            needUseMap[dependency] -= 1;
+            if (needUseMap[dependency] === 0) {
+                queue.push(dependency);
+            }
+        }
+    }
+    return result.reverse();
+};
+const getPackageName = (packageFolderName$) => {
+    const { workspace, packageFolderName, packageName } = impl();
+    if (!workspace
+        || !packageFolderName$
+        || packageFolderName$ === packageFolderName) {
+        return packageName;
+    }
+    else {
+        return `${packageName}-${packageFolderName$.replace(new RegExp(`${packageName}-?`), '')}`;
+    }
+};
+const getPackageFolderName = (packageName$) => {
+    const { workspace, packageFolderName, packageName } = impl();
+    if (!workspace)
+        return '';
+    if (packageName$ === packageName)
+        return packageFolderName;
+    return packageName$?.replace(new RegExp(`${packageName}-?`), '');
+};
+let configMap = {};
+const impl = (cwd) => {
+    cwd = cwd || cwd$;
+    if (configMap[cwd])
+        return configMap[cwd];
+    const rootPackageOptions = require$(`${cwd}/package.json`);
+    let workspace = 'packages';
+    let isMonorepo = fs.existsSync(path.resolve(cwd, workspace));
+    workspace = isMonorepo ? workspace : '';
+    const packageFolderName = isMonorepo ? 'index' : '';
+    const packageDir = path.resolve(cwd, workspace);
+    const packageOptions = require$(path.resolve(packageDir, packageFolderName, 'package.json'));
+    const packageName = packageOptions.name;
+    const packageVersion = packageOptions.version;
+    const packageFolderNames = !isMonorepo ? [] : fs
+        .readdirSync(packageDir)
+        .reduce((pre, file) => {
+        const fullpath = path.resolve(packageDir, file);
+        const stat = fs.statSync(fullpath);
+        if (!(/(^_|tpl)/.test(file))
+            && stat.isDirectory()) {
+            pre.push(file);
+        }
+        return pre;
+    }, []);
+    const packageOptionsMap = packageFolderNames.reduce((pre, packageFolderName$) => {
+        pre[packageFolderName$] = require$(path.resolve(packageDir, packageFolderName$, 'package.json'));
+        return pre;
+    }, {});
+    const packageDirsMap = packageFolderNames.reduce((pre, packageFolderName$) => {
+        pre[packageFolderName$] = path.resolve(packageDir, packageFolderName$);
+        return pre;
+    }, {});
+    const packageRelation = packageFolderNames.reduce((pre, packageFolderName$) => {
+        let packagesOptions = packageOptionsMap[packageFolderName$];
+        let deps = {
+            ...(packagesOptions.dependencies || {}),
+            ...(packagesOptions.devDependencies || {}),
+        };
+        pre[packagesOptions.name] = Object.keys(deps).filter(i => new RegExp(`${packageName}`).test(i));
+        return pre;
+    }, {});
+    const normalizePackageNames = getNormalizePackage(packageRelation);
+    const normalizePackageFolderNames = normalizePackageNames
+        .map(i => i.replace(new RegExp(`${packageName}-?`), '') || packageFolderName);
+    const homepage = (rootPackageOptions.repository || packageOptions.repository || {}).url || '';
+    const config = {
+        cwd,
+        workspace,
+        homepage: homepage.replace(/(.*)(https?:\/\/.*)(#|\.git)/, '$2'),
+        packageFolderName,
+        packageDir,
+        packageOptions,
+        packageName,
+        packageVersion,
+        packageFolderNames,
+        packageOptionsMap,
+        packageDirsMap,
+        packageRelation,
+        normalizePackageNames,
+        normalizePackageFolderNames
+    };
+    configMap[cwd] = config;
+    return config;
+};
+
+var locals = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    getNormalizePackage: getNormalizePackage,
+    getPackageFolderName: getPackageFolderName,
+    getPackageName: getPackageName,
+    impl: impl
+});
+
+export { locals as Locals, logger as Logger, shell as Shell, utils as Utils };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@deot/dev-shared",
-  "version": "1.0.1",
-  "main": "dist/index.js",
+  "version": "1.1.0",
+  "main": "dist/index.es.js",
   "types": "dist/index.d.ts",
   "type": "module",
   "files": [
@@ -10,6 +10,5 @@
   "license": "MIT",
   "publishConfig": {
     "access": "public"
-  },
-  "gitHead": "9f098b9a3cfa6deae01cf6066d6cc2e07ee26034"
-}
+  }
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2023 deot
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/dist/index.js

@@ -1,107 +0,0 @@
-import os from 'node:os';
-import path from 'node:path';
-import * as childProcess from 'node:child_process';
-import util from 'node:util';
-import fs from 'node:fs';
-
-const getHost = () => {
-    const ips = [];
-    const ntwk = os.networkInterfaces();
-    for (const k in ntwk) {
-        for (let i = 0; i < ntwk[k].length; i++) {
-            const _add = ntwk[k][i].address;
-            if (_add && _add.split('.').length == 4 && !ntwk[k][i].internal && ntwk[k][i].family == 'IPv4') {
-                ips.push(_add);
-            }
-        }
-    }
-    return ips[0];
-};
-const formatBytes = (size, suffix = 2) => {
-    if (!size)
-        return "0B";
-    const base = 1024;
-    const units = ["B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
-    const index = Math.floor(Math.log(size) / Math.log(base));
-    const value = parseFloat((size / (base ** index)).toFixed(suffix));
-    return value + units[index];
-};
-const autoCatch = async (impl, options = {}) => {
-    const { onError = console.error } = options;
-    let target = impl;
-    typeof target === 'function' && (target = target());
-    try {
-        const e = await target;
-        return e;
-    }
-    catch (e) {
-        onError(e);
-    }
-};
-
-var utils = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    autoCatch: autoCatch,
-    formatBytes: formatBytes,
-    getHost: getHost
-});
-
-const log = console.log;
-const error = console.error;
-const info = console.info;
-
-var logger = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    error: error,
-    info: info,
-    log: log
-});
-
-const SPACE = ' ';
-const binDirectory = path.resolve(process.cwd(), './node_modules/.bin');
-const LOCAL_COMMAND_MAP = fs.existsSync(binDirectory)
-    ? fs
-        .readdirSync(binDirectory)
-        .reduce((pre, file) => {
-        const fullpath = path.resolve(binDirectory, file);
-        const stat = fs.statSync(fullpath);
-        if (stat.isFile()) {
-            pre[file] = `./node_modules/.bin/${file}`;
-        }
-        return pre;
-    }, {})
-    : {};
-const exec = util.promisify(childProcess.exec);
-const spawn = (command, args = []) => {
-    const [command$, ...args$] = (command + SPACE + args.join(SPACE))
-        .replace(/\s+/g, SPACE)
-        .split(SPACE)
-        .filter(i => !!i)
-        .map(i => LOCAL_COMMAND_MAP[i] || i);
-    return new Promise((resolve, reject) => {
-        const emit = childProcess.spawn(command$, args$, {
-            stdio: 'inherit'
-        });
-        emit.on('close', (code) => {
-            if (code === 0) {
-                resolve(code);
-            }
-            else {
-                reject(code);
-            }
-        });
-        emit.on('error', (error) => {
-            !process.exitCode && (process.exitCode = 1);
-            reject(error);
-        });
-    });
-};
-
-var shell = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    LOCAL_COMMAND_MAP: LOCAL_COMMAND_MAP,
-    exec: exec,
-    spawn: spawn
-});
-
-export { logger as Logger, shell as Shell, utils as Utils };