@modern-js/utils 1.2.0 → 1.3.1

package/tests/prettyInstructions.test.ts

@@ -0,0 +1,139 @@
+import { prettyInstructions } from '../src/prettyInstructions';
+
+const mockNetworkInterfaces = {
+  lo0: [
+    {
+      address: '127.0.0.1',
+      netmask: '255.0.0.0',
+      family: 'IPv4',
+      mac: '00:00:00:00:00:00',
+      internal: true,
+      cidr: '127.0.0.1/8',
+    },
+  ],
+  en5: [
+    {
+      address: 'fe80::aede:48ff:fe00:1122',
+      netmask: 'ffff:ffff:ffff:ffff::',
+      family: 'IPv6',
+      mac: 'ac:de:48:00:11:22',
+      internal: false,
+      cidr: 'fe80::aede:48ff:fe00:1122/64',
+      scopeid: 4,
+    },
+  ],
+  en0: [
+    {
+      address: '11.11.111.11',
+      netmask: '255.255.252.0',
+      family: 'IPv4',
+      mac: '90:9c:4a:cf:11:d2',
+      internal: false,
+      cidr: '10.85.117.60/22',
+    },
+  ],
+  utun2: [
+    {
+      address: '10.100.100.100',
+      netmask: '255.255.224.0',
+      family: 'IPv4',
+      mac: '00:00:00:00:00:00',
+      internal: false,
+      cidr: '10.255.182.172/19',
+    },
+  ],
+};
+
+jest.mock('os', () => {
+  const originalModule = jest.requireActual('os');
+  return {
+    __esModule: true,
+    ...originalModule,
+    default: {
+      networkInterfaces() {
+        return mockNetworkInterfaces;
+      },
+    },
+  };
+});
+
+jest.mock('chalk', () => ({
+  __esModule: true,
+  default: {
+    bold: jest.fn(str => str),
+    green: jest.fn(str => str),
+    red: jest.fn(str => str),
+    yellow: jest.fn(str => str),
+    cyanBright: jest.fn(str => str),
+  },
+}));
+
+describe('prettyInstructions', () => {
+  test('basic usage', () => {
+    const mockAppContext = {
+      entrypoints: [
+        {
+          entryName: 'main',
+          entry: '/example/node_modules/.modern-js/main/index.js',
+          isAutoMount: true,
+          customBootstrap: false,
+        },
+      ],
+      serverRoutes: [
+        {
+          urlPath: '/',
+          entryName: 'main',
+          entryPath: 'html/main/index.html',
+          isSPA: true,
+          isSSR: false,
+          enableModernMode: false,
+        },
+        {
+          urlPath: '/api',
+          isApi: true,
+          entryPath: '',
+          isSPA: false,
+          isSSR: false,
+        },
+      ],
+      port: 8080,
+      existSrc: true,
+    };
+    const mockConfig = {
+      dev: {
+        https: true,
+      },
+    };
+
+    const message = prettyInstructions(mockAppContext, mockConfig);
+
+    expect(message).toMatchSnapshot();
+  });
+
+  test('The src directory does not exist', () => {
+    const mockAppContext = {
+      entrypoints: [],
+      serverRoutes: [
+        {
+          urlPath: '/api',
+          isApi: true,
+          entryPath: '',
+          isSPA: false,
+          isSSR: false,
+        },
+      ],
+      port: 8080,
+      existSrc: false,
+    };
+
+    const mockConfig = {
+      dev: {
+        https: true,
+      },
+    };
+
+    const message = prettyInstructions(mockAppContext, mockConfig);
+
+    expect(message).toMatchSnapshot();
+  });
+});

package/tests/wait.ts

@@ -0,0 +1,38 @@
+import { wait } from '../src/wait';
+
+jest.useRealTimers();
+
+describe('wait', () => {
+  test('basic usage', async () => {
+    const fn1 = jest.fn();
+    const fn2 = jest.fn();
+    const fn3 = async () => {
+      fn1();
+      await wait();
+      fn2();
+    };
+
+    fn3();
+    expect(fn1).toBeCalled();
+    expect(fn2).not.toBeCalled();
+    await wait();
+    expect(fn2).toBeCalled();
+  });
+
+  test('delay', async () => {
+    const fn1 = jest.fn();
+    const fn2 = jest.fn();
+    const time = 100;
+    const fn3 = async () => {
+      fn1();
+      await wait(time);
+      fn2();
+    };
+
+    fn3();
+    expect(fn1).toBeCalled();
+    expect(fn2).not.toBeCalled();
+    await wait(time);
+    expect(fn2).toBeCalled();
+  });
+});

package/src/FileSizeReporter.ts

@@ -1,181 +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)
-'use strict';
-
-import fs from 'fs';
-import path from 'path';
-import chalk from 'chalk';
-import filesize from 'filesize';
-import recursive from 'recursive-readdir';
-import stripAnsi from 'strip-ansi';
-import gzipSize from 'gzip-size';
-import { logger } from './logger';
-
-
-function canReadAsset(asset:string) {
-  return (
-    /\.(js|css)$/.test(asset) &&
-    !/service-worker\.js/.test(asset) &&
-    !/precache-manifest\.[0-9a-f]+\.js/.test(asset)
-  );
-}
-
-// Prints a detailed summary of build files.
-function printFileSizesAfterBuild(
-  webpackStats:any,
-  previousSizeMap:{root:string, sizes:Record<string, number[]>},
-  buildFolder:string,
-  maxBundleGzipSize:number,
-  maxChunkGzipSize:number
-) {
-  var root = previousSizeMap.root;
-  var sizes = previousSizeMap.sizes;
-  var assets = (webpackStats.stats || [webpackStats])
-    .map((stats:any) =>
-      stats
-        .toJson({ all: false, assets: true })
-        .assets.filter((asset:any) => canReadAsset(asset.name))
-        .map((asset:any) => {
-          var fileContents = fs.readFileSync(path.join(root, asset.name));
-          var size = fileContents.length;
-          var gzippedSize = gzipSize.sync(fileContents);
-          var [previousSize, previousGzipSize] = sizes[removeFileNameHash(root, asset.name)] || [];
-          var sizeDifference = getDifferenceLabel(size, previousSize);
-          var gzipSizeDifference = getDifferenceLabel(gzippedSize, previousGzipSize);
-          return {
-            folder: path.join(
-              path.basename(buildFolder),
-              path.dirname(asset.name)
-            ),
-            name: path.basename(asset.name),
-            gzippedSize: gzippedSize,
-            sizeLabel: filesize(size) + (sizeDifference ? ' (' + sizeDifference + ')' : ''),
-            gzipSizeLabel: filesize(gzippedSize) + (gzipSizeDifference ? ' (' + gzipSizeDifference + ')' : ''),
-          };
-        })
-    )
-    .reduce((single:any, all:any) => all.concat(single), []);
-  assets.sort((a:any, b:any) => b.size - a.size);
-  var longestSizeLabelLength = Math.max.apply(
-    null,
-    assets.map((a:any) => stripAnsi(a.sizeLabel).length)
-  );
-  var longestFileNameLength = Math.max.apply(
-    null,
-    assets.map((a:any) => stripAnsi(a.folder + path.sep + a.name).length)
-  );
-
-  printFileSizesHeader(longestFileNameLength, longestSizeLabelLength);
-
-  var suggestBundleSplitting = false;
-  assets.forEach((asset:any) => {
-    var {folder, name, sizeLabel, gzipSizeLabel, gzippedSize} = asset;
-    var fileNameLength = stripAnsi(folder + path.sep + name).length;
-    var sizeLength = stripAnsi(sizeLabel).length;
-    if (sizeLength < longestSizeLabelLength) {
-      var rightPadding = ' '.repeat(longestSizeLabelLength - sizeLength);
-      sizeLabel += rightPadding;
-    }
-    var fileNameLabel = chalk.dim(asset.folder + path.sep) + chalk.cyan(asset.name);
-    if (fileNameLength < longestFileNameLength) {
-      var rightPadding = ' '.repeat(longestFileNameLength - fileNameLength);
-      fileNameLabel += rightPadding;
-    }
-    var isMainBundle = asset.name.indexOf('main.') === 0;
-    var maxRecommendedSize = isMainBundle
-      ? maxBundleGzipSize
-      : maxChunkGzipSize;
-    var isLarge = maxRecommendedSize && gzippedSize > maxRecommendedSize;
-    if (isLarge && path.extname(asset.name) === '.js') {
-      suggestBundleSplitting = true;
-    }
-    logger.log(
-      '  ' + fileNameLabel +
-      '    ' + sizeLabel +
-      '    ' + (isLarge ? chalk.yellow(gzipSizeLabel) : gzipSizeLabel)
-    );
-  });
-  if (suggestBundleSplitting) {
-    logger.log();
-    logger.warn(
-      'The bundle size is significantly larger than recommended.'
-    );
-  }
-}
-
-function printFileSizesHeader(longestFileNameLength:number, longestSizeLabelLength:number){
-  const longestLengths = [longestFileNameLength, longestSizeLabelLength]
-  const headerRow = ['File', 'Size', 'Gzipped'].reduce((prev, cur, index) => {
-    const length = longestLengths[index];
-    let curLabel = cur;
-    if(length){
-      curLabel =  cur.length < length ? cur + ' '.repeat(length - cur.length) : cur;
-    }
-    return prev + curLabel + '    ';
-  }, '  ')
-
-  logger.log(chalk.bold(chalk.blue(headerRow)))
-}
-
-function removeFileNameHash(buildFolder:string, fileName:string) {
-  return fileName
-    .replace(buildFolder, '')
-    .replace(/\\/g, '/')
-    .replace(
-      /\/?(.*)(\.[0-9a-f]+)(\.chunk)?(\.js|\.css)/,
-      (match, p1, p2, p3, p4) => p1 + p4
-    );
-}
-
-// Input: 1024, 2048
-// Output: "(+1 KB)"
-function getDifferenceLabel(currentSize:number, previousSize:number) {
-  var FIFTY_KILOBYTES = 1024 * 50;
-  var difference = currentSize - previousSize;
-  var fileSize = !Number.isNaN(difference) ? filesize(difference) : 0;
-  if (difference >= FIFTY_KILOBYTES) {
-    return chalk.red('+' + fileSize);
-  } else if (difference < FIFTY_KILOBYTES && difference > 0) {
-    return chalk.yellow('+' + fileSize);
-  } else if (difference < 0) {
-    return chalk.green(fileSize);
-  } else {
-    return '';
-  }
-}
-
-function measureFileSizesBeforeBuild(buildFolder:string):Promise<{root:string; sizes: Record<string, number[]>}> {
-  return new Promise(resolve => {
-    recursive(buildFolder, (err, fileNames) => {
-      var sizes;
-      if (!err && fileNames) {
-        sizes = fileNames.filter(canReadAsset).reduce<Record<string, [number,number]>>((memo, fileName) => {
-          var contents = fs.readFileSync(fileName);
-          var key = removeFileNameHash(buildFolder, fileName);
-          // save both the original size and gzip size
-          memo[key] = [contents.length, gzipSize.sync(contents)]
-          return memo;
-        }, {});
-      }
-      resolve({
-        root: buildFolder,
-        sizes: sizes || {},
-      });
-    });
-  });
-}
-
-export {
-  measureFileSizesBeforeBuild,
-  printFileSizesAfterBuild,
-};
-/* eslint-enable */

package/src/alias.ts

@@ -1,90 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import chalk from 'chalk';
-import { readTsConfigByFile } from './readTsConfig';
-import { applyOptionsChain } from './applyOptionsChain';
-
-type AliasOption =
-  | Record<string, string>
-  | ((aliases: Record<string, string>) => Record<string, unknown>)
-  | Record<string, string>
-  | undefined;
-
-interface NormalizedConfig {
-  source: {
-    alias?: AliasOption | Array<AliasOption>;
-  };
-}
-
-interface IAliasConfig {
-  absoluteBaseUrl: string;
-  paths?: Record<string, string | string[]>;
-  isTsPath?: boolean;
-  isTsProject?: boolean;
-}
-
-export const validAlias = <T extends NormalizedConfig>(
-  modernConfig: T,
-  { tsconfigPath }: { tsconfigPath: string },
-) => {
-  const {
-    source: { alias },
-  } = modernConfig;
-  if (!alias) {
-    return null;
-  }
-
-  const isTsProject = fs.existsSync(tsconfigPath);
-  if (!isTsProject) {
-    return null;
-  }
-
-  const userAlias = getUserAlias(alias as Record<string, string>);
-  if (Object.keys(userAlias).length > 0) {
-    return chalk.red(
-      'Note: Please use `compilerOptions.paths` in "tsconfig.json" file replace `source.alias` config in "modern.config.js/ts" when project is typescript',
-    );
-  }
-
-  return null;
-};
-
-export const getAlias = (
-  aliasOption: AliasOption | Array<AliasOption>,
-  option: { appDirectory: string; tsconfigPath: string },
-) => {
-  const isTsProject = fs.existsSync(option.tsconfigPath);
-  let aliasConfig: IAliasConfig;
-  if (!isTsProject) {
-    aliasConfig = {
-      absoluteBaseUrl: option.appDirectory,
-      paths: applyOptionsChain({ '@': ['./src'] }, aliasOption as any),
-      isTsPath: false,
-      isTsProject,
-    };
-  } else {
-    const tsconfig = readTsConfigByFile(option.tsconfigPath);
-    const baseUrl = tsconfig?.compilerOptions?.baseUrl;
-    aliasConfig = {
-      absoluteBaseUrl: baseUrl
-        ? path.join(option.appDirectory, baseUrl)
-        : option.appDirectory,
-      paths: {
-        ...(aliasOption || {}),
-        ...tsconfig?.compilerOptions?.paths,
-      },
-      isTsPath: true,
-      isTsProject,
-    };
-  }
-  return aliasConfig;
-};
-
-// filter invalid ts paths that are not array
-export const getUserAlias = (alias: Record<string, string | string[]> = {}) =>
-  Object.keys(alias).reduce((o, k) => {
-    if (Array.isArray(alias[k])) {
-      o[k] = alias[k];
-    }
-    return o;
-  }, {} as Record<string, string | string[]>);

package/src/applyOptionsChain.ts

@@ -1,44 +0,0 @@
-// eslint-disable-next-line import/no-useless-path-segments
-import { isFunction, logger, isPlainObject } from './index';
-
-export const applyOptionsChain = <T, U>(
-  defaults: T,
-  /* eslint-disable @typescript-eslint/no-invalid-void-type */
-  options?:
-    | T
-    | ((config: T, utils?: U) => T | void)
-    | Array<T | ((config: T, utils?: U) => T | void)>,
-  /* eslint-enable @typescript-eslint/no-invalid-void-type */
-  utils?: U,
-  mergeFn = Object.assign,
-): T => {
-  if (!options) {
-    return defaults;
-  }
-
-  if (isPlainObject(options) as any) {
-    return mergeFn(defaults, options);
-  } else if (isFunction(options)) {
-    const ret = options(defaults, utils);
-    if (ret) {
-      if (!isPlainObject(ret)) {
-        logger.warn(
-          `${options.name}: Function should mutate the config and return nothing, Or return a cloned or merged version of config object.`,
-        );
-      }
-      return ret;
-    }
-  } else if (Array.isArray(options)) {
-    return options.reduce<T>(
-      (memo, cur) => applyOptionsChain(memo, cur, utils, mergeFn),
-      defaults,
-    );
-  } else {
-    throw new Error(
-      `applyOptionsChain error:\ndefault options is: ${JSON.stringify(
-        defaults,
-      )}`,
-    );
-  }
-  return defaults;
-};

package/src/chalk.ts

@@ -1,3 +0,0 @@
-import chalk from 'chalk';
-
-export { chalk };

package/src/clearConsole.ts

@@ -1,5 +0,0 @@
-export const clearConsole = () => {
-  if (process.stdout.isTTY) {
-    process.stdout.write('\x1B[H\x1B[2J');
-  }
-};

package/src/compatRequire.ts

@@ -1,25 +0,0 @@
-import { findExists } from './findExists';
-
-/**
- * Require function compatible with esm and cjs module.
- * @param filePath - File to required.
- * @returns module export object.
- */
-export const compatRequire = (filePath: string) => {
-  const mod = require(filePath);
-
-  return mod?.__esModule ? mod.default : mod;
-};
-
-export const requireExistModule = (
-  filename: string,
-  extensions = ['.ts', '.js'],
-) => {
-  const exist = findExists(extensions.map(ext => `${filename}${ext}`));
-
-  if (!exist) {
-    return null;
-  }
-
-  return compatRequire(exist);
-};