@modern-js/utils 1.3.6 → 1.3.8-canary.0

package/dist/getPackageManager.js

@@ -0,0 +1,47 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPackageManager = void 0;
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const compiled_1 = require("./compiled");
+const nodeEnv_1 = require("./nodeEnv");
+const MAX_TIMES = 5;
+function getPackageManager(cwd = process.cwd()) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let appDirectory = cwd;
+        let times = 0;
+        while (os_1.default.homedir() !== appDirectory && times < MAX_TIMES) {
+            times++;
+            if (compiled_1.fs.existsSync(path_1.default.resolve(appDirectory, 'pnpm-lock.yaml'))) {
+                return 'pnpm';
+            }
+            if (compiled_1.fs.existsSync(path_1.default.resolve(appDirectory, 'yarn.lock'))) {
+                return 'yarn';
+            }
+            if (compiled_1.fs.existsSync(path_1.default.resolve(appDirectory, 'package-lock.json'))) {
+                return 'npm';
+            }
+            appDirectory = path_1.default.join(appDirectory, '..');
+        }
+        if (yield (0, nodeEnv_1.canUsePnpm)()) {
+            return 'pnpm';
+        }
+        if (yield (0, nodeEnv_1.canUseYarn)()) {
+            return 'yarn';
+        }
+        return 'npm';
+    });
+}
+exports.getPackageManager = getPackageManager;

package/dist/getPort.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Get available free port.
+ * @param port - Current port want to use.
+ * @param tryLimits - Maximum number of retries.
+ * @returns Available port number.
+ */
+export declare const getPort: (port: string | number, tryLimits?: number) => Promise<number>;

package/dist/getPort.js

@@ -0,0 +1,62 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPort = void 0;
+const net_1 = __importDefault(require("net"));
+const compiled_1 = require("./compiled");
+const logger_1 = require("./logger");
+/**
+ * Get available free port.
+ * @param port - Current port want to use.
+ * @param tryLimits - Maximum number of retries.
+ * @returns Available port number.
+ */
+/* eslint-disable no-param-reassign, @typescript-eslint/no-loop-func */
+const getPort = (port, tryLimits = 20) => __awaiter(void 0, void 0, void 0, function* () {
+    if (typeof port === 'string') {
+        port = parseInt(port, 10);
+    }
+    const original = port;
+    let found = false;
+    let attempts = 0;
+    while (!found && attempts <= tryLimits) {
+        try {
+            yield new Promise((resolve, reject) => {
+                const server = net_1.default.createServer();
+                server.unref();
+                server.on('error', reject);
+                server.listen({
+                    port,
+                    host: '0.0.0.0',
+                }, () => {
+                    found = true;
+                    server.close(resolve);
+                });
+            });
+        }
+        catch (e) {
+            if (e.code !== 'EADDRINUSE') {
+                throw e;
+            }
+            port++;
+            attempts++;
+        }
+    }
+    if (port !== original) {
+        logger_1.logger.info(compiled_1.chalk.red(`Something is already running on port ${original}. ${compiled_1.chalk.yellow(`Use port ${port} instead.`)}`));
+    }
+    return port;
+});
+exports.getPort = getPort;
+/* eslint-enable no-param-reassign, @typescript-eslint/no-loop-func */

package/dist/getServerConfig.d.ts

@@ -0,0 +1 @@
+export declare const getServerConfig: (appDirectory: string, configFile: string) => Promise<string | false>;

package/dist/getServerConfig.js

@@ -0,0 +1,39 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getServerConfig = void 0;
+const path = __importStar(require("path"));
+const constants_1 = require("./constants");
+const findExists_1 = require("./findExists");
+const getServerConfig = (appDirectory, configFile) => __awaiter(void 0, void 0, void 0, function* () {
+    const configFilePath = (0, findExists_1.findExists)(constants_1.CONFIG_FILE_EXTENSIONS.map(extension => path.resolve(appDirectory, `${configFile}${extension}`)));
+    return configFilePath;
+});
+exports.getServerConfig = getServerConfig;

package/dist/import.d.ts

@@ -0,0 +1,5 @@
+declare const lazy: (moduleName: string, requireFn: (id: string) => unknown) => any;
+export { lazy as lazyImport };
+export declare const Import: {
+    lazy: (moduleName: string, requireFn: (id: string) => unknown) => any;
+};

package/dist/import.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Import = exports.lazyImport = void 0;
+// cover: https://rushstack.io/pages/api/node-core-library.import.lazy/
+const lazy = (moduleName, requireFn) => {
+    const importLazyLocal = require('../compiled/import-lazy')(requireFn);
+    return importLazyLocal(moduleName);
+};
+exports.lazyImport = lazy;
+exports.Import = { lazy };

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+export * from './compiled';
+export * from './format';
+export * from './FileSizeReporter';
+export * from './printBuildError';
+export * from './debug';
+export * from './findExists';
+export * from './is';
+export * from './compatRequire';
+export * from './logger';
+export * from './constants';
+export * from './ensureAbsolutePath';
+export * from './getCacheIdentifier';
+export * from './clearConsole';
+export * from './applyOptionsChain';
+export * from './getBrowserslist';
+export * from './removeSlash';
+export * from './getEntryOptions';
+export * from './getPort';
+export * from './monorepo';
+export * from './getPackageManager';
+export * from './runtimeExports';
+export * from './readTsConfig';
+export * from './path';
+export * from './generateMetaTags';
+export * from './prettyInstructions';
+export * from './alias';
+export * from './import';
+export * from './watch';
+export * from './nodeEnv';
+export * from './wait';
+export * from './emptyDir';
+export * from './getServerConfig';
+export * from './ssrHelpers';

package/dist/index.js

@@ -0,0 +1,45 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./compiled"), exports);
+__exportStar(require("./format"), exports);
+__exportStar(require("./FileSizeReporter"), exports);
+__exportStar(require("./printBuildError"), exports);
+__exportStar(require("./debug"), exports);
+__exportStar(require("./findExists"), exports);
+__exportStar(require("./is"), exports);
+__exportStar(require("./compatRequire"), exports);
+__exportStar(require("./logger"), exports);
+__exportStar(require("./constants"), exports);
+__exportStar(require("./ensureAbsolutePath"), exports);
+__exportStar(require("./getCacheIdentifier"), exports);
+__exportStar(require("./clearConsole"), exports);
+__exportStar(require("./applyOptionsChain"), exports);
+__exportStar(require("./getBrowserslist"), exports);
+__exportStar(require("./removeSlash"), exports);
+__exportStar(require("./getEntryOptions"), exports);
+__exportStar(require("./getPort"), exports);
+__exportStar(require("./monorepo"), exports);
+__exportStar(require("./getPackageManager"), exports);
+__exportStar(require("./runtimeExports"), exports);
+__exportStar(require("./readTsConfig"), exports);
+__exportStar(require("./path"), exports);
+__exportStar(require("./generateMetaTags"), exports);
+__exportStar(require("./prettyInstructions"), exports);
+__exportStar(require("./alias"), exports);
+__exportStar(require("./import"), exports);
+__exportStar(require("./watch"), exports);
+__exportStar(require("./nodeEnv"), exports);
+__exportStar(require("./wait"), exports);
+__exportStar(require("./emptyDir"), exports);
+__exportStar(require("./getServerConfig"), exports);
+__exportStar(require("./ssrHelpers"), exports);

package/dist/is/index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Check if the package name is in dependencies or devDependencies.
+ *
+ * @param appDirectory - Project root directory.
+ * @param name - Package name.
+ * @returns True if the name is in dependencies or devDependencies, false otherwise.
+ */
+export declare const isDepExists: (appDirectory: string, name: string) => boolean;
+/**
+ * Is typescript project.
+ *
+ * @param root - App directory.
+ * @returns Whether to use typescript.
+ */
+export declare const isTypescript: (root: string) => boolean;
+/**
+ * Is Empty object
+ *
+ * @param o - Any object.
+ * @returns Whether it is empty object.
+ */
+export declare const isEmpty: (o: Record<string, unknown>) => boolean;
+/**
+ * Is SSR project
+ *
+ * @param config - User config.
+ * @returns Whether to use server side render.
+ */
+export declare const isSSR: (config: any) => boolean;
+export declare const isUseSSRBundle: (config: any) => boolean;
+export declare const isFastRefresh: () => boolean;
+export * from './node-env';
+export * from './platform';
+export * from './type';

package/dist/is/index.js

@@ -0,0 +1,82 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFastRefresh = exports.isUseSSRBundle = exports.isSSR = exports.isEmpty = exports.isTypescript = exports.isDepExists = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const node_env_1 = require("./node-env");
+/**
+ * Check if the package name is in dependencies or devDependencies.
+ *
+ * @param appDirectory - Project root directory.
+ * @param name - Package name.
+ * @returns True if the name is in dependencies or devDependencies, false otherwise.
+ */
+const isDepExists = (appDirectory, name) => {
+    const json = require(path_1.default.resolve(appDirectory, './package.json'));
+    const { dependencies = {}, devDependencies = {} } = json;
+    return (dependencies.hasOwnProperty(name) || devDependencies.hasOwnProperty(name));
+};
+exports.isDepExists = isDepExists;
+/**
+ * Is typescript project.
+ *
+ * @param root - App directory.
+ * @returns Whether to use typescript.
+ */
+const isTypescript = (root) => fs_1.default.existsSync(path_1.default.resolve(root, './tsconfig.json'));
+exports.isTypescript = isTypescript;
+/**
+ * Is Empty object
+ *
+ * @param o - Any object.
+ * @returns Whether it is empty object.
+ */
+const isEmpty = (o) => Object.entries(o).length === 0 && o.constructor === Object;
+exports.isEmpty = isEmpty;
+/**
+ * Is SSR project
+ *
+ * @param config - User config.
+ * @returns Whether to use server side render.
+ */
+const isSSR = (config) => {
+    const { server } = config;
+    if (server === null || server === void 0 ? void 0 : server.ssr) {
+        return true;
+    }
+    if ((server === null || server === void 0 ? void 0 : server.ssrByEntries) && !(0, exports.isEmpty)(server.ssrByEntries)) {
+        for (const name of Object.keys(server.ssrByEntries)) {
+            if (server.ssrByEntries[name]) {
+                return true;
+            }
+        }
+    }
+    return false;
+};
+exports.isSSR = isSSR;
+const isUseSSRBundle = (config) => {
+    const { output } = config;
+    if (output === null || output === void 0 ? void 0 : output.ssg) {
+        return true;
+    }
+    return (0, exports.isSSR)(config);
+};
+exports.isUseSSRBundle = isUseSSRBundle;
+const isFastRefresh = () => (0, node_env_1.isDev)() && process.env.FAST_REFRESH !== 'false';
+exports.isFastRefresh = isFastRefresh;
+__exportStar(require("./node-env"), exports);
+__exportStar(require("./platform"), exports);
+__exportStar(require("./type"), exports);

package/dist/is/node-env.d.ts

@@ -0,0 +1,4 @@
+export declare const isDev: () => boolean;
+export declare const isProd: () => boolean;
+export declare const isTest: () => boolean;
+export declare const isProdProfile: () => boolean;

package/dist/is/node-env.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isProdProfile = exports.isTest = exports.isProd = exports.isDev = void 0;
+const isDev = () => process.env.NODE_ENV === 'development';
+exports.isDev = isDev;
+const isProd = () => process.env.NODE_ENV === 'production';
+exports.isProd = isProd;
+const isTest = () => process.env.NODE_ENV === 'test';
+exports.isTest = isTest;
+// Variable used for enabling profiling in Production.
+const isProdProfile = () => (0, exports.isProd)() && process.argv.includes('--profile');
+exports.isProdProfile = isProdProfile;

package/dist/is/platform.d.ts

@@ -0,0 +1,2 @@
+export declare const isNodeJS: () => boolean;
+export declare const isBrowser: () => boolean;

package/dist/is/platform.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBrowser = exports.isNodeJS = void 0;
+const isNodeJS = () => typeof process !== 'undefined' &&
+    process.versions != null &&
+    process.versions.node != null &&
+    process.versions.electron == null;
+exports.isNodeJS = isNodeJS;
+const isBrowser = () => typeof window !== 'undefined';
+exports.isBrowser = isBrowser;

package/dist/is/type.d.ts

@@ -0,0 +1,8 @@
+export declare function isString(str: any): str is string;
+export declare function isUndefined(obj: any): obj is undefined;
+export declare function isArray(obj: unknown): obj is any[];
+export declare function isFunction(func: any): func is Function;
+export declare function isObject(obj: unknown): obj is Record<string, any>;
+export declare function isPlainObject(obj: unknown): obj is Record<string, any>;
+export declare function isPromise(obj: any): obj is Promise<any>;
+export declare function isRegExp(obj: any): obj is RegExp;

package/dist/is/type.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRegExp = exports.isPromise = exports.isPlainObject = exports.isObject = exports.isFunction = exports.isArray = exports.isUndefined = exports.isString = void 0;
+function isString(str) {
+    return typeof str === 'string';
+}
+exports.isString = isString;
+function isUndefined(obj) {
+    return typeof obj === 'undefined';
+}
+exports.isUndefined = isUndefined;
+function isArray(obj) {
+    return Array.isArray(obj);
+}
+exports.isArray = isArray;
+// eslint-disable-next-line @typescript-eslint/ban-types
+function isFunction(func) {
+    return typeof func === 'function';
+}
+exports.isFunction = isFunction;
+function isObject(obj) {
+    return obj !== null && typeof obj === 'object';
+}
+exports.isObject = isObject;
+function isPlainObject(obj) {
+    return (isObject(obj) && Object.prototype.toString.call(obj) === '[object Object]');
+}
+exports.isPlainObject = isPlainObject;
+function isPromise(obj) {
+    return (Boolean(obj) &&
+        (typeof obj === 'object' || typeof obj === 'function') &&
+        typeof obj.then === 'function');
+}
+exports.isPromise = isPromise;
+function isRegExp(obj) {
+    return Object.prototype.toString.call(obj) === '[object RegExp]';
+}
+exports.isRegExp = isRegExp;

package/dist/js/modern/monorepo.js

@@ -6,8 +6,7 @@ function _defineProperty(obj, key, value) { if (key in obj) { Object.definePrope
 
 import fs from 'fs';
 import path from 'path';
-import glob from 'glob';
-import yaml from 'yaml';
+import { glob, yaml } from "./compiled";
 const PACKAGE_MAX_DEPTH = 5;
 const WOKRSPACES_FILES = {
   YARN: 'package.json',
@@ -43,7 +42,7 @@ export const findMonorepoRoot = (appDirectory, maxDepth = PACKAGE_MAX_DEPTH) =>
     if (isMonorepo(appDirectory)) {
       inMonorepo = true;
       break;
-    } // eslint-disable-next-line no-param-reassign
+    } // eslint-d isable-next-line no-param-reassign
 
 
     appDirectory = path.dirname(appDirectory);
@@ -67,14 +66,14 @@ export const getMonorepoPackages = root => {
   } else {
     ({
       packages
-    } = yaml.parse(fs.readFileSync(path.join(root, WOKRSPACES_FILES.PNPM), 'utf8')));
+    } = yaml.load(fs.readFileSync(path.join(root, WOKRSPACES_FILES.PNPM), 'utf8')));
   }
 
   if (packages) {
     return packages.map(name => // The trailing / ensures only dirs are picked up
     glob.sync(path.join(root, `${name}/`), {
       ignore: ['**/node_modules/**']
-    })).flat().filter(filepath => fs.existsSync(path.resolve(filepath, 'package.json'))).map(filepath => ({
+    })).reduce((acc, val) => acc.concat(val), []).filter(filepath => fs.existsSync(path.resolve(filepath, 'package.json'))).map(filepath => ({
       path: filepath,
       name: JSON.parse(fs.readFileSync(path.resolve(filepath, 'package.json'), 'utf8')).name
     }));

package/dist/js/node/monorepo.js

@@ -9,9 +9,7 @@ var _fs = _interopRequireDefault(require("fs"));
 
 var _path = _interopRequireDefault(require("path"));
 
-var _glob = _interopRequireDefault(require("glob"));
-
-var _yaml = _interopRequireDefault(require("yaml"));
+var _compiled = require("./compiled");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
@@ -72,7 +70,7 @@ const findMonorepoRoot = (appDirectory, maxDepth = PACKAGE_MAX_DEPTH) => {
     if (isMonorepo(appDirectory)) {
       inMonorepo = true;
       break;
-    } // eslint-disable-next-line no-param-reassign
+    } // eslint-d isable-next-line no-param-reassign
 
 
     appDirectory = _path.default.dirname(appDirectory);
@@ -99,14 +97,14 @@ const getMonorepoPackages = root => {
   } else {
     ({
       packages
-    } = _yaml.default.parse(_fs.default.readFileSync(_path.default.join(root, WOKRSPACES_FILES.PNPM), 'utf8')));
+    } = _compiled.yaml.load(_fs.default.readFileSync(_path.default.join(root, WOKRSPACES_FILES.PNPM), 'utf8')));
   }
 
   if (packages) {
     return packages.map(name => // The trailing / ensures only dirs are picked up
-    _glob.default.sync(_path.default.join(root, `${name}/`), {
+    _compiled.glob.sync(_path.default.join(root, `${name}/`), {
       ignore: ['**/node_modules/**']
-    })).flat().filter(filepath => _fs.default.existsSync(_path.default.resolve(filepath, 'package.json'))).map(filepath => ({
+    })).reduce((acc, val) => acc.concat(val), []).filter(filepath => _fs.default.existsSync(_path.default.resolve(filepath, 'package.json'))).map(filepath => ({
       path: filepath,
       name: JSON.parse(_fs.default.readFileSync(_path.default.resolve(filepath, 'package.json'), 'utf8')).name
     }));

package/dist/js/treeshaking/monorepo.js

@@ -6,8 +6,7 @@ function _defineProperty(obj, key, value) { if (key in obj) { Object.definePrope
 
 import fs from 'fs';
 import path from 'path';
-import glob from 'glob';
-import yaml from 'yaml';
+import { glob, yaml } from "./compiled";
 var PACKAGE_MAX_DEPTH = 5;
 var WOKRSPACES_FILES = {
   YARN: 'package.json',
@@ -50,7 +49,7 @@ export var findMonorepoRoot = function findMonorepoRoot(appDirectory) {
     if (isMonorepo(appDirectory)) {
       inMonorepo = true;
       break;
-    } // eslint-disable-next-line no-param-reassign
+    } // eslint-d isable-next-line no-param-reassign
 
 
     appDirectory = path.dirname(appDirectory);
@@ -69,9 +68,9 @@ export var getMonorepoPackages = function getMonorepoPackages(root) {
 
     packages = _json.packages;
   } else {
-    var _yaml$parse = yaml.parse(fs.readFileSync(path.join(root, WOKRSPACES_FILES.PNPM), 'utf8'));
+    var _ref = yaml.load(fs.readFileSync(path.join(root, WOKRSPACES_FILES.PNPM), 'utf8'));
 
-    packages = _yaml$parse.packages;
+    packages = _ref.packages;
   }
 
   if (packages) {
@@ -81,7 +80,9 @@ export var getMonorepoPackages = function getMonorepoPackages(root) {
           ignore: ['**/node_modules/**']
         })
       );
-    }).flat().filter(function (filepath) {
+    }).reduce(function (acc, val) {
+      return acc.concat(val);
+    }, []).filter(function (filepath) {
       return fs.existsSync(path.resolve(filepath, 'package.json'));
     }).map(function (filepath) {
       return {

package/dist/logger.d.ts

@@ -0,0 +1,63 @@
+import { Color } from '../compiled/chalk';
+declare type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+interface LoggerConfiguration {
+    color?: typeof Color;
+    label?: string;
+    level?: LogLevel;
+}
+interface InstanceConfiguration {
+    displayLabel?: boolean;
+    underlineLabel?: boolean;
+    uppercaseLabel?: boolean;
+}
+interface ConstructorOptions {
+    config?: InstanceConfiguration;
+    types?: Record<string, LoggerConfiguration>;
+}
+declare type LoggerFunction = (message?: number | string | Error, ...args: any[]) => void;
+declare const LOG_TYPES: {
+    error: {
+        color: string;
+        label: string;
+        level: string;
+    };
+    info: {
+        color: string;
+        label: string;
+        level: string;
+    };
+    warn: {
+        color: string;
+        label: string;
+        level: string;
+    };
+    debug: {
+        color: string;
+        label: string;
+        level: string;
+    };
+    log: {
+        level: string;
+    };
+};
+declare class Logger {
+    private readonly logCount;
+    private history;
+    private readonly config;
+    private readonly types;
+    private readonly longestLabel;
+    [key: string]: any;
+    constructor(options?: ConstructorOptions);
+    private retainLog;
+    private _log;
+    private getLongestLabel;
+    private get longestUnderlinedLabel();
+    getRetainedLogs(type: string): string[];
+    clearRetainedLogs(type: string): void;
+}
+declare type LoggerInterface = {
+    [key in keyof typeof LOG_TYPES]: LoggerFunction;
+};
+declare const logger: Logger & LoggerInterface;
+export { logger };
+export type { LoggerInterface };