@modern-js/utils 1.3.7 → 1.5.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/{types/getPort.d.ts → getPort.d.ts}

@@ -4,4 +4,4 @@
  * @param tryLimits - Maximum number of retries.
  * @returns Available port number.
  */
-export declare const getPort: (port: string | number, tryLimits?: number) => Promise<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/{types/import.d.ts → import.d.ts}

@@ -1,5 +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;
-};
+    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/{types/index.d.ts → index.d.ts}

@@ -1,5 +1,4 @@
-export * as fs from 'fs-extra';
-export * from './chalk';
+export * from './compiled';
 export * from './format';
 export * from './FileSizeReporter';
 export * from './printBuildError';
@@ -12,7 +11,6 @@ export * from './constants';
 export * from './ensureAbsolutePath';
 export * from './getCacheIdentifier';
 export * from './clearConsole';
-export * from './pkgUp';
 export * from './applyOptionsChain';
 export * from './getBrowserslist';
 export * from './removeSlash';
@@ -30,4 +28,7 @@ export * from './import';
 export * from './watch';
 export * from './nodeEnv';
 export * from './wait';
-export * from './emptyDir';
+export * from './emptyDir';
+export * from './getServerConfig';
+export * from './ssrHelpers';
+export * from './analyzeProject';

package/dist/index.js

@@ -0,0 +1,46 @@
+"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);
+__exportStar(require("./analyzeProject"), exports);

package/dist/{types/is → is}/index.d.ts

@@ -12,7 +12,6 @@ export declare const isDepExists: (appDirectory: string, name: string) => boolea
  * @param root - App directory.
  * @returns Whether to use typescript.
  */
-
 export declare const isTypescript: (root: string) => boolean;
 /**
  * Is Empty object
@@ -20,7 +19,6 @@ export declare const isTypescript: (root: string) => boolean;
  * @param o - Any object.
  * @returns Whether it is empty object.
  */
-
 export declare const isEmpty: (o: Record<string, unknown>) => boolean;
 /**
  * Is SSR project
@@ -28,10 +26,9 @@ export declare const isEmpty: (o: Record<string, unknown>) => boolean;
  * @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';
+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/{types/is → is}/node-env.d.ts

@@ -1,4 +1,4 @@
 export declare const isDev: () => boolean;
 export declare const isProd: () => boolean;
 export declare const isTest: () => boolean;
-export declare const isProdProfile: () => 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/{types/is → is}/type.d.ts

@@ -5,4 +5,4 @@ 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;
+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/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 };

package/dist/logger.js

@@ -0,0 +1,128 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+const chalk_1 = __importDefault(require("../compiled/chalk"));
+const { grey, underline } = chalk_1.default;
+const LOG_TYPES = {
+    error: {
+        color: 'red',
+        label: 'error',
+        level: 'error',
+    },
+    info: {
+        color: 'blue',
+        label: 'info',
+        level: 'info',
+    },
+    warn: {
+        color: 'yellow',
+        label: 'warning',
+        level: 'warn',
+    },
+    debug: {
+        color: 'red',
+        label: 'debug',
+        level: 'debug',
+    },
+    log: { level: 'info' },
+};
+const DEFAULT_CONFIG = {
+    displayLabel: true,
+    underlineLabel: true,
+    uppercaseLabel: false,
+};
+class Logger {
+    constructor(options = {}) {
+        this.logCount = 200;
+        this.history = {};
+        this.config = Object.assign(Object.assign({}, DEFAULT_CONFIG), (options.config || {}));
+        this.types = Object.assign(Object.assign({}, LOG_TYPES), (options.types || {}));
+        this.longestLabel = this.getLongestLabel();
+        Object.keys(this.types).forEach(type => {
+            this[type] = this._log.bind(this, type);
+        });
+    }
+    retainLog(type, message) {
+        if (!this.history[type]) {
+            this.history[type] = [];
+        }
+        this.history[type].push(message);
+        while (this.history[type].length > this.logCount) {
+            this.history[type].shift();
+        }
+    }
+    _log(type, message) {
+        if (message === undefined) {
+            // eslint-disable-next-line no-console
+            console.log();
+            return;
+        }
+        let label = '';
+        let text = '';
+        const logType = this.types[type];
+        if (this.config.displayLabel && logType.label) {
+            label = this.config.uppercaseLabel
+                ? logType.label.toUpperCase()
+                : logType.label;
+            if (this.config.underlineLabel) {
+                label = underline(label).padEnd(this.longestUnderlinedLabel.length + 1);
+            }
+            else {
+                label = label.padEnd(this.longestLabel.length + 1);
+            }
+            label = logType.color ? chalk_1.default[logType.color](label) : label;
+        }
+        if (message instanceof Error) {
+            if (message.stack) {
+                const [name, ...rest] = message.stack.split('\n');
+                text = `${name}\n${grey(rest.join('\n'))}`;
+            }
+            else {
+                text = message.message;
+            }
+        }
+        else {
+            text = `${message}`;
+        }
+        // only retain logs of warn/error level
+        if (logType.level === 'warn' || logType.level === 'error') {
+            // retain log text without label
+            this.retainLog(type, text);
+        }
+        const log = label.length > 0 ? `${label}  ${text}` : text;
+        // eslint-disable-next-line no-console
+        console.log(log);
+    }
+    getLongestLabel() {
+        let longestLabel = '';
+        Object.keys(this.types).forEach(type => {
+            const { label = '' } = this.types[type];
+            if (label.length > longestLabel.length) {
+                longestLabel = label;
+            }
+        });
+        return longestLabel;
+    }
+    get longestUnderlinedLabel() {
+        return underline(this.longestLabel);
+    }
+    getRetainedLogs(type) {
+        return this.history[type] || [];
+    }
+    clearRetainedLogs(type) {
+        if (type) {
+            if (this.history[type]) {
+                this.history[type] = [];
+            }
+        }
+        else {
+            this.history = {};
+        }
+    }
+}
+const logger = new Logger();
+exports.logger = logger;
+logger.Logger = Logger;

package/dist/{types/monorepo.d.ts → monorepo.d.ts}

@@ -6,6 +6,6 @@ export declare const isMonorepo: (root: string) => boolean;
 export declare const isModernjsMonorepo: (root: string) => boolean;
 export declare const findMonorepoRoot: (appDirectory: string, maxDepth?: number) => string | undefined;
 export declare const getMonorepoPackages: (root: string) => {
-  name: string;
-  path: string;
-}[];
+    name: string;
+    path: string;
+}[];