@modern-js/core 1.0.0-alpha.3

package/dist/types/config/index.d.ts

@@ -0,0 +1,125 @@
+import { MetaOptions } from '@modern-js/utils';
+import { PluginConfig } from '../loadPlugins';
+import { defaults } from './defaults';
+import { NormalizedConfig } from './mergeConfig';
+import { PluginValidateSchema } from './schema';
+export { defaults as defaultsConfig };
+export interface SourceConfig {
+  entries?: Record<string, string | {
+    entry: string;
+    enableFileSystemRoutes?: boolean;
+    disableMount?: boolean;
+  }>;
+  disableDefaultEntries?: boolean;
+  entriesDir?: string;
+  configDir?: string;
+  apiDir?: string;
+  envVars?: Array<string>;
+  globalVars?: Record<string, string>;
+  alias?: Record<string, string> | ((aliases: Record<string, string>) => Record<string, unknown>);
+  moduleScopes?: Array<string | RegExp> | ((scopes: Array<string | RegExp>) => Array<string | RegExp>);
+  include?: Array<string | RegExp>;
+}
+export interface OutputConfig {
+  assetPrefix?: string;
+  htmlPath?: string;
+  jsPath?: string;
+  cssPath?: string;
+  mediaPath?: string;
+  path?: string;
+  title?: string;
+  titleByEntries?: Record<string, string>;
+  meta?: MetaOptions;
+  metaByEntries?: Record<string, MetaOptions>;
+  inject?: 'body' | 'head' | boolean;
+  injectByEntries?: Record<string, 'body' | 'head' | boolean>;
+  mountId?: string;
+  favicon?: string;
+  faviconByEntries?: Record<string, string | undefined>;
+  copy?: Record<string, unknown>;
+  scriptExt?: Record<string, unknown>;
+  disableHtmlFolder?: boolean;
+  disableCssModuleExtension?: boolean;
+  disableCssExtract?: boolean;
+  enableCssModuleTSDeclaration?: boolean;
+  disableMinimize?: boolean;
+  enableInlineStyles?: boolean;
+  enableInlineScripts?: boolean;
+  disableSourceMap?: boolean;
+  disableInlineRuntimeChunk?: boolean;
+  disableAssetsCache?: boolean;
+  enableLatestDecorators?: boolean;
+  polyfill?: 'off' | 'usage' | 'entry' | 'ua';
+  dataUriLimit?: number;
+  templateParameters?: Record<string, unknown>;
+  templateParametersByEntries?: Record<string, Record<string, unknown> | undefined>;
+  cssModuleLocalIdentName?: string;
+  enableModernMode?: boolean;
+  federation?: boolean;
+  disableNodePolyfill?: boolean;
+  enableTsLoader?: boolean;
+}
+export interface ServerConfig {
+  routes?: Record<string, string | {
+    route: string | string[];
+    disableSpa?: boolean;
+  }>;
+  publicRoutes?: {
+    [filepath: string]: string;
+  };
+  ssr?: boolean | Record<string, unknown>;
+  ssrByEntries?: Record<string, boolean | Record<string, unknown>>;
+  baseUrl?: string | Array<string>;
+  port?: number;
+  logger?: Record<string, string>;
+  measure?: Record<string, string>;
+}
+export interface DevConfig {
+  assetPrefix?: string | boolean;
+}
+export interface DeployConfig {
+  microFrontend?: {
+    enableHtmlEntry?: boolean;
+  };
+  domain?: string | Array<string>;
+  domainByEntries?: Record<string, string | Array<string>>;
+}
+declare type ConfigFunction = Record<string, unknown> | ((config: Record<string, unknown>) => Record<string, unknown> | void);
+export interface ToolsConfig {
+  webpack?: ConfigFunction;
+  babel?: ConfigFunction;
+  autoprefixer?: ConfigFunction;
+  postcss?: ConfigFunction;
+  lodash?: ConfigFunction;
+  devServer?: Record<string, unknown>;
+  tsLoader?: ConfigFunction;
+  terser?: ConfigFunction;
+  minifyCss?: ConfigFunction;
+  esbuild?: Record<string, unknown>;
+}
+export declare type RuntimeConfig = Record<string, any>;
+export interface RuntimeByEntriesConfig {
+  [name: string]: RuntimeConfig;
+}
+export interface UserConfig {
+  source?: SourceConfig;
+  output?: OutputConfig;
+  server?: ServerConfig;
+  dev?: DevConfig;
+  deploy?: DeployConfig;
+  tools?: ToolsConfig;
+  plugins?: PluginConfig;
+  runtime?: RuntimeConfig;
+  runtimeByEntries?: RuntimeByEntriesConfig;
+}
+export declare type ConfigParam = UserConfig | Promise<UserConfig> | ((env: any) => UserConfig | Promise<UserConfig>);
+export interface LoadedConfig {
+  config: UserConfig;
+  filePath: string | false;
+  dependencies: string[];
+  pkgConfig: UserConfig;
+  jsConfig: UserConfig;
+}
+export declare const defineConfig: (config: ConfigParam) => ConfigParam;
+export declare const loadUserConfig: (appDirectory: string, filePath?: string | undefined) => Promise<LoadedConfig>;
+export declare const resolveConfig: (loaded: LoadedConfig, configs: UserConfig[], schemas: PluginValidateSchema[], isRestart: boolean, argv: string[]) => Promise<NormalizedConfig>;

package/dist/types/config/mergeConfig.d.ts

@@ -0,0 +1,29 @@
+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;
+  _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 declare const mergeConfig: (configs: Array<UserConfig | NormalizedConfig>) => NormalizedConfig;

package/dist/types/config/schema/deploy.d.ts

@@ -0,0 +1,33 @@
+export declare const deploy: {
+  type: string;
+  properties: {
+    microFrontend: {
+      type: string;
+      dependencies: {
+        enableHtmlEntry: {
+          properties: {
+            enableLegacy: {
+              enum: boolean[];
+            };
+          };
+        };
+      };
+      properties: {
+        enableHtmlEntry: {
+          type: string;
+        };
+      };
+    };
+    domain: {
+      type: string[];
+    };
+    domainByEntries: {
+      type: string;
+      patternProperties: {
+        "^[a-zA-Z0-9_-]+$": {
+          type: string[];
+        };
+      };
+    };
+  };
+};

package/dist/types/config/schema/index.d.ts

@@ -0,0 +1,474 @@
+import { JSONSchemaType } from 'ajv';
+export interface PluginValidateSchema {
+  target: string;
+  schema: JSONSchemaType<any>;
+}
+export declare const patchSchema: (pluginSchemas: Array<PluginValidateSchema | PluginValidateSchema[]>) => {
+  type: string;
+  additionalProperties: boolean;
+  properties: {
+    source: {
+      type: string;
+      additionalProperties: boolean;
+      properties: {
+        entries: {
+          type: string;
+          patternProperties: {
+            "^[a-zA-Z0-9_-]+$": {
+              if: {
+                type: string;
+              };
+              then: {
+                required: string[];
+                properties: {
+                  entry: {
+                    type: string[];
+                  };
+                  disableMount: {
+                    type: string;
+                  };
+                  enableFileSystemRoutes: {
+                    type: string;
+                  };
+                };
+                additionalProperties: boolean;
+              };
+              else: {
+                type: string[];
+              };
+            };
+          };
+        };
+        alias: {
+          typeof: string[];
+        };
+        disableDefaultEntries: {
+          type: string;
+        };
+        envVars: {
+          type: string;
+        };
+        globalVars: {
+          type: string;
+        };
+        moduleScopes: {
+          instanceof: string[];
+        };
+        entriesDir: {
+          type: string;
+        };
+        configDir: {
+          type: string;
+        };
+        include: {
+          type: string[];
+        };
+      };
+    };
+    output: {
+      type: string;
+      additionalProperties: boolean;
+      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: string;
+          patternProperties: {
+            "^[a-zA-Z0-9_-]+$": {
+              type: string;
+            };
+          };
+        };
+        title: {
+          type: string;
+        };
+        titleByEntries: {
+          type: string;
+          patternProperties: {
+            "^[a-zA-Z0-9_-]+$": {
+              type: string;
+            };
+          };
+        };
+        meta: {
+          type: string;
+        };
+        metaByEntries: {
+          type: string;
+          patternProperties: {
+            "^[a-zA-Z0-9_-]+$": {
+              type: string;
+            };
+          };
+        };
+        inject: {
+          enum: (string | boolean)[];
+        };
+        injectByEntries: {
+          type: string;
+          patternProperties: {
+            "^[a-zA-Z0-9_-]+$": {
+              enum: (string | boolean)[];
+            };
+          };
+        };
+        copy: {
+          type: string;
+        };
+        scriptExt: {
+          type: string;
+        };
+        disableHtmlFolder: {
+          type: string;
+        };
+        disableCssModuleExtension: {
+          type: string;
+        };
+        disableCssExtract: {
+          type: string;
+        };
+        enableCssModuleTSDeclaration: {
+          type: string;
+        };
+        disableMinimize: {
+          type: string;
+        };
+        enableInlineStyles: {
+          type: string;
+        };
+        enableInlineScripts: {
+          type: string;
+        };
+        disableSourceMap: {
+          type: string;
+        };
+        disableInlineRuntimeChunk: {
+          type: string;
+        };
+        disableAssetsCache: {
+          type: string;
+        };
+        enableLatestDecorators: {
+          type: string;
+        };
+        enableUsageBuiltIns: {
+          type: string;
+        };
+        enableTsLoader: {
+          type: string;
+        };
+        dataUriLimit: {
+          type: string;
+        };
+        templateParameters: {
+          type: string;
+        };
+        templateParametersByEntries: {
+          type: string;
+          patternProperties: {
+            "^[a-zA-Z0-9_-]+$": {
+              type: string;
+            };
+          };
+        };
+        polyfill: {
+          type: string;
+          enum: string[];
+        };
+        cssModuleLocalIdentName: {
+          type: string;
+        };
+        federation: {
+          type: string;
+        };
+        disableNodePolyfill: {
+          type: string;
+        };
+        enableModernMode: {
+          type: string;
+        };
+      };
+    };
+    server: {
+      type: string;
+      additionalProperties: boolean;
+      properties: {
+        port: {
+          type: string;
+        };
+        ssr: {
+          if: {
+            type: string;
+          };
+          then: {
+            properties: {
+              disableLoadable: {
+                type: string;
+              };
+              disableHelmet: {
+                type: string;
+              };
+              disableRedirect: {
+                type: string;
+              };
+              enableAsyncData: {
+                type: string;
+              };
+              enableProductWarning: {
+                type: string;
+              };
+              timeout: {
+                type: string;
+              };
+              asyncDataTimeout: {
+                type: string;
+              };
+            };
+          };
+          else: {
+            type: string;
+          };
+        };
+        ssrByEntries: {
+          type: string;
+          patternProperties: {
+            "^[a-zA-Z0-9_-]+$": {
+              if: {
+                type: string;
+              };
+              then: {
+                properties: {
+                  disableLoadable: {
+                    type: string;
+                  };
+                  disableHelmet: {
+                    type: string;
+                  };
+                  disableRedirect: {
+                    type: string;
+                  };
+                  enableProductWarning: {
+                    type: string;
+                  };
+                  enableAsyncData: {
+                    type: string;
+                  };
+                  timeout: {
+                    type: string;
+                  };
+                  asyncDataTimeout: {
+                    type: string;
+                  };
+                };
+                additionalProperties: boolean;
+              };
+              else: {
+                type: string;
+              };
+            };
+          };
+        };
+        routes: {
+          type: string;
+          patternProperties: {
+            "^[a-zA-Z0-9_-]+$": {
+              if: {
+                type: string;
+              };
+              then: {
+                properties: {
+                  route: {
+                    oneOf: ({
+                      type: string;
+                      properties: {
+                        path: {
+                          type: string;
+                        };
+                        headers: {
+                          type: string;
+                        };
+                      };
+                      additionalProperties: boolean;
+                    } | {
+                      type: string;
+                      items?: undefined;
+                    } | {
+                      type: string;
+                      items: {
+                        oneOf: ({
+                          type: string;
+                          properties: {
+                            path: {
+                              type: string;
+                            };
+                            headers: {
+                              type: string;
+                            };
+                          };
+                          additionalProperties: boolean;
+                        } | {
+                          type: string;
+                        })[];
+                      };
+                    })[];
+                  };
+                  disableSpa: {
+                    type: string;
+                  };
+                };
+                additionalProperties: boolean;
+              };
+              else: {
+                oneOf: ({
+                  type: string;
+                  items?: undefined;
+                } | {
+                  type: string;
+                  items: {
+                    type: string;
+                  };
+                })[];
+              };
+            };
+          };
+        };
+        publicRoutes: {
+          type: string;
+          patternProperties: {
+            "^[a-zA-Z0-9_-]+$": {
+              type: string[];
+            };
+          };
+        };
+        baseUrl: {
+          oneOf: ({
+            type: string;
+            items?: undefined;
+          } | {
+            type: string;
+            items: {
+              type: string;
+            }[];
+          })[];
+        };
+        middleware: {
+          instanceof: string[];
+        };
+        renderHook: {
+          instanceof: string;
+        };
+        logger: {
+          type: string;
+        };
+        measure: {
+          type: string;
+        };
+        proxy: {
+          type: string;
+        };
+      };
+    };
+    deploy: {
+      type: string;
+      properties: {
+        microFrontend: {
+          type: string;
+          dependencies: {
+            enableHtmlEntry: {
+              properties: {
+                enableLegacy: {
+                  enum: boolean[];
+                };
+              };
+            };
+          };
+          properties: {
+            enableHtmlEntry: {
+              type: string;
+            };
+          };
+        };
+        domain: {
+          type: string[];
+        };
+        domainByEntries: {
+          type: string;
+          patternProperties: {
+            "^[a-zA-Z0-9_-]+$": {
+              type: string[];
+            };
+          };
+        };
+      };
+    };
+    plugins: {
+      type: string;
+      additionalProperties: boolean;
+    };
+    dev: {
+      type: string;
+      properties: {
+        assetPrefix: {
+          type: string[];
+        };
+      };
+      additionalProperties: boolean;
+    };
+    tools: {
+      type: string;
+      additionalProperties: boolean;
+      properties: {
+        webpack: {
+          typeof: string[];
+        };
+        babel: {
+          typeof: string[];
+        };
+        postcss: {
+          typeof: string[];
+        };
+        lodash: {
+          typeof: string[];
+        };
+        devServer: {
+          type: string;
+        };
+        tsLoader: {
+          typeof: string[];
+        };
+        autoprefixer: {
+          typeof: string[];
+        };
+        terser: {
+          typeof: string[];
+        };
+        minifyCss: {
+          typeof: string[];
+        };
+      };
+    };
+  };
+};
+export declare const traverseSchema: (schema: ReturnType<typeof patchSchema>) => string[];