@modern-js/utils 1.1.6 → 1.2.2

package/src/getPort.ts

@@ -1,62 +0,0 @@
-import net from 'net';
-import { chalk } from './chalk';
-import { logger } from './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 */
-export const getPort = async (
-  port: string | number,
-  tryLimits = 20,
-): Promise<number> => {
-  if (typeof port === 'string') {
-    port = parseInt(port, 10);
-  }
-
-  const original = port;
-
-  let found = false;
-  let attempts = 0;
-  while (!found && attempts <= tryLimits) {
-    try {
-      await new Promise((resolve, reject) => {
-        const server = net.createServer();
-        server.unref();
-        server.on('error', reject);
-        server.listen(
-          {
-            port,
-            host: '0.0.0.0',
-          },
-          () => {
-            found = true;
-            server.close(resolve);
-          },
-        );
-      });
-    } catch (e: any) {
-      if (e.code !== 'EADDRINUSE') {
-        throw e;
-      }
-      port++;
-      attempts++;
-    }
-  }
-
-  if (port !== original) {
-    logger.info(
-      chalk.red(
-        `Something is already running on port ${original}. ${chalk.yellow(
-          `Use port ${port} instead.`,
-        )}`,
-      ),
-    );
-  }
-
-  return port;
-};
-/* eslint-enable no-param-reassign, @typescript-eslint/no-loop-func */

package/src/import.ts

@@ -1,10 +0,0 @@
-// cover: https://rushstack.io/pages/api/node-core-library.import.lazy/
-const lazy = (moduleName: string, requireFn: (id: string) => unknown): any => {
-  const importLazyLocal: (moduleName: string) => unknown =
-    require('import-lazy')(requireFn);
-  return importLazyLocal(moduleName);
-};
-
-export { lazy as lazyImport };
-
-export const Import = { lazy };

package/src/index.ts

@@ -1,31 +0,0 @@
-export * as fs from 'fs-extra';
-export * from './chalk';
-export * from './formatWebpackMessages';
-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 './pkgUp';
-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';

package/src/is/index.ts

@@ -1,78 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import { isDev } from './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.
- */
-export const isDepExists = (appDirectory: string, name: string): boolean => {
-  const json = require(path.resolve(appDirectory, './package.json'));
-
-  const { dependencies = {}, devDependencies = {} } = json;
-
-  return (
-    dependencies.hasOwnProperty(name) || devDependencies.hasOwnProperty(name)
-  );
-};
-
-/**
- * Is typescript project.
- *
- * @param root - App directory.
- * @returns Whether to use typescript.
- */
-export const isTypescript = (root: string): boolean =>
-  fs.existsSync(path.resolve(root, './tsconfig.json'));
-
-/**
- * Is Empty object
- *
- * @param o - Any object.
- * @returns Whether it is empty object.
- */
-export const isEmpty = (o: Record<string, unknown>) =>
-  Object.entries(o).length === 0 && o.constructor === Object;
-
-/**
- * Is SSR project
- *
- * @param config - User config.
- * @returns Whether to use server side render.
- */
-export const isSSR = (config: any): boolean => {
-  const { server } = config;
-
-  if (server?.ssr) {
-    return true;
-  }
-
-  if (server?.ssrByEntries && !isEmpty(server.ssrByEntries)) {
-    for (const name of Object.keys(server.ssrByEntries)) {
-      if (server.ssrByEntries[name]) {
-        return true;
-      }
-    }
-  }
-
-  return false;
-};
-
-export const isUseSSRBundle = (config: any): boolean => {
-  const { output } = config;
-  if (output?.ssg) {
-    return true;
-  }
-
-  return isSSR(config);
-};
-
-export const isFastRefresh = () =>
-  isDev() && process.env.FAST_REFRESH !== 'false';
-
-export * from './node-env';
-export * from './platform';
-export * from './type';

package/src/is/node-env.ts

@@ -1,9 +0,0 @@
-export const isDev = (): boolean => process.env.NODE_ENV === 'development';
-
-export const isProd = (): boolean => process.env.NODE_ENV === 'production';
-
-export const isTest = () => process.env.NODE_ENV === 'test';
-
-// Variable used for enabling profiling in Production.
-export const isProdProfile = () =>
-  isProd() && process.argv.includes('--profile');

package/src/is/platform.ts

@@ -1,7 +0,0 @@
-export const isNodeJS = (): boolean =>
-  typeof process !== 'undefined' &&
-  process.versions != null &&
-  process.versions.node != null &&
-  (process.versions as any).electron == null;
-
-export const isBrowser = (): boolean => typeof window !== 'undefined';

package/src/is/type.ts

@@ -1,43 +0,0 @@
-export function isString(str: any): str is string {
-  return typeof str === 'string';
-}
-
-export function isUndefined(obj: any): obj is undefined {
-  return typeof obj === 'undefined';
-}
-
-export function isArray(obj: any): obj is any[] {
-  return Object.prototype.toString.call(obj) === '[object Array]';
-}
-
-// eslint-disable-next-line @typescript-eslint/ban-types
-export function isFunction(func: any): func is Function {
-  return typeof func === 'function';
-}
-
-// eslint-disable-next-line @typescript-eslint/ban-types
-export function isObject(obj: any): obj is object {
-  return typeof obj === 'object';
-}
-
-export function isPlainObject(obj: any): obj is Record<string, any> {
-  return (
-    obj &&
-    typeof obj === 'object' &&
-    Object.prototype.toString.call(obj) === '[object Object]'
-  );
-}
-
-export function isPromise(obj: any): obj is Promise<any> {
-  /* eslint-disable promise/prefer-await-to-then */
-  return (
-    Boolean(obj) &&
-    (typeof obj === 'object' || typeof obj === 'function') &&
-    typeof obj.then === 'function'
-  );
-  /* eslint-enable promise/prefer-await-to-then */
-}
-
-export function isRegExp(obj: any): obj is RegExp {
-  return Object.prototype.toString.call(obj) === '[object RegExp]';
-}

package/src/logger.ts

@@ -1,184 +0,0 @@
-import chalk, { Color } from 'chalk';
-
-type LogLevel = 'debug' | 'info' | 'warn' | 'error';
-
-type LogMsg = number | string | 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>;
-}
-
-type LoggerFunction = (
-  message?: number | string | Error,
-  ...args: any[]
-) => void;
-
-const { grey, underline } = chalk;
-
-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 {
-  private readonly logCount: number = 200;
-
-  private history: Partial<Record<string, Array<string>>> = {};
-
-  private readonly config: InstanceConfiguration;
-
-  private readonly types: Record<string, LoggerConfiguration>;
-
-  private readonly longestLabel: string;
-
-  [key: string]: any;
-
-  constructor(options: ConstructorOptions = {}) {
-    this.config = { ...DEFAULT_CONFIG, ...(options.config || {}) };
-    this.types = {
-      ...(LOG_TYPES as Record<string, LoggerConfiguration>),
-      ...(options.types || {}),
-    };
-    this.longestLabel = this.getLongestLabel();
-
-    Object.keys(this.types).forEach(type => {
-      this[type] = this._log.bind(this, type);
-    });
-  }
-
-  private retainLog(type: string, message: string) {
-    if (!this.history[type]) {
-      this.history[type] = [];
-    }
-    this.history[type]!.push(message);
-    while (this.history[type]!.length > this.logCount) {
-      this.history[type]!.shift();
-    }
-  }
-
-  // eslint-disable-next-line max-statements
-  private _log(type: string, message?: LogMsg) {
-    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[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);
-  }
-
-  private getLongestLabel() {
-    let longestLabel = '';
-    Object.keys(this.types).forEach(type => {
-      const { label = '' } = this.types[type];
-      if (label.length > longestLabel.length) {
-        longestLabel = label;
-      }
-    });
-    return longestLabel;
-  }
-
-  private get longestUnderlinedLabel() {
-    return underline(this.longestLabel);
-  }
-
-  getRetainedLogs(type: string) {
-    return this.history[type] || [];
-  }
-
-  clearRetainedLogs(type: string) {
-    if (type) {
-      if (this.history[type]) {
-        this.history[type] = [];
-      }
-    } else {
-      this.history = {};
-    }
-  }
-}
-
-type LoggerInterface = {
-  [key in keyof typeof LOG_TYPES]: LoggerFunction;
-};
-
-const logger = new Logger() as Logger & LoggerInterface;
-
-logger.Logger = Logger;
-
-export { logger };
-export type { LoggerInterface };

package/src/monorepo.ts

@@ -1,106 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import glob from 'glob';
-import yaml from 'yaml';
-
-const PACKAGE_MAX_DEPTH = 5;
-
-const WOKRSPACES_FILES = {
-  YARN: 'package.json',
-  PNPM: 'pnpm-workspaces.yaml',
-  LERNA: 'lerna.json',
-};
-
-export const isLerna = (root: string) =>
-  fs.existsSync(path.join(root, WOKRSPACES_FILES.LERNA));
-
-export const isYarnWorkspaces = (root: string) => {
-  const pkg = path.join(root, WOKRSPACES_FILES.YARN);
-
-  if (!fs.existsSync(pkg)) {
-    return false;
-  }
-
-  const json = JSON.parse(fs.readFileSync(pkg, 'utf8'));
-
-  return Boolean(json.workspaces?.packages);
-};
-
-export const isPnpmWorkspaces = (root: string) =>
-  fs.existsSync(path.join(root, WOKRSPACES_FILES.PNPM));
-
-export const isMonorepo = (root: string) =>
-  isLerna(root) || isYarnWorkspaces(root) || isPnpmWorkspaces(root);
-
-export const isModernjsMonorepo = (root: string) => {
-  const json = JSON.parse(
-    fs.readFileSync(path.join(root, 'package.json'), 'utf8'),
-  );
-
-  const deps = {
-    ...(json.dependencies || {}),
-    ...(json.devDependencies || {}),
-  };
-
-  return Boolean(deps['@modern-js/monorepo-tools']);
-};
-
-export const findMonorepoRoot = (
-  appDirectory: string,
-  maxDepth: number = PACKAGE_MAX_DEPTH,
-) => {
-  let inMonorepo = false;
-
-  for (let depth = 0; depth < maxDepth; depth++) {
-    if (isMonorepo(appDirectory)) {
-      inMonorepo = true;
-      break;
-    }
-    // eslint-disable-next-line no-param-reassign
-    appDirectory = path.dirname(appDirectory);
-  }
-
-  return inMonorepo ? appDirectory : undefined;
-};
-
-export const getMonorepoPackages = (
-  root: string,
-): { name: string; path: string }[] => {
-  let packages: string[] = [];
-
-  if (isYarnWorkspaces(root)) {
-    const json = JSON.parse(
-      fs.readFileSync(path.join(root, 'package.json'), 'utf8'),
-    );
-    ({ packages } = json.workspaces);
-  } else if (isLerna(root)) {
-    const json = JSON.parse(
-      fs.readFileSync(path.resolve(root, 'lerna.json'), 'utf8'),
-    );
-    ({ packages } = json);
-  } else {
-    ({ packages } = yaml.parse(
-      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 => ({
-        path: filepath,
-        name: JSON.parse(
-          fs.readFileSync(path.resolve(filepath, 'package.json'), 'utf8'),
-        ).name,
-      }));
-  }
-
-  return [];
-};

package/src/nodeEnv.ts

@@ -1,28 +0,0 @@
-import execa from 'execa';
-
-export async function canUseNpm() {
-  try {
-    await execa('npm', ['--version'], { env: process.env });
-    return true;
-  } catch (e) {
-    return false;
-  }
-}
-
-export async function canUseYarn() {
-  try {
-    await execa('yarn', ['--version'], { env: process.env });
-    return true;
-  } catch (e) {
-    return false;
-  }
-}
-
-export async function canUsePnpm() {
-  try {
-    await execa('pnpm', ['--version'], { env: process.env });
-    return true;
-  } catch (e) {
-    return false;
-  }
-}

package/src/path.ts

@@ -1,9 +0,0 @@
-import path from 'path';
-import upath from 'upath';
-
-export const isRelativePath = (test: string): boolean =>
-  /^\.\.?($|[\\/])/.test(test);
-
-export const normalizeOutputPath = (s: string) => s.replace(/\\/g, '\\\\');
-export const normalizeToPosixPath = (p: string) =>
-  upath.normalizeSafe(path.normalize(p));

package/src/pkgUp.ts

@@ -1,3 +0,0 @@
-import pkgUp from 'pkg-up';
-
-export { pkgUp };

package/src/prettyInstructions.ts

@@ -1,88 +0,0 @@
-import os from 'os';
-import chalk from 'chalk';
-import { isDev } from './is';
-
-// TODO: type
-interface EntryPoint {
-  entryName: string;
-}
-
-interface ServerRoute {
-  entryName: string;
-  isSSR: boolean;
-  urlPath: string;
-}
-
-// TODO: remove hard code 'main'
-export const isSingleEntry = (entrypoints: EntryPoint[]) =>
-  entrypoints.length === 1 && entrypoints[0].entryName === 'main';
-
-const normalizeUrl = (url: string) => url.replace(/([^:]\/)\/+/g, '$1');
-
-const getAddressUrls = (protocol = 'http', port: number) => {
-  const interfaces = os.networkInterfaces();
-  const ipv4Interfaces: os.NetworkInterfaceInfo[] = [];
-  Object.keys(interfaces).forEach(key => {
-    interfaces[key]!.forEach(detail => {
-      if (detail.family === 'IPv4') {
-        ipv4Interfaces.push(detail);
-      }
-    });
-  });
-
-  return ipv4Interfaces.reduce(
-    (memo: { type: string; url: string }[], detail) => {
-      let type = 'Network:  ';
-      let url = `${protocol}://${detail.address}:${port}`;
-      if (detail.address.includes(`127.0.0.1`)) {
-        type = 'Local:  ';
-        url = `${protocol}://localhost:${port}`;
-      }
-
-      memo.push({ type, url });
-      return memo;
-    },
-    [],
-  );
-};
-
-export const prettyInstructions = (appContext: any, config: any) => {
-  const { entrypoints, serverRoutes, port } = appContext as {
-    entrypoints: EntryPoint[];
-    serverRoutes: ServerRoute[];
-    port: number;
-  };
-
-  const urls = getAddressUrls(
-    config.dev.https && isDev() ? 'https' : 'http',
-    port,
-  );
-
-  const routes = serverRoutes.filter(route => route.entryName);
-
-  let message = 'App running at:\n\n';
-
-  if (isSingleEntry(entrypoints)) {
-    message += urls
-      .map(
-        ({ type, url }) =>
-          `  ${chalk.bold(`> ${type.padEnd(10)}`)}${chalk.cyanBright(
-            normalizeUrl(`${url}/${routes[0].urlPath}`),
-          )}\n`,
-      )
-      .join('');
-  } else {
-    const maxNameLength = Math.max(...routes.map(r => r.entryName.length));
-
-    urls.forEach(({ type, url }) => {
-      message += `  ${chalk.bold(`> ${type}`)}\n`;
-      routes.forEach(({ entryName, urlPath }) => {
-        message += `    ${chalk.yellowBright(
-          entryName.padEnd(maxNameLength + 8),
-        )}${chalk.cyanBright(normalizeUrl(`${url}/${urlPath}`))}\n`;
-      });
-    });
-  }
-
-  return message;
-};