@modern-js/core 0.0.0-windows-202110385642 → 0.0.1-20221226

package/tests/mergeConfig.test.ts

@@ -1,78 +0,0 @@
-import { mergeConfig } from '@/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 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 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: () => ({}) } },
-    ]);
-    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(1);
-  });
-});

package/tests/repeatKeyWarning.test.ts

@@ -1,68 +0,0 @@
-import { repeatKeyWarning } from '@/utils/repeatKeyWarning';
-import { UserConfig } from '@/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,109 +0,0 @@
-import { patchSchema, traverseSchema } from '@/config/schema';
-
-describe('patch schemas', () => {
-  test('should add schema succcessfully', () => {
-    const schema = patchSchema([
-      {
-        target: 'foo',
-        schema: { type: 'string' },
-      },
-      {
-        target: 'deploy.microFrontend.foo',
-        schema: { type: 'number' },
-      },
-    ]);
-
-    expect(schema.properties).toHaveProperty('foo');
-
-    expect(
-      schema.properties.deploy.properties.microFrontend.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,13 +0,0 @@
-{
-  "extends": "@modern-js/tsconfig/base",
-  "compilerOptions": {
-    "declaration": false,
-    "jsx": "preserve",
-    "baseUrl": "./",
-    "isolatedModules": true,
-    "esModuleInterop": true,
-    "paths": {
-      "@/*": ["../src/*"]
-    }
-  }
-}

package/tsconfig.json

@@ -1,14 +0,0 @@
-{
-  "extends": "@modern-js/tsconfig/base",
-  "compilerOptions": {
-    "declaration": false,
-    "jsx": "preserve",
-    "baseUrl": "./",
-    "isolatedModules": true,
-    "esModuleInterop": true,
-    "paths": {
-      "@/*": ["./src/*"]
-    }
-  },
-  "include": ["src"]
-}