@modern-js/utils 1.2.1 → 1.2.2

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(`localhost`)) {
-        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;
-};

package/src/printBuildError.ts

@@ -1,47 +0,0 @@
-/* eslint-disable eslint-comments/no-unlimited-disable */
-/* eslint-disable */
-/**
- * Copyright (c) 2015-present, Facebook, Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file at
- * https://github.com/facebook/create-react-app/blob/master/LICENSE
- */
-
-// Modified by Chao Xu (xuchaobei)
-
-import chalk from 'chalk';
-import { logger } from './logger';
-
-export function printBuildError(err: Error) {
-  const message = err != null && err.message;
-  const stack = err != null && err.stack;
-
-  // Add more helpful message for Terser error
-  if (
-    stack &&
-    typeof message === 'string' &&
-    message.indexOf('from Terser') !== -1
-  ) {
-    try {
-      const matched = /(.+)\[(.+):(.+),(.+)\]\[.+\]/.exec(stack);
-      if (!matched) {
-        throw new Error('Using errors for control flow is bad.');
-      }
-      const problemPath = matched[2];
-      const line = matched[3];
-      const column = matched[4];
-      logger.error(
-        `Failed to minify the code from this file: \n\n ${chalk.yellow(
-          `\t${problemPath}:${line}${column !== '0' ? ':' + column : ''}`
-        )}\n`
-      );
-    } catch (ignored) {
-      logger.error(`Failed to minify the bundle. ${err}\n`);
-    }
-  } else {
-    logger.error((message || err) + '\n');
-  }
-  logger.log();
-};
-/* eslint-enable */

package/src/readTsConfig.ts

@@ -1,21 +0,0 @@
-import path from 'path';
-
-export const readTsConfig = (root: string) => {
-  // import typescript from 'typescript' cause eslint fromat error.
-  const typescript = require('typescript');
-
-  return typescript.readConfigFile(
-    path.resolve(root, './tsconfig.json'),
-    typescript.sys.readFile,
-  ).config;
-};
-
-export const readTsConfigByFile = (filename: string) => {
-  // import typescript from 'typescript' cause eslint fromat error.
-  const typescript = require('typescript');
-
-  return typescript.readConfigFile(
-    path.resolve(filename),
-    typescript.sys.readFile,
-  ).config;
-};

package/src/removeSlash.ts

@@ -1,6 +0,0 @@
-export const removeLeadingSlash = (s: string): string => s.replace(/^\/+/, '');
-
-export const removeTailSlash = (s: string): string => s.replace(/\/+$/, '');
-
-export const removeSlash = (s: string): string =>
-  removeLeadingSlash(removeTailSlash(s));

package/src/runtimeExports.ts

@@ -1,68 +0,0 @@
-import path from 'path';
-import fs from 'fs-extra';
-import { normalizeOutputPath } from './path';
-
-const memo = <T extends (...args: any[]) => any>(fn: T) => {
-  const cache = new Map();
-
-  return (...params: Parameters<T>): ReturnType<T> => {
-    const stringifiedParams = JSON.stringify(params);
-    const cachedResult = cache.get(stringifiedParams);
-
-    if (cachedResult) {
-      return cachedResult;
-    }
-
-    const res = fn(...params);
-    cache.set(stringifiedParams, res);
-
-    return res;
-  };
-};
-
-export const createRuntimeExportsUtils = memo(
-  (pwd = '', namespace: string, ts = false) => {
-    const entryExportFile = path.join(
-      pwd,
-      `.runtime-exports/${namespace ? `${namespace}.js` : 'index.js'}`,
-    );
-    const entryExportTsFile = path.join(
-      pwd,
-      `.runtime-exports/${namespace ? `${namespace}.d.ts` : 'index.d.ts'}`,
-    );
-
-    // const ensure = () => {
-    //   if (!fs.existsSync(entryExportFile)) {
-    //     fs.outputFileSync(entryExportFile, '');
-    //   }
-    //   fs.ensureFileSync(entryExportFile);
-    // };
-
-    const addExport = (statement: string) => {
-      // eslint-disable-next-line no-param-reassign
-      statement = normalizeOutputPath(statement);
-      try {
-        fs.ensureFileSync(entryExportFile);
-        fs.ensureFileSync(entryExportTsFile);
-
-        if (!fs.readFileSync(entryExportFile, 'utf8').includes(statement)) {
-          fs.appendFileSync(entryExportFile, `${statement}\n`);
-          ts &&
-            fs.appendFileSync(
-              entryExportTsFile,
-              `${statement.replace('.js', '.d')}\n`,
-            );
-        }
-      } catch {
-        // FIXME:
-      }
-    };
-
-    const getPath = () => entryExportFile;
-
-    return {
-      addExport,
-      getPath,
-    };
-  },
-);

package/src/types.d.ts

@@ -1 +0,0 @@
-declare module 'browserslist/node';

package/src/watch.ts

@@ -1,56 +0,0 @@
-import * as path from 'path';
-import { Import } from './import';
-
-const chokidar: typeof import('chokidar') = Import.lazy('chokidar', require);
-
-export type WatchChangeTypeValueT = 'add' | 'unlink' | 'change';
-
-export const WatchChangeType: Record<
-  'ADD' | 'UNLINK' | 'CHANGE',
-  WatchChangeTypeValueT
-> = {
-  ADD: 'add',
-  UNLINK: 'unlink',
-  CHANGE: 'change',
-};
-
-type RunTaskType = (option: {
-  changedFilePath: string;
-  changeType: WatchChangeTypeValueT;
-}) => void | Promise<void>;
-
-export const watch = (
-  watchDir: string | string[],
-  runTask: RunTaskType,
-  ignored: string[] = [],
-) => {
-  let ready = false;
-  const watcher = chokidar.watch(watchDir, {
-    ignored,
-  });
-
-  watcher.on('ready', () => (ready = true));
-
-  watcher.on('change', async filePath => {
-    const changedFilePath = path.resolve(filePath);
-    await runTask({ changedFilePath, changeType: WatchChangeType.CHANGE });
-  });
-
-  watcher.on('add', async filePath => {
-    const changedFilePath = path.resolve(filePath);
-    if (ready) {
-      await runTask({ changedFilePath, changeType: WatchChangeType.ADD });
-    }
-  });
-
-  watcher.on('unlink', async filePath => {
-    const changedFilePath = path.resolve(filePath);
-    await runTask({ changedFilePath, changeType: WatchChangeType.UNLINK });
-  });
-
-  watcher.on('error', err => {
-    throw err;
-  });
-
-  return watcher;
-};