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

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

@@ -1,125 +1,49 @@
-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>;
-  enableMicroFrontendDebug?: boolean;
-}
-export interface DevConfig {
-  assetPrefix?: string | boolean;
-  https?: boolean;
-}
-export interface DeployConfig {
-  microFrontend?: boolean | Record<string, unknown>;
-  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>;
+import { PluginConfig } from '../plugin';
+import type { BaseTestingNormalizedConfig, BaseTestingUserConfig } from './testing';
+export type { Jest as JestConfig, BaseTestingUserConfig as TestConfig, } from './testing';
+declare type DropUndefined<T> = T extends undefined ? never : T;
+export declare type UserConfig<Extends extends {
+    hooks?: ExtendHooks;
+    userConfig?: ExtendUserConfig;
+    normalizedConfig?: ExtendNormalizedConfig;
+} = {}, ExtendHooks extends Record<string, any> = {}, ExtendUserConfig extends {
+    testing?: Record<string, any>;
+    [property: string]: any;
+} = {}, ExtendNormalizedConfig extends Record<string, any> = {}> = {
+    testing?: BaseTestingUserConfig<DropUndefined<Extends['userConfig']>['testing']>;
+    plugins?: PluginConfig<any>;
+    /**
+     * auto load plugin that exist in the package.json
+     *
+     * **default: `false`**
+     */
+    autoLoadPlugins?: boolean;
+} & Omit<Extends['userConfig'], 'plugins' | 'testing'>;
+export declare type NormalizedConfig<Extends extends {
+    hooks?: ExtendHooks;
+    userConfig?: ExtendUserConfig;
+    normalizedConfig?: ExtendNormalizedConfig;
+} = {}, ExtendHooks extends Record<string, any> = {}, ExtendUserConfig extends Record<string, any> = {}, ExtendNormalizedConfig extends {
+    testing?: Record<string, any>;
+    [property: string]: any;
+} = {}> = {
+    plugins: PluginConfig<any>;
+    testing: BaseTestingNormalizedConfig<DropUndefined<Extends['normalizedConfig']>['testing']>;
+    /**
+     * auto load plugin that exist in the package.json
+     *
+     * **default: `false`**
+     */
+    autoLoadPlugins: boolean;
+} & Omit<Extends['normalizedConfig'], 'plugins' | 'testing'>;
+export declare type LoadedConfig<Extends extends {
+    hooks?: ExtendHooks;
+    userConfig?: ExtendUserConfig;
+} = {}, ExtendHooks extends {} = {}, ExtendUserConfig extends Record<string, any> = {}> = {
+    config: UserConfig<Extends>;
+    filePath: string | false;
+    dependencies: string[];
+    pkgConfig: UserConfig<Extends>;
+    jsConfig: UserConfig<Extends>;
+};
+export declare type ConfigParams = UserConfig | Promise<UserConfig> | ((env: any) => UserConfig | Promise<UserConfig>);

package/dist/types/config/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,15 @@
+import type { JestConfigTypes, Merge } from '@modern-js/types';
+export declare type Jest = JestConfigTypes.InitialOptions;
+export declare type BaseTestingUserConfig<ExtendTestingUserConfig = {}> = Merge<{
+    /**
+     * Decide which transformer will be used to compile file
+     * Default: babel-jest
+     */
+    transformer?: 'babel-jest' | 'ts-jest';
+    /**
+     * Original jest config
+     * Doc: https://jestjs.io/docs/configuration
+     */
+    jest?: Jest | ((jestConfig: Jest) => Jest);
+}, ExtendTestingUserConfig>;
+export declare type BaseTestingNormalizedConfig<ExtendTestingNormailzedConfig = {}> = BaseTestingUserConfig<ExtendTestingNormailzedConfig>;

package/dist/types/config/testing.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/context.d.ts

@@ -1,14 +1,28 @@
-import type { IAppContext } from '@modern-js/types';
-import { UserConfig } from './config';
-import { NormalizedConfig } from './config/mergeConfig';
-export type { IAppContext };
-export declare const AppContext: import("@modern-js/plugin").Context<IAppContext>;
-export declare const ConfigContext: import("@modern-js/plugin").Context<UserConfig>;
-export declare const ResolvedConfigContext: import("@modern-js/plugin").Context<NormalizedConfig>;
-export declare const useAppContext: () => IAppContext;
-export declare const useConfigContext: () => UserConfig;
-export declare const useResolvedConfigContext: () => NormalizedConfig;
-export declare const initAppContext: (appDirectory: string, plugins: Array<{
-  cli: any;
-  server: any;
-}>, configFile: string | false) => IAppContext;
+import { Entrypoint, InternalPlugins, ServerRoute, HtmlTemplates } from '@modern-js/types';
+import { BuilderInstance } from '@modern-js/builder-shared';
+export declare type ToolsType = 'app-tools' | 'module-tools' | 'doc-tools' | 'monorepo-tools';
+export interface IAppContext {
+    metaName: string;
+    appDirectory: string;
+    configFile: string | false;
+    serverConfigFile: string;
+    serverInternalPlugins: InternalPlugins;
+    ip?: string;
+    port?: number;
+    distDirectory: string;
+    toolsType?: ToolsType;
+    packageName: string;
+    srcDirectory: string;
+    sharedDirectory: string;
+    nodeModulesDirectory: string;
+    internalDirectory: string;
+    plugins: any[];
+    entrypoints: Entrypoint[];
+    checkedEntries: string[];
+    serverRoutes: ServerRoute[];
+    htmlTemplates: HtmlTemplates;
+    apiOnly: boolean;
+    internalDirAlias: string;
+    internalSrcAlias: string;
+    builder?: BuilderInstance;
+}

package/dist/types/context.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/hooks.d.ts

@@ -0,0 +1,44 @@
+import { ParallelWorkflow, AsyncWaterfall, AsyncWorkflow, ToRunners, ToThreads } from '@modern-js/plugin';
+import type { Command } from '@modern-js/utils';
+import type { UserConfig, NormalizedConfig } from './config';
+export declare type BaseHooks<Extends extends {
+    hooks?: ExtendHooks;
+    userConfig?: ExtendUserConfig;
+    normalizedConfig?: ExtendNormalizedConfig;
+}, ExtendHooks extends {} = {}, ExtendUserConfig extends Record<string, any> = {}, ExtendNormalizedConfig extends Record<string, any> = {}> = {
+    config: ParallelWorkflow<void, UserConfig<Extends>>;
+    resolvedConfig: AsyncWaterfall<{
+        resolved: NormalizedConfig<Extends>;
+    }>;
+    validateSchema: ParallelWorkflow<void>;
+    prepare: AsyncWorkflow<void, void>;
+    commands: AsyncWorkflow<{
+        program: Command;
+    }, void>;
+    beforeExit: AsyncWorkflow<void, void>;
+    addRuntimeExports: AsyncWaterfall<void>;
+};
+export declare type CliHooksRunner<Extends extends {
+    hooks?: ExtendHooks;
+    userConfig?: ExtendUserConfig;
+    normalizedConfig?: ExtendNormalizedConfig;
+} = {}, ExtendHooks extends {} = {}, ExtendUserConfig extends Record<string, any> = {}, ExtendNormalizedConfig extends Record<string, any> = {}> = ToRunners<BaseHooks<Extends> & Extends['hooks']>;
+export declare type CliHookCallbacks = ToThreads<BaseHooks<{}>>;
+export interface DevToolData<DevOptions = any> {
+    name: string;
+    subCommands?: string[];
+    menuItem?: {
+        name: string;
+        value: string;
+    };
+    disableRunBuild?: boolean;
+    action: (options: DevOptions, context: {
+        isTsProject?: boolean;
+    }) => void | Promise<void>;
+}
+export interface RegisterBuildPlatformResult {
+    platform: string | string[];
+    build: (currentPlatform: string, context: {
+        isTsProject: boolean;
+    }) => void | Promise<void>;
+}

package/dist/types/hooks.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/index.d.ts

@@ -1,88 +1,10 @@
-import { ParallelWorkflow, AsyncWorkflow, Progresses2Runners } from '@modern-js/plugin';
-import type { Hooks } from '@modern-js/types';
-import { Command } from './utils/commander';
-import { defineConfig, UserConfig, ToolsConfig } from './config';
-import { AppContext, IAppContext, useAppContext, useConfigContext, useResolvedConfigContext } from './context';
-import { NormalizedConfig } from './config/mergeConfig';
-export type { Hooks };
-export { defaultsConfig } from './config';
-export * from '@modern-js/plugin';
-export * from '@modern-js/plugin/node';
-export declare type HooksRunner = Progresses2Runners<{
-  config: ParallelWorkflow<void>;
-  validateSchema: ParallelWorkflow<void>;
-  prepare: AsyncWorkflow<void, void>;
-  commands: AsyncWorkflow<{
-    program: Command;
-  }, void>;
-  watchFiles: ParallelWorkflow<void>;
-  fileChange: AsyncWorkflow<{
-    filename: string;
-  }, void>;
-  beforeExit: AsyncWorkflow<void, void>;
-}>;
-export declare const manager: import("@modern-js/plugin").AsyncManager<Hooks, {
-  config: ParallelWorkflow<void, unknown>;
-  validateSchema: ParallelWorkflow<void, unknown>;
-  prepare: AsyncWorkflow<void, void>;
-  commands: AsyncWorkflow<{
-    program: Command;
-  }, void>;
-  watchFiles: ParallelWorkflow<void, unknown>;
-  fileChange: AsyncWorkflow<{
-    filename: string;
-  }, void>;
-  beforeExit: AsyncWorkflow<void, void>;
-}>;
-export declare const createPlugin: (initializer: import("@modern-js/plugin").AsyncInitializer<Partial<import("@modern-js/plugin").Progresses2Threads<{
-  config: ParallelWorkflow<void, unknown>;
-  validateSchema: ParallelWorkflow<void, unknown>;
-  prepare: AsyncWorkflow<void, void>;
-  commands: AsyncWorkflow<{
-    program: Command;
-  }, void>;
-  watchFiles: ParallelWorkflow<void, unknown>;
-  fileChange: AsyncWorkflow<{
-    filename: string;
-  }, void>;
-  beforeExit: AsyncWorkflow<void, void>;
-} & import("@modern-js/plugin").ClearDraftProgress<Hooks>>>>, options?: import("@modern-js/plugin").PluginOptions | undefined) => import("@modern-js/plugin").AsyncPlugin<Partial<import("@modern-js/plugin").Progresses2Threads<{
-  config: ParallelWorkflow<void, unknown>;
-  validateSchema: ParallelWorkflow<void, unknown>;
-  prepare: AsyncWorkflow<void, void>;
-  commands: AsyncWorkflow<{
-    program: Command;
-  }, void>;
-  watchFiles: ParallelWorkflow<void, unknown>;
-  fileChange: AsyncWorkflow<{
-    filename: string;
-  }, void>;
-  beforeExit: AsyncWorkflow<void, void>;
-} & import("@modern-js/plugin").ClearDraftProgress<Hooks>>>>, registerHook: (newShape: Partial<Hooks>) => void, mountHook: () => Progresses2Runners<{
-  config: ParallelWorkflow<void, unknown>;
-  validateSchema: ParallelWorkflow<void, unknown>;
-  prepare: AsyncWorkflow<void, void>;
-  commands: AsyncWorkflow<{
-    program: Command;
-  }, void>;
-  watchFiles: ParallelWorkflow<void, unknown>;
-  fileChange: AsyncWorkflow<{
-    filename: string;
-  }, void>;
-  beforeExit: AsyncWorkflow<void, void>;
-} & import("@modern-js/plugin").ClearDraftProgress<Hooks>>;
-export declare const usePlugins: (plugins: string[]) => void;
-export { defineConfig, AppContext, useAppContext, useConfigContext, useResolvedConfigContext };
-export type { NormalizedConfig, IAppContext, UserConfig, ToolsConfig };
-export interface CoreOption {
-  dryRun?: boolean;
+import type { JSONSchemaType } from '@modern-js/utils/ajv/json-schema';
+export * from './plugin';
+export * from './config';
+export * from './pluginAPI';
+export * from './hooks';
+export * from './context';
+export interface PluginValidateSchema {
+    target: string;
+    schema: JSONSchemaType<any>;
 }
-export declare const cli: {
-  init: (argv?: string[]) => Promise<{
-    loadedConfig: import("./config").LoadedConfig;
-    appContext: IAppContext;
-    resolved: NormalizedConfig;
-  }>;
-  run: (argv: string[]) => Promise<void>;
-  restart: () => Promise<void>;
-};

package/dist/types/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./plugin"), exports);
+__exportStar(require("./config"), exports);
+__exportStar(require("./pluginAPI"), exports);
+__exportStar(require("./hooks"), exports);
+__exportStar(require("./context"), exports);

package/dist/types/plugin.d.ts

@@ -0,0 +1,26 @@
+import { AsyncSetup, PluginOptions } from '@modern-js/plugin';
+import { BaseHooks } from './hooks';
+import { BasePluginAPI } from './pluginAPI';
+export type { InternalPlugins } from '@modern-js/types';
+/** Plugin options of a cli plugin. */
+export declare type CliPlugin<Extends extends {
+    hooks?: ExtendHooks;
+    userConfig?: ExtendUserConfig;
+    normalizedConfig?: ExtendNormalizedConfig;
+} = {}, ExtendHooks extends Record<string, any> = {}, ExtendUserConfig extends Record<string, any> = {}, ExtendNormalizedConfig extends Record<string, any> = {}> = PluginOptions<BaseHooks<Extends>, AsyncSetup<BaseHooks<Extends> & Extends['hooks'], BasePluginAPI<Extends>>, Extends['hooks']>;
+export declare type PluginItem = string | [string, any];
+/**
+ * @deprecated
+ * Using NewPluginConfig instead.
+ */
+export declare type OldPluginConfig = Array<PluginItem>;
+export declare type NewPluginConfig<PluginTypes extends {
+    hooks?: Record<string, any>;
+    userConfig?: Record<string, any>;
+    normalizedConfig?: Record<string, any>;
+}> = CliPlugin<PluginTypes>[];
+export declare type PluginConfig<PluginTypes extends {
+    hooks?: Record<string, any>;
+    userConfig?: Record<string, any>;
+    normalizedConfig?: Record<string, any>;
+} = {}> = OldPluginConfig | NewPluginConfig<PluginTypes>;

package/dist/types/plugin.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/pluginAPI.d.ts

@@ -0,0 +1,18 @@
+import { CommonAPI } from '@modern-js/plugin';
+import type { setAppContext, useAppContext, useResolvedConfigContext, useConfigContext } from '../context';
+import { BaseHooks } from './hooks';
+export declare type BasePluginAPI<Extends extends {
+    hooks?: ExtendHooks;
+    userConfig?: ExtendUserConfig;
+    normalizedConfig?: ExtendNormalizedConfig;
+}, ExtendHooks extends {} = {}, ExtendUserConfig extends Record<string, any> = {}, ExtendNormalizedConfig extends Record<string, any> = {}> = {
+    setAppContext: typeof setAppContext;
+    useAppContext: typeof useAppContext;
+    useConfigContext: typeof useConfigContext<Extends>;
+    useResolvedConfigContext: typeof useResolvedConfigContext<Extends>;
+};
+/** all apis for cli plugin */
+export declare type PluginAPI<Extends extends {
+    hooks?: ExtendHooks;
+    userConfig?: ExtendUserConfig;
+} = {}, ExtendHooks extends {} = {}, ExtendUserConfig extends Record<string, any> = {}> = BasePluginAPI<Extends> & CommonAPI<BaseHooks<Extends> & Extends['hooks']>;

package/dist/types/pluginAPI.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/commander.d.ts

@@ -0,0 +1,4 @@
+import { program, Command } from '@modern-js/utils';
+export declare function initCommandsMap(): void;
+export type { Command };
+export { program };

package/dist/utils/commander.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.program = exports.initCommandsMap = void 0;
+const utils_1 = require("@modern-js/utils");
+Object.defineProperty(exports, "program", { enumerable: true, get: function () { return utils_1.program; } });
+function initCommandsMap() {
+    if (!utils_1.program.hasOwnProperty('commandsMap')) {
+        Object.defineProperty(utils_1.program, 'commandsMap', {
+            get() {
+                const map = new Map();
+                for (const command of utils_1.program.commands) {
+                    map.set(command._name, command);
+                }
+                return map;
+            },
+            configurable: false,
+        });
+    }
+}
+exports.initCommandsMap = initCommandsMap;

package/dist/utils/mergeConfig.d.ts

@@ -0,0 +1,2 @@
+import { UserConfig, NormalizedConfig } from '../types';
+export declare const mergeConfig: <ExtendConfig extends Record<string, any>>(configs: (UserConfig<ExtendConfig, {}, {}, {}> | NormalizedConfig<ExtendConfig, {}, {}, {}>)[]) => NormalizedConfig<ExtendConfig, {}, {}, {}>;

package/dist/utils/mergeConfig.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeConfig = void 0;
+const lodash_1 = require("@modern-js/utils/lodash");
+const mergeConfig = (configs) => (0, lodash_1.mergeWith)({}, ...configs, (target, source, key) => {
+    // Do not use the following merge logic for source.designSystem and tools.tailwind(css)
+    if (key === 'designSystem' ||
+        (key === 'tailwind' && typeof source === 'object') ||
+        (key === 'tailwindcss' && typeof source === 'object') ||
+        key === 'devServer') {
+        return (0, lodash_1.mergeWith)({}, target !== null && target !== void 0 ? target : {}, source !== null && source !== void 0 ? source : {});
+    }
+    if (Array.isArray(target)) {
+        if (Array.isArray(source)) {
+            return [...target, ...source];
+        }
+        else {
+            return source !== undefined ? [...target, source] : target;
+        }
+    }
+    else if ((0, lodash_1.isFunction)(target) || (0, lodash_1.isFunction)(source)) {
+        if (source === undefined) {
+            return target;
+        }
+        if (target === undefined) {
+            return source;
+        }
+        return [target, source];
+    }
+    return undefined;
+});
+exports.mergeConfig = mergeConfig;

package/dist/utils/repeatKeyWarning.d.ts

@@ -0,0 +1,3 @@
+import { UserConfig } from '../types';
+export declare const deepGet: (obj: any, key: string) => any;
+export declare const repeatKeyWarning: <E extends Record<string, any>>(schema: any, jsConfig: UserConfig<E, {}, {}, {}>, pkgConfig: UserConfig<E, {}, {}, {}>) => void;

package/dist/utils/repeatKeyWarning.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.repeatKeyWarning = exports.deepGet = void 0;
+const traverseSchema_1 = require("../schema/traverseSchema");
+const deepGet = (obj, key) => {
+    for (const p of key.split('.')) {
+        // eslint-disable-next-line no-param-reassign
+        obj = obj ? obj[p] : undefined;
+    }
+    return obj;
+};
+exports.deepGet = deepGet;
+const repeatKeyWarning = (schema, jsConfig, pkgConfig) => {
+    const keys = (0, traverseSchema_1.traverseSchema)(schema);
+    for (const key of keys) {
+        if ((0, exports.deepGet)(jsConfig, key) !== undefined &&
+            (0, exports.deepGet)(pkgConfig, key) !== undefined) {
+            throw new Error(`The same configuration ${key} exists in modern.config.js and package.json.\n Please remove it from package.json.`);
+        }
+    }
+};
+exports.repeatKeyWarning = repeatKeyWarning;