@modern-js/core 1.7.1 → 1.9.1

package/tests/loadPlugin.test.ts

@@ -1,116 +0,0 @@
-import path from 'path';
-import { CliPlugin } from '../src';
-import { loadPlugins, getAppPlugins } from '../src/loadPlugins';
-
-describe('load plugins', () => {
-  test('getAppPlugins', () => {
-    const appDirectory = path.resolve(
-      __dirname,
-      './fixtures/load-plugin/user-plugins',
-    );
-    const plugins = getAppPlugins(appDirectory, ['foo' as any], {
-      x: {
-        cli: 'x',
-        forced: true,
-      } as any,
-    });
-    expect(plugins).toEqual([{ cli: 'x', forced: true }, 'foo']);
-  });
-
-  test('should load user plugin successfully', () => {
-    const fixture = path.resolve(
-      __dirname,
-      './fixtures/load-plugin/user-plugins',
-    );
-
-    const plugins = loadPlugins(fixture, {
-      plugins: [
-        { cli: path.join(fixture, './test-plugin-a.js') },
-        { server: './test-plugin-b' },
-      ],
-    });
-
-    expect(plugins).toEqual([
-      {
-        cli: {
-          name: 'a',
-        },
-      },
-      {
-        server: './test-plugin-b',
-        serverPkg: './test-plugin-b',
-      },
-    ]);
-  });
-
-  test('should pass options to Plugin', () => {
-    const fixture = path.resolve(
-      __dirname,
-      './fixtures/load-plugin/user-plugins',
-    );
-
-    const plugins = loadPlugins(fixture, {
-      plugins: [{ cli: ['./test-plugin-c', 'c'] }, ['./test-plugin-c', 'c2']],
-    });
-
-    expect(plugins[0].cli!.name).toEqual('c');
-    expect(plugins[1].cli!.name).toEqual('c2');
-  });
-
-  test('should load user string plugin successfully', () => {
-    const fixture = path.resolve(
-      __dirname,
-      './fixtures/load-plugin/user-plugins',
-    );
-
-    const plugins = loadPlugins(fixture, {
-      plugins: [path.join(fixture, './test-plugin-a.js') as any],
-    });
-
-    expect(plugins).toEqual([
-      {
-        cli: {
-          name: 'a',
-        },
-      },
-    ]);
-  });
-
-  test(`should throw error when plugin not found `, () => {
-    const fixture = path.resolve(__dirname, './fixtures/load-plugin/not-found');
-
-    expect(() => {
-      loadPlugins(fixture, {
-        plugins: [{ cli: './test-plugin-a' }, { cli: './plugin-b' }],
-      });
-    }).toThrowError(/^Can not find plugin /);
-  });
-
-  test(`should load new plugin array correctly`, () => {
-    const appDirectory = path.resolve(
-      __dirname,
-      './fixtures/load-plugin/user-plugins',
-    );
-    const plugin = (): CliPlugin => ({
-      name: 'foo',
-    });
-    const userConfig = { plugins: [plugin()] };
-    const loadedPlugins = loadPlugins(appDirectory, userConfig);
-
-    expect(loadedPlugins[0].cli?.name).toEqual('foo');
-  });
-
-  test(`should load new plugin object correctly`, () => {
-    const appDirectory = path.resolve(
-      __dirname,
-      './fixtures/load-plugin/user-plugins',
-    );
-    const plugin = (): CliPlugin => ({
-      name: 'foo',
-    });
-    const userConfig = { plugins: { cli: [plugin()] } };
-    const loadedPlugins = loadPlugins(appDirectory, userConfig);
-
-    expect(loadedPlugins[0].cli?.name).toEqual('foo');
-  });
-});

package/tests/mergeConfig.test.ts

@@ -1,97 +0,0 @@
-import { mergeConfig } from '../src/config/mergeConfig';
-
-describe('load plugins', () => {
-  test('should replace property deeply', () => {
-    expect(
-      mergeConfig([
-        {
-          source: { disableDefaultEntries: false },
-          output: { polyfill: 'usage' },
-        },
-        {
-          source: { disableDefaultEntries: true },
-          output: { polyfill: 'entry' },
-        },
-      ]),
-    ).toEqual({
-      source: { disableDefaultEntries: true },
-      output: { polyfill: 'entry' },
-    });
-  });
-
-  test(`should set value when property value is not undefined `, () => {
-    expect(
-      mergeConfig([
-        { source: { entries: { app: './App.tsx' } } },
-        { source: { entries: { app2: './src/App2.tsx' } } },
-        { server: { baseUrl: './a' } },
-      ]),
-    ).toEqual({
-      source: {
-        entries: {
-          app: './App.tsx',
-          app2: './src/App2.tsx',
-        },
-      },
-      server: { baseUrl: './a' },
-    });
-  });
-
-  test(`should ignore undefined property`, () => {
-    const config = mergeConfig([
-      { source: { entries: { app: './App.tsx' } } },
-      { source: { entries: undefined } },
-      { tools: { webpack: () => ({}) } },
-      { tools: { webpack: undefined } },
-    ]);
-    expect(config.source).toEqual({
-      entries: {
-        app: './App.tsx',
-      },
-    });
-    expect(Array.isArray(config.tools.webpack)).toBe(true);
-    expect(config.tools.webpack?.length).toBe(1);
-  });
-
-  test(`should merge array value`, () => {
-    expect(
-      mergeConfig([
-        { source: { envVars: ['a', 'b'] } },
-        { source: { globalVars: { A: '1' } } },
-        {
-          source: {
-            disableDefaultEntries: true,
-            envVars: ['c', 'd'],
-            globalVars: { B: '2' },
-          },
-        },
-      ]),
-    ).toEqual({
-      source: {
-        disableDefaultEntries: true,
-        envVars: ['a', 'b', 'c', 'd'],
-        globalVars: {
-          A: '1',
-          B: '2',
-        },
-      },
-    });
-  });
-
-  test(`should merge function and object value`, () => {
-    const config = mergeConfig([
-      { source: { alias: { a: 'b' } } },
-      { source: { alias: () => ({ c: 'd' }) } },
-      { tools: { webpack: () => ({}) } },
-      { tools: { webpack: { name: 'test' } } },
-      { tools: { webpack: () => ({}) } },
-    ]);
-    expect(Array.isArray(config.source.alias)).toBe(true);
-    expect(config?.source?.alias?.length).toBe(2);
-    expect(typeof (config.source.alias as Array<any>)[1]).toBe('function');
-    expect(Array.isArray(config.tools.webpack)).toBe(true);
-    expect(config.tools.webpack?.length).toBe(3);
-    expect(typeof (config.tools.webpack as Array<any>)[0]).toBe('function');
-    expect(typeof (config.tools.webpack as Array<any>)[2]).toBe('function');
-  });
-});

package/tests/pluginAPI.test.ts

@@ -1,19 +0,0 @@
-import { CliPlugin, manager } from '../src';
-
-describe('pluginAPI', () => {
-  it('api.setAppContext', done => {
-    const plugin = (): CliPlugin => ({
-      setup(api) {
-        api.setAppContext({
-          ...api.useAppContext(),
-          packageName: 'foo',
-        });
-
-        expect(api.useAppContext().packageName).toEqual('foo');
-        done();
-      },
-    });
-
-    manager.clone().usePlugin(plugin).init();
-  });
-});

package/tests/repeatKeyWarning.test.ts

@@ -1,68 +0,0 @@
-import { repeatKeyWarning } from '../src/utils/repeatKeyWarning';
-import { UserConfig } from '../src/config';
-
-jest.spyOn(process, 'exit').mockImplementation();
-
-describe('check repeated keys in user config', () => {
-  test(`should exit with error`, () => {
-    expect(() => {
-      repeatKeyWarning(
-        {
-          type: 'object',
-          properties: {
-            a: {
-              type: 'object',
-              properties: {
-                b: {
-                  type: 'object',
-                  properties: { c: { type: ['boolean', 'object'] } },
-                },
-              },
-            },
-          },
-        },
-        { a: { b: { c: true } } } as UserConfig,
-        { a: { b: { c: false } } } as UserConfig,
-      );
-    }).toThrowError(
-      'The same configuration a.b.c exists in modern.config.js and package.json.',
-    );
-  });
-
-  test(`should exit succcessfully`, () => {
-    expect(
-      repeatKeyWarning(
-        {
-          type: 'object',
-          properties: {
-            a: {
-              type: 'object',
-              properties: { b: { type: 'string' } },
-            },
-          },
-          c: {
-            type: 'object',
-            proeperties: {
-              d: {
-                type: 'object',
-                properties: { e: { type: 'string' } },
-              },
-              f: { type: 'string' },
-            },
-          },
-        },
-        {
-          a: { b: 'name' },
-          c: { d: { e: 's' } },
-        } as UserConfig,
-        {
-          a: {},
-          c: {
-            d: {},
-            f: 'ss',
-          },
-        } as UserConfig,
-      ),
-    ).toBeUndefined();
-  });
-});

package/tests/schema.test.ts

@@ -1,107 +0,0 @@
-import { patchSchema, traverseSchema } from '../src/config/schema';
-
-describe('patch schemas', () => {
-  test('should add schema succcessfully', () => {
-    const schema = patchSchema([
-      {
-        target: 'foo',
-        schema: { type: 'string' },
-      },
-      {
-        target: 'deploy.foo',
-        schema: { type: 'number' },
-      },
-    ]);
-
-    expect(schema.properties).toHaveProperty('foo');
-
-    expect(schema.properties.deploy.properties).toHaveProperty('foo');
-  });
-
-  test('should throw error when node is undefined', () => {
-    expect(() => {
-      patchSchema([
-        {
-          target: 'deploy.a.foo',
-          schema: { type: 'string' },
-        },
-      ]);
-    }).toThrowError(/^add schema deploy\.a error$/);
-  });
-
-  test(`should throw error on empty target property`, () => {
-    expect(() => {
-      patchSchema([
-        {
-          target: '',
-          schema: { type: 'object' },
-        },
-      ]);
-    }).toThrowError('should return target property in plugin schema.');
-  });
-
-  test(`support schema array in one schema`, () => {
-    const schema = patchSchema([
-      [
-        {
-          target: 'foo',
-          schema: { type: 'string' },
-        },
-        {
-          target: 'tools.foo',
-          schema: { type: 'number' },
-        },
-      ],
-      {
-        target: 'bar',
-        schema: { type: 'string' },
-      },
-    ]);
-
-    expect(schema.properties).toHaveProperty('foo');
-    expect(schema.properties).toHaveProperty('bar');
-    expect(schema.properties.tools.properties).toHaveProperty('foo');
-  });
-});
-
-describe(`traverse schema`, () => {
-  test(`should return all avaliable keys of current schema`, () => {
-    const schema = {
-      type: 'object',
-      properties: {
-        source: {
-          type: 'object',
-          properties: { alias: { type: ['object', 'function'] } },
-        },
-        a: {
-          type: 'object',
-          properties: {
-            b: {
-              type: 'object',
-              properties: { c: { type: 'object' } },
-            },
-            d: { type: 'string' },
-          },
-        },
-        runtime: {
-          type: 'object',
-          properties: {
-            router: { type: ['object', 'boolean'] },
-            state: { type: ['object', 'boolean'] },
-          },
-        },
-        runtimeByEntries: { patternProperties: { '^$': { type: 'string' } } },
-        dev: { type: ['function', 'string'] },
-      },
-    };
-    expect(traverseSchema(schema as any)).toEqual([
-      'source.alias',
-      'a.b.c',
-      'a.d',
-      'runtime.router',
-      'runtime.state',
-      'runtimeByEntries',
-      'dev',
-    ]);
-  });
-});

package/tests/tsconfig.json

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

package/tests/utils.test.ts

@@ -1,7 +0,0 @@
-import { program } from '../src/utils/commander';
-
-describe('utils', () => {
-  it('default', () => {
-    expect(program).toBeDefined();
-  });
-});