@modern-js/core 1.3.1 → 1.3.2

package/src/config/mergeConfig.ts

@@ -1,69 +0,0 @@
-import mergeWith from 'lodash.mergewith';
-import { isFunction } from '@modern-js/utils';
-import { UserConfig, SourceConfig, ToolsConfig } from '.';
-
-export interface NormalizedSourceConfig
-  extends Omit<SourceConfig, 'alias' | 'moduleScopes'> {
-  alias: SourceConfig['alias'] | Array<SourceConfig['alias']>;
-  moduleScopes:
-    | SourceConfig['moduleScopes']
-    | Array<SourceConfig['moduleScopes']>;
-}
-
-export interface NormalizedToolsConfig
-  extends Omit<
-    ToolsConfig,
-    | 'webpack'
-    | 'babel'
-    | 'postcss'
-    | 'autoprefixer'
-    | 'lodash'
-    | 'tsLoader'
-    | 'terser'
-    | 'minifyCss'
-    | 'esbuild'
-  > {
-  webpack: ToolsConfig['webpack'] | Array<NonNullable<ToolsConfig['webpack']>>;
-  babel: ToolsConfig['babel'] | Array<NonNullable<ToolsConfig['babel']>>;
-  postcss: ToolsConfig['postcss'] | Array<NonNullable<ToolsConfig['postcss']>>;
-  autoprefixer:
-    | ToolsConfig['autoprefixer']
-    | Array<NonNullable<ToolsConfig['autoprefixer']>>;
-  lodash: ToolsConfig['lodash'] | Array<ToolsConfig['lodash']>;
-  tsLoader:
-    | ToolsConfig['tsLoader']
-    | Array<NonNullable<ToolsConfig['tsLoader']>>;
-  terser: ToolsConfig['terser'] | Array<NonNullable<ToolsConfig['terser']>>;
-  minifyCss:
-    | ToolsConfig['minifyCss']
-    | Array<NonNullable<ToolsConfig['minifyCss']>>;
-  esbuild: ToolsConfig['esbuild'] | Array<NonNullable<ToolsConfig['esbuild']>>;
-}
-export interface NormalizedConfig
-  extends Omit<Required<UserConfig>, 'source' | 'tools'> {
-  source: NormalizedSourceConfig;
-  tools: NormalizedToolsConfig;
-  cliOptions?: Record<string, any>;
-  _raw: UserConfig;
-}
-
-/**
- * merge configuration from  modern.config.js and plugins.
- *
- * @param configs - Configuration from modern.config.ts or plugin's config hook.
- * @returns - normalized user config.
- */
-export const mergeConfig = (
-  configs: Array<UserConfig | NormalizedConfig>,
-): NormalizedConfig =>
-  mergeWith({}, ...configs, (target: any, source: any) => {
-    if (Array.isArray(target) && Array.isArray(source)) {
-      return [...target, ...source];
-    }
-    if (isFunction(source)) {
-      return Array.isArray(target)
-        ? [...target, source]
-        : [target, source].filter(Boolean);
-    }
-    return undefined;
-  });

package/src/config/schema/deploy.ts

@@ -1,17 +0,0 @@
-import { ENTRY_NAME_PATTERN } from '@modern-js/utils';
-
-export const deploy = {
-  type: 'object',
-  properties: {
-    microFrontend: {
-      type: ['boolean', 'object'],
-    },
-    domain: { type: ['array', 'string'] },
-    domainByEntries: {
-      type: 'object',
-      patternProperties: {
-        [ENTRY_NAME_PATTERN]: { type: ['array', 'string'] },
-      },
-    },
-  },
-};

package/src/config/schema/index.ts

@@ -1,116 +0,0 @@
-import { JSONSchemaType } from 'ajv';
-import { isObject, createDebugger } from '@modern-js/utils';
-import cloneDeep from 'lodash.clonedeep';
-import { source } from './source';
-import { output } from './output';
-import { server } from './server';
-import { deploy } from './deploy';
-import { tools } from './tools';
-
-const debug = createDebugger('validate-schema');
-
-const plugins = {
-  type: 'array',
-  additionalProperties: false,
-};
-
-const dev = {
-  type: 'object',
-  properties: {
-    assetPrefix: { type: ['boolean', 'string'] },
-    https: {
-      type: 'boolean',
-    },
-  },
-  additionalProperties: false,
-};
-export interface PluginValidateSchema {
-  target: string;
-  schema: JSONSchemaType<any>;
-}
-
-export const patchSchema = (
-  pluginSchemas: Array<PluginValidateSchema | PluginValidateSchema[]>,
-) => {
-  const finalSchema = cloneDeep({
-    type: 'object',
-    additionalProperties: false,
-    properties: {
-      source,
-      output,
-      server,
-      deploy,
-      plugins,
-      dev,
-      tools,
-    },
-  });
-
-  const findTargetNode = (props: string[]) => {
-    let node = finalSchema.properties;
-
-    for (const prop of props) {
-      node = node[prop as keyof typeof node] as any;
-      if (!node || !isObject(node)) {
-        throw new Error(`add schema ${props.join('.')} error`);
-      }
-      (node as any).properties = (node as any).hasOwnProperty('properties')
-        ? (node as any).properties
-        : {};
-
-      node = (node as any).properties;
-    }
-    return node;
-  };
-
-  const finalPluginSchemas: PluginValidateSchema[] = [];
-  pluginSchemas.forEach(item => {
-    if (Array.isArray(item)) {
-      finalPluginSchemas.push(...item);
-    } else {
-      finalPluginSchemas.push(item);
-    }
-  });
-  for (const { target, schema } of finalPluginSchemas) {
-    if (!target) {
-      throw new Error(`should return target property in plugin schema.`);
-    }
-    const props = target.split('.');
-
-    const mountProperty = props.pop();
-
-    const targetNode = findTargetNode(props);
-
-    if (targetNode.hasOwnProperty(mountProperty!)) {
-      throw new Error(`${target} already exists in current validate schema`);
-    }
-
-    (targetNode as any)[mountProperty as string] = cloneDeep(schema);
-  }
-
-  debug(`final validate schema: %o`, finalSchema);
-
-  return finalSchema;
-};
-
-export const traverseSchema = (schema: ReturnType<typeof patchSchema>) => {
-  const keys: string[] = [];
-
-  const traverse = (
-    { properties }: { properties: any },
-    old: string[] = [],
-  ) => {
-    for (const key of Object.keys(properties)) {
-      const current = [...old, key];
-      if (properties[key].type === 'object' && properties[key].properties) {
-        traverse(properties[key], current);
-      } else {
-        keys.push(current.join('.'));
-      }
-    }
-  };
-
-  traverse(schema);
-
-  return keys;
-};

package/src/config/schema/output.ts

@@ -1,65 +0,0 @@
-import { ENTRY_NAME_PATTERN } from '@modern-js/utils';
-
-export const output = {
-  type: 'object',
-  additionalProperties: false,
-  properties: {
-    assetPrefix: { type: 'string' },
-    path: { type: 'string' },
-    jsPath: { type: 'string' },
-    cssPath: { type: 'string' },
-    htmlPath: { type: 'string' },
-    mediaPath: { type: 'string' },
-    mountId: { type: 'string' },
-    favicon: { type: 'string' },
-    faviconByEntries: {
-      type: 'object',
-      patternProperties: { [ENTRY_NAME_PATTERN]: { type: 'string' } },
-    },
-    title: { type: 'string' },
-    titleByEntries: {
-      type: 'object',
-      patternProperties: { [ENTRY_NAME_PATTERN]: { type: 'string' } },
-    },
-    meta: { type: 'object' },
-    metaByEntries: {
-      type: 'object',
-      patternProperties: { [ENTRY_NAME_PATTERN]: { type: 'object' } },
-    },
-    inject: { enum: [true, 'head', 'body', false] },
-    injectByEntries: {
-      type: 'object',
-      patternProperties: {
-        [ENTRY_NAME_PATTERN]: { enum: [true, 'head', 'body', false] },
-      },
-    },
-    copy: { type: 'array' },
-    scriptExt: { type: 'object' },
-    disableHtmlFolder: { type: 'boolean' },
-    disableCssModuleExtension: { type: 'boolean' },
-    disableCssExtract: { type: 'boolean' },
-    enableCssModuleTSDeclaration: { type: 'boolean' },
-    disableMinimize: { type: 'boolean' },
-    enableInlineStyles: { type: 'boolean' },
-    enableInlineScripts: { type: 'boolean' },
-    disableSourceMap: { type: 'boolean' },
-    disableInlineRuntimeChunk: { type: 'boolean' },
-    disableAssetsCache: { type: 'boolean' },
-    enableLatestDecorators: { type: 'boolean' },
-    enableTsLoader: { type: 'boolean' },
-    dataUriLimit: { type: 'number' },
-    templateParameters: { type: 'object' },
-    templateParametersByEntries: {
-      type: 'object',
-      patternProperties: { [ENTRY_NAME_PATTERN]: { type: 'object' } },
-    },
-    polyfill: {
-      type: 'string',
-      enum: ['usage', 'entry', 'off', 'ua'],
-    },
-    cssModuleLocalIdentName: { type: 'string' },
-    federation: { type: 'object' },
-    disableNodePolyfill: { type: 'boolean' },
-    enableModernMode: { type: 'boolean' },
-  },
-};

package/src/config/schema/server.ts

@@ -1,106 +0,0 @@
-import { ENTRY_NAME_PATTERN } from '@modern-js/utils';
-
-const SERVER_ROUTE_OBJECT = {
-  type: 'object',
-  properties: {
-    path: { type: 'string' },
-    headers: { type: 'object' },
-  },
-  additionalProperties: false,
-};
-
-export const server = {
-  type: 'object',
-  additionalProperties: false,
-  properties: {
-    port: { type: 'number' },
-    ssr: {
-      if: { type: 'object' },
-      then: {
-        properties: {
-          disableLoadable: { type: 'boolean' },
-          disableHelmet: { type: 'boolean' },
-          disableRedirect: { type: 'boolean' },
-          enableAsyncData: { type: 'boolean' },
-          enableProductWarning: { type: 'boolean' },
-          timeout: { type: 'number' },
-          asyncDataTimeout: { type: 'number' },
-        },
-      },
-      else: { type: 'boolean' },
-    },
-    ssrByEntries: {
-      type: 'object',
-      patternProperties: {
-        [ENTRY_NAME_PATTERN]: {
-          if: { type: 'object' },
-          then: {
-            properties: {
-              disableLoadable: { type: 'boolean' },
-              disableHelmet: { type: 'boolean' },
-              disableRedirect: { type: 'boolean' },
-              enableProductWarning: { type: 'boolean' },
-              enableAsyncData: { type: 'boolean' },
-              timeout: { type: 'number' },
-              asyncDataTimeout: { type: 'number' },
-            },
-            additionalProperties: false,
-          },
-          else: { type: 'boolean' },
-        },
-      },
-    },
-    routes: {
-      type: 'object',
-      patternProperties: {
-        [ENTRY_NAME_PATTERN]: {
-          if: { type: 'object' },
-          then: {
-            properties: {
-              route: {
-                oneOf: [
-                  { type: 'string' },
-                  {
-                    type: 'array',
-                    items: { oneOf: [{ type: 'string' }, SERVER_ROUTE_OBJECT] },
-                  },
-                  SERVER_ROUTE_OBJECT,
-                ],
-              },
-              disableSpa: { type: 'boolean' },
-            },
-            additionalProperties: false,
-          },
-          else: {
-            oneOf: [
-              { type: 'string' },
-              {
-                type: 'array',
-                items: { type: 'string' },
-              },
-            ],
-          },
-        },
-      },
-    },
-    publicRoutes: {
-      type: 'object',
-      patternProperties: { [ENTRY_NAME_PATTERN]: { type: ['string'] } },
-    },
-    baseUrl: {
-      oneOf: [
-        { type: 'string' },
-        {
-          type: 'array',
-          items: [{ type: 'string' }],
-        },
-      ],
-    },
-    middleware: { instanceof: ['Array', 'Function'] },
-    renderHook: { instanceof: 'Function' },
-    logger: { type: 'object' },
-    metrics: { type: 'object' },
-    proxy: { type: 'object' },
-    enableMicroFrontendDebug: { type: 'boolean' },
-  },
-};

package/src/config/schema/source.ts

@@ -1,34 +0,0 @@
-import { ENTRY_NAME_PATTERN } from '@modern-js/utils';
-
-export const source = {
-  type: 'object',
-  additionalProperties: false,
-  properties: {
-    entries: {
-      type: 'object',
-      patternProperties: {
-        [ENTRY_NAME_PATTERN]: {
-          if: { type: 'object' },
-          then: {
-            required: ['entry'],
-            properties: {
-              entry: { type: ['string', 'array'] },
-              disableMount: { type: 'boolean' },
-              enableFileSystemRoutes: { type: 'boolean' },
-            },
-            additionalProperties: false,
-          },
-          else: { type: ['string', 'array'] },
-        },
-      },
-    },
-    alias: { typeof: ['object', 'function'] },
-    disableDefaultEntries: { type: 'boolean' },
-    envVars: { type: 'array' },
-    globalVars: { type: 'object' },
-    moduleScopes: { instanceof: ['Array', 'Function'] },
-    entriesDir: { type: 'string' },
-    configDir: { type: 'string' },
-    include: { type: ['array'] },
-  },
-};

package/src/config/schema/tools.ts

@@ -1,15 +0,0 @@
-export const tools = {
-  type: 'object',
-  additionalProperties: false,
-  properties: {
-    webpack: { typeof: ['object', 'function'] },
-    babel: { typeof: ['object', 'function'] },
-    postcss: { typeof: ['object', 'function'] },
-    lodash: { typeof: ['object', 'function'] },
-    devServer: { type: 'object' },
-    tsLoader: { typeof: ['object', 'function'] },
-    autoprefixer: { typeof: ['object', 'function'] },
-    terser: { typeof: ['object', 'function'] },
-    minifyCss: { typeof: ['object', 'function'] },
-  },
-};

package/src/context.ts

@@ -1,46 +0,0 @@
-import path from 'path';
-import { createContext } from '@modern-js/plugin';
-import address from 'address';
-import type { IAppContext } from '@modern-js/types';
-import { UserConfig } from './config';
-import { NormalizedConfig } from './config/mergeConfig';
-
-export type { IAppContext };
-
-export const AppContext = createContext<IAppContext>({} as IAppContext);
-
-export const ConfigContext = createContext<UserConfig>({} as UserConfig);
-
-export const ResolvedConfigContext = createContext<NormalizedConfig>(
-  {} as NormalizedConfig,
-);
-
-export const useAppContext = () => AppContext.use().value;
-
-export const useConfigContext = () => ConfigContext.use().value;
-
-export const useResolvedConfigContext = () => ResolvedConfigContext.use().value;
-
-export const initAppContext = (
-  appDirectory: string,
-  plugins: Array<{
-    cli: any;
-    server: any;
-  }>,
-  configFile: string | false,
-): IAppContext => ({
-  appDirectory,
-  configFile,
-  ip: address.ip(),
-  port: 0,
-  packageName: require(path.resolve(appDirectory, './package.json')).name,
-  srcDirectory: path.resolve(appDirectory, './src'),
-  distDirectory: '',
-  sharedDirectory: path.resolve(appDirectory, './shared'),
-  nodeModulesDirectory: path.resolve(appDirectory, './node_modules'),
-  internalDirectory: path.resolve(appDirectory, './node_modules/.modern-js'),
-  plugins,
-  htmlTemplates: {},
-  serverRoutes: [],
-  entrypoints: [],
-});