@modern-js/utils 1.3.8-canary.0 → 1.6.0

package/tests/applyOptionsChain.test.ts

@@ -1,100 +0,0 @@
-import { applyOptionsChain } from '../src/applyOptionsChain';
-
-describe('apply options chain', () => {
-  test(`should return default options`, () => {
-    expect(applyOptionsChain({ default: 'a' })).toEqual({ default: 'a' });
-  });
-
-  test(`should merge default options`, () => {
-    expect(
-      applyOptionsChain(
-        { name: 'a' },
-        {
-          name: 'b',
-          custom: 'c',
-        },
-      ),
-    ).toEqual({
-      name: 'b',
-      custom: 'c',
-    });
-  });
-
-  test(`should support custom merge function`, () => {
-    const merge = (target: any, source: any) => {
-      for (const key in source) {
-        if (target.hasOwnProperty(key)) {
-          target[key] += source[key];
-        } else {
-          target[key] = source[key];
-        }
-      }
-      return target;
-    };
-
-    expect(
-      applyOptionsChain(
-        {
-          a: 1,
-          b: 'b',
-        },
-        {
-          a: 2,
-          b: 'b',
-          c: 'c',
-        },
-        {},
-        merge,
-      ),
-    ).toEqual({
-      a: 3,
-      b: 'bb',
-      c: 'c',
-    });
-  });
-
-  test(`should support funciton or object array`, () => {
-    const defaults = { a: 'a' };
-
-    const options = [
-      { b: 'b' },
-      (o: any, { add }: { add: any }) => {
-        o.c = add(1, 2);
-      },
-      (o: any) => ({
-        ...o,
-        d: 'd',
-      }),
-      { e: 'e' },
-    ];
-    expect(
-      applyOptionsChain(defaults, options as any, {
-        add: (a: any, b: any) => a + b,
-      }),
-    ).toEqual({
-      a: 'a',
-      b: 'b',
-      c: 3,
-      d: 'd',
-      e: 'e',
-    });
-  });
-
-  test(`should throw error`, () => {
-    expect(() => {
-      applyOptionsChain(1, 2);
-    }).toThrow(/^applyOptionsChain error:/);
-  });
-
-  test(`should log warning about function result`, () => {
-    let outputs = '';
-    /* eslint-disable no-console */
-    console.log = jest.fn(input => (outputs += input));
-    /* eslint-enable no-console */
-    applyOptionsChain({ name: 'a' } as any, [() => 111]);
-
-    expect(outputs).toContain(
-      'Function should mutate the config and return nothing, Or return a cloned or merged version of config object.',
-    );
-  });
-});

package/tests/compatRequire.test.ts

@@ -1,32 +0,0 @@
-import path from 'path';
-import { compatRequire, cleanRequireCache } from '../src/compatRequire';
-
-describe('compat require', () => {
-  const fixturePath = path.resolve(__dirname, './fixtures/compat-require');
-
-  test(`should support default property`, () => {
-    expect(compatRequire(path.join(fixturePath, 'esm.js'))).toEqual({
-      name: 'esm',
-    });
-  });
-
-  test(`should support commonjs module`, () => {
-    expect(compatRequire(path.join(fixturePath, 'cjs.js'))).toEqual({
-      name: 'cjs',
-    });
-  });
-
-  test(`should return null`, () => {
-    expect(compatRequire(path.join(fixturePath, 'empty.js'))).toEqual(null);
-  });
-
-  test('should clearn cache after fn', () => {
-    const foo = module.require('./fixtures/compat-require/foo');
-    const requirePath = require.resolve('./fixtures/compat-require/foo.js');
-    expect(foo.name).toBe('foo');
-    expect(require.cache[requirePath]).toBeDefined();
-    cleanRequireCache([requirePath]);
-    jest.resetModules();
-    expect(require.cache[requirePath]).toBeUndefined();
-  });
-});

package/tests/debug.test.ts

@@ -1,25 +0,0 @@
-import { debug } from '../src/compiled';
-import { stripAnsi } from '../src';
-import { createDebugger } from '../src/debug';
-
-describe('debug utility', () => {
-  test('should return file path', () => {
-    const debug1 = createDebugger('test');
-
-    const debug2 = createDebugger('test2');
-
-    debug.enable('modern-js:test2');
-
-    debug.log = (...args) => {
-      // XXX: args[0] 的内容有时候是 '  \x1B[38;5;167;1mmodern-js:test2 \x1B[0m22222' 这种格式
-      expect(stripAnsi(args[0])).toContain('modern-js:test2 22222');
-    };
-
-    debug1('11111');
-    debug2('22222');
-
-    expect(debug2.enabled).toBe(true);
-
-    expect(debug1.enabled).toBe(false);
-  });
-});

package/tests/ensureAbsolutePath.test.ts

@@ -1,16 +0,0 @@
-import path from 'path';
-import { ensureAbsolutePath } from '../src/ensureAbsolutePath';
-
-describe('ensure absolute file path', () => {
-  test('should return filePath directly', () => {
-    expect(
-      path.isAbsolute(ensureAbsolutePath('/a/b', '/a/b/c/d/e.jsx')),
-    ).toBeTruthy();
-  });
-
-  test(`should resolve absolute path`, () => {
-    expect(
-      path.isAbsolute(ensureAbsolutePath('/a/b', 'c/d/e.jsx')),
-    ).toBeTruthy();
-  });
-});

package/tests/findExists.test.ts

@@ -1,22 +0,0 @@
-import path from 'path';
-import { findExists } from '../src/findExists';
-
-describe('find first exists file', () => {
-  const fixturePath = path.resolve(__dirname, './fixtures/file-exists');
-
-  test('should return file path', () => {
-    expect(
-      findExists(
-        ['.js', '.ts', '.ejs', '.mjs'].map(ext =>
-          path.join(fixturePath, `a${ext}`),
-        ),
-      ),
-    ).toEqual(path.join(fixturePath, 'a.ts'));
-  });
-
-  test('should return false when no file exists', () => {
-    expect(
-      findExists(['.jsx'].map(ext => path.join(fixturePath, `a${ext}`))),
-    ).toBe(false);
-  });
-});

package/tests/fixtures/browserlist/develop/package.json

@@ -1,11 +0,0 @@
-{
-  "name": "test-browserlist-develop",
-  "browserslist": {
-    "development": [
-      "last 1 chrome version"
-    ],
-    "production": [
-      "IOS 7"
-    ]
-  }
-}

package/tests/fixtures/browserlist/dotfile/.browserslistrc

@@ -1,3 +0,0 @@
-defaults
-not IE 11
-maintained node versions

package/tests/fixtures/browserlist/pkg/package.json

@@ -1,7 +0,0 @@
-{
-  "name": "test-browserlist-pkg",
-  "browserslist": [
-    "not IE 11",
-    "maintained node versions"
-  ]
-}

package/tests/fixtures/compat-require/cjs.js

@@ -1 +0,0 @@
-module.exports = { name: 'cjs' };

package/tests/fixtures/compat-require/empty.js

@@ -1 +0,0 @@
-module.exports = null;

package/tests/fixtures/compat-require/esm.js

@@ -1,5 +0,0 @@
-Object.defineProperty(exports, '__esModule', { value: true });
-
-const _default = { name: 'esm' };
-
-exports.default = _default;

package/tests/fixtures/compat-require/foo.js

@@ -1,3 +0,0 @@
-module.exports = {
-  name: 'foo',
-};

package/tests/format.test.ts

@@ -1,60 +0,0 @@
-import { formatProxyOptions } from '../src/format';
-
-describe('test format', () => {
-  it('should format correctly use simply options', async () => {
-    const proxy = {
-      '/simple': `http://localhost`,
-    };
-
-    const options = formatProxyOptions(proxy);
-    expect(options).toEqual([
-      {
-        context: '/simple',
-        changeOrigin: true,
-        logLevel: 'warn',
-        target: 'http://localhost',
-      },
-    ]);
-  });
-
-  it('should format correctly use simply options', async () => {
-    const proxy = {
-      '/simple-obj': {
-        target: `http://localhost`,
-      },
-    };
-    const options = formatProxyOptions(proxy);
-    expect(options).toEqual([
-      {
-        context: '/simple-obj',
-        changeOrigin: true,
-        logLevel: 'warn',
-        target: 'http://localhost',
-      },
-    ]);
-  });
-
-  it('should format correctly use simply options', async () => {
-    const proxy = {
-      context: '/context',
-      target: `http://localhost`,
-    };
-    const options = formatProxyOptions(proxy);
-    expect(options).toEqual([
-      { context: '/context', target: 'http://localhost' },
-    ]);
-  });
-
-  it('should format correctly use simply options', async () => {
-    const proxy = [
-      {
-        context: '/array',
-        target: `http://localhost`,
-      },
-    ];
-    const options = formatProxyOptions(proxy);
-    expect(options).toEqual([
-      { context: '/array', target: 'http://localhost' },
-    ]);
-  });
-});

package/tests/generateMetaTags.test.ts

@@ -1,19 +0,0 @@
-import { generateMetaTags } from '../src/generateMetaTags';
-
-describe('generateMetaTags', () => {
-  it('should return empty string when params is empty', () => {
-    expect(generateMetaTags()).toEqual('');
-  });
-
-  it('should generate meta tag correctly', () => {
-    const options = {
-      foo: {
-        name: 'viewport',
-        content: 'width=500, initial-scale=1',
-      },
-    };
-    expect(generateMetaTags(options).trim()).toEqual(
-      '<meta name="viewport" content="width=500, initial-scale=1">',
-    );
-  });
-});

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);
-  });
-});