@modern-js/utils 1.3.7 → 1.5.0

package/tests/getBrowserslist.test.ts

@@ -1,32 +0,0 @@
-import path from 'path';
-import { getBrowserslist, defaults } from '../src/getBrowserslist';
-
-describe('get browserslist', () => {
-  const fixture = path.resolve(__dirname, './fixtures/browserlist');
-
-  test(`should load browserslist from package.json`, () => {
-    expect(getBrowserslist(path.join(fixture, 'pkg'))).toEqual([
-      'not IE 11',
-      'maintained node versions',
-    ]);
-  });
-
-  test(`should load browerslist from  .browserslistrc`, () => {
-    expect(getBrowserslist(path.join(fixture, 'dotfile'))).toEqual([
-      'defaults',
-      'not IE 11',
-      'maintained node versions',
-    ]);
-  });
-
-  test(`should load browserslist base on environment`, () => {
-    process.env.NODE_ENV = 'development';
-    expect(getBrowserslist(path.join(fixture, 'develop'))).toEqual([
-      'last 1 chrome version',
-    ]);
-  });
-
-  test(`should return default browserslist config`, () => {
-    expect(getBrowserslist(path.join(fixture))).toEqual(defaults);
-  });
-});

package/tests/getCacheIdentifier.test.ts

@@ -1,37 +0,0 @@
-import { getCacheIdentifier } from '../src/getCacheIdentifier';
-
-describe('get cache identifier', () => {
-  test('should use package name and version', () => {
-    expect(
-      getCacheIdentifier([
-        {
-          name: 'package-a',
-          version: '0.1.0',
-        },
-        {
-          name: 'package-b',
-          version: '1.0.1',
-        },
-      ]),
-    ).toEqual(`test:package-a@0.1.0:package-b@1.0.1`);
-  });
-
-  test(`should return identifier with node environment`, () => {
-    const packages = [
-      {
-        name: 'a',
-        version: '0.1.0',
-      },
-    ];
-
-    process.env.NODE_ENV = 'development';
-    expect(getCacheIdentifier(packages)).toEqual('development:a@0.1.0');
-
-    process.env.NODE_ENV = 'production';
-    expect(getCacheIdentifier(packages)).toEqual('production:a@0.1.0');
-
-    process.env.NODE_ENV = '';
-
-    expect(getCacheIdentifier(packages)).toEqual(`:a@0.1.0`);
-  });
-});

package/tests/getEntryOptions.test.ts

@@ -1,53 +0,0 @@
-import { getEntryOptions } from '../src/getEntryOptions';
-
-describe('get entry options', () => {
-  test('should return default options', () => {
-    expect(getEntryOptions('page-a', 'default value')).toEqual('default value');
-
-    expect(
-      getEntryOptions('page-a', 'default value', { 'page-b': 'a' }),
-    ).toEqual('default value');
-  });
-
-  test(`should return options from optionsByEntries`, () => {
-    expect(
-      getEntryOptions('page-a', 'default value', { 'page-a': 'a' }),
-    ).toEqual('a');
-  });
-
-  test(`should compatible with main entry using packageName as key`, () => {
-    expect(
-      getEntryOptions(
-        'main',
-        'default value',
-        { 'package-name': 'a' },
-        'package-name',
-      ),
-    ).toEqual('a');
-  });
-
-  expect(
-    getEntryOptions(
-      'page-a',
-      { name: 'a' },
-      {
-        'page-a': {
-          name: 'page-a',
-          about: 'b',
-        },
-      },
-    ),
-  ).toEqual({
-    name: 'page-a',
-    about: 'b',
-  });
-
-  expect(
-    getEntryOptions<
-      | {
-          [name: string]: string;
-        }
-      | boolean
-    >('page-a', { name: 'a' }, { 'page-a': false }),
-  ).toEqual(false);
-});

package/tests/index.test.ts

@@ -1,18 +0,0 @@
-import { canUseNpm, canUsePnpm, canUseYarn } from '../src';
-
-jest.setTimeout(40000);
-
-describe('test generator utils', () => {
-  test('test canUseNpm', async () => {
-    const npmAbility = await canUseNpm();
-    expect(typeof npmAbility === 'boolean').toBe(true);
-  });
-  test('test canUsePnpm', async () => {
-    const pnpmAbility = await canUsePnpm();
-    expect(typeof pnpmAbility === 'boolean').toBe(true);
-  });
-  test('test canUseYarn', async () => {
-    const yarnAbility = await canUseYarn();
-    expect(typeof yarnAbility === 'boolean').toBe(true);
-  });
-});

package/tests/is.test.ts

@@ -1,27 +0,0 @@
-import { isEmpty, isFastRefresh } from '../src/is';
-
-describe('validate', () => {
-  it('should validate empty object correctly', () => {
-    expect(isEmpty({})).toBeTruthy();
-    expect(isEmpty({ foo: 'bar' })).toBeFalsy();
-  });
-
-  it('should validate fast refresh correctly', () => {
-    const { NODE_ENV, FAST_REFRESH } = process.env;
-
-    process.env.NODE_ENV = 'development';
-    process.env.FAST_REFRESH = 'true';
-    expect(isFastRefresh()).toBeTruthy();
-
-    process.env.NODE_ENV = 'production';
-    process.env.FAST_REFRESH = 'true';
-    expect(isFastRefresh()).toBeFalsy();
-
-    process.env.NODE_ENV = 'development';
-    process.env.FAST_REFRESH = 'false';
-    expect(isFastRefresh()).toBeFalsy();
-
-    process.env.NODE_ENV = NODE_ENV;
-    process.env.FAST_REFRESH = FAST_REFRESH;
-  });
-});

package/tests/isPlatform.test.ts

@@ -1,19 +0,0 @@
-import { isNodeJS, isBrowser } from '../src/is/platform';
-
-describe('validate platform', () => {
-  it('should validate Node.js correctly', () => {
-    expect(isNodeJS()).toBeTruthy();
-  });
-
-  it('should validate browser correctly', () => {
-    const windowSpy = jest.spyOn(window, 'window', 'get');
-
-    windowSpy.mockImplementation((): any => undefined);
-    expect(isBrowser()).toBeFalsy();
-
-    windowSpy.mockImplementation((): any => global);
-    expect(isBrowser()).toBeTruthy();
-
-    windowSpy.mockRestore();
-  });
-});

package/tests/isType.test.ts

@@ -1,85 +0,0 @@
-import {
-  isArray,
-  isObject,
-  isString,
-  isRegExp,
-  isPromise,
-  isUndefined,
-  isPlainObject,
-} from '../src/is/type';
-
-describe('validate type', () => {
-  it('should validate string correctly', () => {
-    expect(isString('')).toBeTruthy();
-    expect(isString('foo')).toBeTruthy();
-    expect(isString(null)).toBeFalsy();
-    expect(isString(123)).toBeFalsy();
-  });
-
-  it('should validate undefined correctly', () => {
-    expect(isUndefined(undefined)).toBeTruthy();
-    expect(isUndefined(null)).toBeFalsy();
-    expect(isUndefined('')).toBeFalsy();
-    expect(isUndefined(123)).toBeFalsy();
-  });
-
-  it('should validate array correctly', () => {
-    expect(isArray(undefined)).toBeFalsy();
-    expect(isArray(null)).toBeFalsy();
-    expect(isArray('')).toBeFalsy();
-    expect(isArray(123)).toBeFalsy();
-    expect(isArray({})).toBeFalsy();
-    expect(isArray([])).toBeTruthy();
-  });
-
-  it('should validate object correctly', () => {
-    expect(isObject(1)).toBeFalsy();
-    expect(isObject('1')).toBeFalsy();
-    expect(isObject(undefined)).toBeFalsy();
-    expect(isObject(null)).toBeFalsy();
-    // eslint-disable-next-line @typescript-eslint/no-empty-function
-    expect(isObject(() => {})).toBeFalsy();
-    expect(isObject({})).toBeTruthy();
-    expect(isObject([])).toBeTruthy();
-    expect(isObject(/foo/)).toBeTruthy();
-  });
-
-  it('should validate plain object correctly', () => {
-    expect(isPlainObject(1)).toBeFalsy();
-    expect(isPlainObject('1')).toBeFalsy();
-    expect(isPlainObject(undefined)).toBeFalsy();
-    expect(isPlainObject(null)).toBeFalsy();
-    // eslint-disable-next-line @typescript-eslint/no-empty-function
-    expect(isPlainObject(() => {})).toBeFalsy();
-    expect(isPlainObject({})).toBeTruthy();
-    expect(isPlainObject([])).toBeFalsy();
-    expect(isPlainObject(/foo/)).toBeFalsy();
-  });
-
-  it('should validate RegExp correctly', () => {
-    expect(isRegExp(1)).toBeFalsy();
-    expect(isRegExp('1')).toBeFalsy();
-    expect(isRegExp(undefined)).toBeFalsy();
-    expect(isRegExp(null)).toBeFalsy();
-    expect(isRegExp({})).toBeFalsy();
-    expect(isRegExp([])).toBeFalsy();
-    expect(isRegExp(/foo/)).toBeTruthy();
-  });
-
-  it('should validate Promise correctly', () => {
-    expect(isPromise(1)).toBeFalsy();
-    expect(isPromise('1')).toBeFalsy();
-    expect(isPromise(undefined)).toBeFalsy();
-    expect(isPromise(null)).toBeFalsy();
-    expect(isPromise({})).toBeFalsy();
-    expect(isPromise([])).toBeFalsy();
-    expect(isPromise(/foo/)).toBeFalsy();
-    expect(
-      isPromise(
-        new Promise<void>(resolve => {
-          resolve();
-        }),
-      ),
-    ).toBeTruthy();
-  });
-});

package/tests/logger.test.ts

@@ -1,53 +0,0 @@
-import { logger } from '../src/logger';
-
-describe('logger', () => {
-  test('should log', () => {
-    // eslint-disable-next-line no-console
-    console.log = jest.fn();
-
-    logger.log('this is a log message');
-
-    // eslint-disable-next-line no-console
-    expect((console.log as jest.Mock).mock.calls[0][0]).toBe(
-      'this is a log message',
-    );
-
-    logger.info('this is an info message');
-
-    logger.warn('this is a warn message');
-
-    logger.error(new Error('this is an error message'));
-
-    // eslint-disable-next-line no-console
-    expect(console.log as jest.Mock).toHaveBeenCalledTimes(4);
-  });
-
-  test('should create new logger', () => {
-    // eslint-disable-next-line no-console
-    console.log = jest.fn();
-
-    const customLogger = new logger.Logger({
-      config: {
-        displayLabel: true,
-        underlineLabel: false,
-        uppercaseLabel: false,
-      },
-      types: {
-        custom: {
-          color: 'blue',
-          label: 'custom',
-          level: 'info',
-        },
-      },
-    });
-
-    customLogger.custom('custom log');
-
-    const reg = new RegExp(`custom.*custom log$`);
-    // eslint-disable-next-line no-console
-    expect((console.log as jest.Mock).mock.calls[0][0]).toMatch(reg);
-
-    // eslint-disable-next-line no-console
-    expect(console.log as jest.Mock).toHaveBeenCalledTimes(1);
-  });
-});

package/tests/prettyInstructions.test.ts

@@ -1,139 +0,0 @@
-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/removeSlash.test.ts

@@ -1,19 +0,0 @@
-import {
-  removeLeadingSlash,
-  removeSlash,
-  removeTailSlash,
-} from '../src/removeSlash';
-
-describe('remove slash', () => {
-  test(`should remove leading slash`, () => {
-    expect(removeLeadingSlash('///yuck/example//')).toEqual('yuck/example//');
-  });
-
-  test(`should remove tail slash`, () => {
-    expect(removeTailSlash('///yuck/example//')).toEqual('///yuck/example');
-  });
-
-  test(`should remove slash`, () => {
-    expect(removeSlash('///yuck/example//')).toEqual('yuck/example');
-  });
-});

package/tests/tsconfig.json

@@ -1,11 +0,0 @@
-{
-  "extends": "@modern-js/tsconfig/base",
-  "compilerOptions": {
-    "declaration": false,
-    "jsx": "preserve",
-    "baseUrl": "./",
-    "isolatedModules": true,
-    "paths": {},
-    "types": ["node", "jest"]
-  }
-}

package/tests/wait.ts

@@ -1,38 +0,0 @@
-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();
-  });
-});