arui-scripts 14.4.1 → 14.5.0-feat-modules.1

package/build/configs/app-configs/index.d.ts

@@ -1,4 +1,6 @@
 import '../util/register-ts-node';
-import { AppConfigs } from './types';
-declare let config: AppConfigs;
-export default config;
+import { AppConfigs, AppContext, AppContextWithConfigs } from './types';
+export declare const appContext: AppContext;
+export declare const appConfigs: AppConfigs;
+export declare const configs: AppContextWithConfigs;
+export default configs;

package/build/configs/app-configs/index.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.configs = exports.appConfigs = exports.appContext = void 0;
 require("../util/register-ts-node");
 const get_defaults_1 = require("./get-defaults");
 const update_with_env_1 = require("./update-with-env");
@@ -7,10 +8,15 @@ const update_with_package_1 = require("./update-with-package");
 const update_with_presets_1 = require("./update-with-presets");
 const calculate_dependent_config_1 = require("./calculate-dependent-config");
 const update_with_config_file_1 = require("./update-with-config-file");
-let config = (0, get_defaults_1.getDefaults)();
-config = (0, update_with_presets_1.updateWithPresets)(config);
-config = (0, update_with_package_1.updateWithPackage)(config);
-config = (0, update_with_config_file_1.updateWithConfigFile)(config);
-config = (0, update_with_env_1.updateWithEnv)(config);
-config = (0, calculate_dependent_config_1.calculateDependentConfig)(config);
-exports.default = config;
+let tmpConfig = (0, get_defaults_1.getDefaultAppConfig)();
+let tmpContext = (0, get_defaults_1.getDefaultAppContext)();
+tmpConfig = (0, update_with_presets_1.updateWithPresets)(tmpConfig, tmpContext);
+tmpConfig = (0, update_with_package_1.updateWithPackage)(tmpConfig, tmpContext);
+tmpConfig = (0, update_with_config_file_1.updateWithConfigFile)(tmpConfig, tmpContext);
+tmpConfig = (0, update_with_env_1.updateWithEnv)(tmpConfig);
+tmpConfig = (0, calculate_dependent_config_1.calculateDependentConfig)(tmpConfig);
+tmpContext = (0, calculate_dependent_config_1.calculateDependentContext)(tmpConfig, tmpContext);
+exports.appContext = tmpContext;
+exports.appConfigs = tmpConfig;
+exports.configs = Object.assign(Object.assign({}, exports.appConfigs), exports.appContext);
+exports.default = exports.configs;

package/build/configs/app-configs/types.d.ts

@@ -1,43 +1,74 @@
+/**
+ * Конфигурация arui-scripts, которая может быть переопределена приложением
+ */
 export type AppConfigs = {
-    appPackage: any;
-    name: string;
-    version: string;
-    dockerRegistry: string;
-    baseDockerImage: string;
-    cwd: string;
-    appSrc: string;
-    appNodeModules: string;
-    appNodeModulesBin: string;
+    clientServerPort: number;
+    serverPort: number;
+    debug: boolean;
+    devSourceMaps: string;
+    useServerHMR: boolean;
+    presets: string | null;
     buildPath: string;
     assetsPath: string;
     additionalBuildPath: string[];
-    nginxRootPath: string;
-    runFromNonRootUser: boolean;
-    archiveName: string;
-    babelRuntimeVersion: string;
+    statsOutputFilename: string;
     serverEntry: string | string[] | Record<string, string | string[]>;
     serverOutput: string;
     clientPolyfillsEntry: null | string | string[];
     clientEntry: string;
+    dockerRegistry: string;
+    baseDockerImage: string;
+    nginxRootPath: string;
+    runFromNonRootUser: boolean;
+    removeDevDependenciesDuringDockerBuild: boolean;
+    archiveName: string;
     keepPropTypes: boolean;
-    tsconfig: string | null;
-    localNginxConf: string | null;
-    localDockerfile: string | null;
-    localStartScript: string | null;
-    devSourceMaps: string;
     useTscLoader: boolean;
-    useServerHMR: boolean;
     webpack4Compatibility: boolean;
-    useYarn: boolean;
-    clientServerPort: number;
-    serverPort: number;
     installServerSourceMaps: boolean;
-    debug: boolean;
-    overridesPath: string[];
-    statsOutputFilename: string;
-    removeDevDependenciesDuringDockerBuild: boolean;
     componentsTheme: string | undefined;
     keepCssVars: boolean;
+    embeddedModules: {
+        shared?: {
+            [libraryName: string]: string;
+        };
+        exposes?: {
+            [moduleId: string]: EmbeddedModuleConfigBase;
+        };
+    } | null;
+    mfModules: {
+        name?: string;
+        shared: any;
+        exposes?: Record<string, string>;
+    } | null;
+};
+type EmbeddedModuleConfigBase = {
+    entry: string;
+    embeddedConfig?: Record<string, string>;
+    cssPrefix?: false | string;
+};
+export type EmbeddedModuleConfig = EmbeddedModuleConfigBase & {
+    name: string;
+};
+/**
+ * Внутренний контекст arui-scripts
+ */
+export type AppContext = {
+    appPackage: any;
+    name: string;
+    normalizedName: string;
+    version: string;
+    cwd: string;
+    appSrc: string;
+    appNodeModules: string;
+    appNodeModulesBin: string;
+    babelRuntimeVersion: string;
+    useYarn: boolean;
+    tsconfig: string | null;
+    localNginxConf: string | null;
+    localDockerfile: string | null;
+    localStartScript: string | null;
+    overridesPath: string[];
     publicPath: string;
     serverOutputPath: string;
     clientOutputPath: string;
@@ -49,3 +80,6 @@ export type AppConfigs = {
     changelogBugfixesPath: string;
     changelogBreakingChangesPath: string;
 };
+export type AppContextWithConfigs = AppContext & AppConfigs;
+export type PackageSettings = Partial<AppConfigs>;
+export {};

package/build/configs/app-configs/update-with-config-file.d.ts

@@ -1,2 +1,2 @@
-import { AppConfigs } from './types';
-export declare function updateWithConfigFile(config: AppConfigs): AppConfigs;
+import { AppConfigs, AppContext } from './types';
+export declare function updateWithConfigFile(config: AppConfigs, context: AppContext): any;

package/build/configs/app-configs/update-with-config-file.js

@@ -5,20 +5,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.updateWithConfigFile = void 0;
 const path_1 = __importDefault(require("path"));
-const lodash_merge_1 = __importDefault(require("lodash.merge"));
 const resolve_1 = require("../util/resolve");
-const validate_settings_keys_1 = __importDefault(require("./validate-settings-keys"));
-const available_package_settings_1 = require("./available-package-settings");
-function updateWithConfigFile(config) {
-    const appConfigPath = (0, resolve_1.tryResolve)(path_1.default.join(config.cwd, '/arui-scripts.config'));
+const validate_settings_keys_1 = require("./validate-settings-keys");
+function updateWithConfigFile(config, context) {
+    const appConfigPath = (0, resolve_1.tryResolve)(path_1.default.join(context.cwd, '/arui-scripts.config'));
     if (appConfigPath) {
         let appSettings = require(appConfigPath);
         if (appSettings.__esModule) {
             // ts-node импортирует esModules, из них надо вытягивать default именно так
             appSettings = appSettings.default;
         }
-        (0, validate_settings_keys_1.default)(available_package_settings_1.availablePackageSettings, appSettings);
-        config = (0, lodash_merge_1.default)(config, appSettings);
+        (0, validate_settings_keys_1.validateSettingsKeys)(config, appSettings, appConfigPath);
+        return Object.assign(Object.assign({}, config), appSettings);
     }
     return config;
 }

package/build/configs/app-configs/update-with-env.js

@@ -1,12 +1,7 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.updateWithEnv = void 0;
-const lodash_merge_1 = __importDefault(require("lodash.merge"));
-const validate_settings_keys_1 = __importDefault(require("./validate-settings-keys"));
-const available_package_settings_1 = require("./available-package-settings");
+const validate_settings_keys_1 = require("./validate-settings-keys");
 function updateWithEnv(config) {
     if (!process.env.ARUI_SCRIPTS_CONFIG) {
         return config;
@@ -14,8 +9,8 @@ function updateWithEnv(config) {
     try {
         console.warn('Используйте ARUI_SCRIPTS_CONFIG только для отладки');
         const envSettings = JSON.parse(process.env.ARUI_SCRIPTS_CONFIG);
-        (0, validate_settings_keys_1.default)(available_package_settings_1.availablePackageSettings, envSettings);
-        return (0, lodash_merge_1.default)(config, envSettings);
+        (0, validate_settings_keys_1.validateSettingsKeys)(config, envSettings, 'ENV');
+        return Object.assign(Object.assign({}, config), envSettings);
     }
     catch (e) {
         console.error(e);

package/build/configs/app-configs/update-with-package.d.ts

@@ -1,2 +1,2 @@
-import { AppConfigs } from './types';
-export declare function updateWithPackage(config: AppConfigs): any;
+import { AppConfigs, AppContext } from './types';
+export declare function updateWithPackage(config: AppConfigs, context: AppContext): any;

package/build/configs/app-configs/update-with-package.js

@@ -1,15 +1,10 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.updateWithPackage = void 0;
-const lodash_merge_1 = __importDefault(require("lodash.merge"));
-const validate_settings_keys_1 = __importDefault(require("./validate-settings-keys"));
-const available_package_settings_1 = require("./available-package-settings");
-function updateWithPackage(config) {
-    const packageSettings = config.appPackage.aruiScripts || {};
-    (0, validate_settings_keys_1.default)(available_package_settings_1.availablePackageSettings, packageSettings);
-    return (0, lodash_merge_1.default)(config, packageSettings);
+const validate_settings_keys_1 = require("./validate-settings-keys");
+function updateWithPackage(config, context) {
+    const packageSettings = context.appPackage.aruiScripts || {};
+    (0, validate_settings_keys_1.validateSettingsKeys)(config, packageSettings, 'package.json');
+    return Object.assign(Object.assign({}, config), packageSettings);
 }
 exports.updateWithPackage = updateWithPackage;

package/build/configs/app-configs/update-with-presets.d.ts

@@ -1,2 +1,2 @@
-import { AppConfigs } from './types';
-export declare function updateWithPresets(config: AppConfigs): AppConfigs;
+import { AppConfigs, AppContext } from './types';
+export declare function updateWithPresets(config: AppConfigs, context: AppContext): AppConfigs;

package/build/configs/app-configs/update-with-presets.js

@@ -1,33 +1,26 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.updateWithPresets = void 0;
-const lodash_merge_1 = __importDefault(require("lodash.merge"));
 const resolve_1 = require("../util/resolve");
-const validate_settings_keys_1 = __importDefault(require("./validate-settings-keys"));
-const available_package_settings_1 = require("./available-package-settings");
-function updateWithPresets(config) {
-    const packageSettings = config.appPackage.aruiScripts || {};
-    if (!packageSettings.presets) {
+const validate_settings_keys_1 = require("./validate-settings-keys");
+function updateWithPresets(config, context) {
+    if (!config.presets) {
         return config;
     }
-    const presetsConfigPath = (0, resolve_1.tryResolve)(`${packageSettings.presets}/arui-scripts.config`, { paths: [config.cwd] });
-    const presetsOverridesPath = (0, resolve_1.tryResolve)(`${packageSettings.presets}/arui-scripts.overrides`, { paths: [config.cwd] });
+    const presetsConfigPath = (0, resolve_1.tryResolve)(`${config.presets}/arui-scripts.config`, { paths: [context.cwd] });
+    const presetsOverridesPath = (0, resolve_1.tryResolve)(`${config.presets}/arui-scripts.overrides`, { paths: [context.cwd] });
     if (presetsConfigPath) {
         let presetsSettings = require(presetsConfigPath);
         if (presetsSettings.__esModule) {
             // ts-node импортирует esModules, из них надо вытягивать default именно так
             presetsSettings = presetsSettings.default;
         }
-        (0, validate_settings_keys_1.default)(available_package_settings_1.availablePackageSettings, presetsSettings);
-        config = (0, lodash_merge_1.default)(config, presetsSettings);
+        (0, validate_settings_keys_1.validateSettingsKeys)(config, presetsSettings, presetsConfigPath);
+        config = Object.assign(Object.assign({}, config), presetsSettings);
     }
     if (presetsOverridesPath) {
-        config.overridesPath.unshift(presetsOverridesPath);
+        context.overridesPath.unshift(presetsOverridesPath);
     }
-    delete packageSettings.presets;
     return config;
 }
 exports.updateWithPresets = updateWithPresets;

package/build/configs/app-configs/validate-settings-keys.d.ts

@@ -1,7 +1,4 @@
 /**
- * Функция проверяет что все ключи объекта settingsObject есть в массиве availableKeys
- * @param {string[]} availableKeys Массив допустимых настроек
- * @param settingsObject Объект с настройками
+ * Функция проверяет что все ключи объекта settingsObject есть в уже существующей конфигурации
  */
-declare function validateSettingsKeys(availableKeys: ReadonlyArray<string>, settingsObject: Record<string, unknown>): void;
-export default validateSettingsKeys;
+export declare function validateSettingsKeys(existingConfig: Record<string, unknown>, settingsObject: Record<string, unknown>, source?: string): void;

package/build/configs/app-configs/validate-settings-keys.js

@@ -1,15 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSettingsKeys = void 0;
 /**
- * Функция проверяет что все ключи объекта settingsObject есть в массиве availableKeys
- * @param {string[]} availableKeys Массив допустимых настроек
- * @param settingsObject Объект с настройками
+ * Функция проверяет что все ключи объекта settingsObject есть в уже существующей конфигурации
  */
-function validateSettingsKeys(availableKeys, settingsObject) {
+function validateSettingsKeys(existingConfig, settingsObject, source) {
     Object.keys(settingsObject).forEach((setting) => {
-        if (!availableKeys.includes(setting)) {
-            console.warn('\x1b[33m', `Setting`, '\x1b[31m', setting, '\x1b[33m', 'is not supported!');
+        if (typeof existingConfig[setting] === 'undefined') {
+            console.warn(`Неизвестная настройка "${setting}" в ${source || 'конфигурации'}`);
         }
     });
 }
-exports.default = validateSettingsKeys;
+exports.validateSettingsKeys = validateSettingsKeys;

package/build/configs/babel-client.d.ts

@@ -1,2 +1,34 @@
-declare const babelClientConfig: any;
+declare const babelClientConfig: {
+    presets: (string | false | (string | {
+        targets: {
+            browsers: string[];
+        };
+        loose: boolean;
+        useBuiltIns: string;
+        corejs: number;
+        exclude: string[];
+    })[])[];
+    plugins: (string | (string | {
+        legacy: boolean;
+    })[] | (string | {
+        loose: boolean;
+    })[] | (string | {
+        useBuiltIns: boolean;
+    })[] | (string | {
+        corejs: boolean;
+        helpers: boolean;
+        version: string;
+        regenerator: boolean;
+    })[])[];
+    env: {
+        production: {
+            plugins: (string | (string | {
+                removeImport: boolean;
+            })[])[];
+        };
+        test: {
+            plugins: string[];
+        };
+    };
+};
 export default babelClientConfig;

package/build/configs/babel-dependencies.d.ts

@@ -1 +1,14 @@
-export declare const babelDependencies: any;
+export declare const babelDependencies: {
+    sourceType: string;
+    presets: (string | {
+        useBuiltIns: string;
+        corejs: number;
+        exclude: string[];
+    })[][];
+    plugins: (string | {
+        corejs: boolean;
+        helpers: boolean;
+        version: string;
+        regenerator: boolean;
+    })[][];
+};

package/build/configs/babel-server.d.ts

@@ -1,2 +1,27 @@
-declare const config: any;
+declare const config: {
+    presets: (string | false | (string | {
+        modules: boolean;
+        targets: {
+            node: string;
+        };
+        loose: boolean;
+    })[])[];
+    plugins: (string | (string | {
+        legacy: boolean;
+    })[] | (string | {
+        loose: boolean;
+    })[] | (string | {
+        useBuiltIns: boolean;
+    })[] | (string | {
+        helpers: boolean;
+    })[])[];
+    env: {
+        production: {
+            plugins: string[];
+        };
+        test: {
+            plugins: string[];
+        };
+    };
+};
 export default config;

package/build/configs/dev-server.d.ts

@@ -1,3 +1,16 @@
-/// <reference types="webpack-dev-server" />
-declare const devServerConfig: import("webpack-dev-server").Configuration;
+declare const devServerConfig: {
+    port: number;
+    liveReload: boolean;
+    client: {
+        overlay: {
+            errors: boolean;
+            warnings: boolean;
+        };
+    };
+    devMiddleware: {
+        publicPath: string;
+    };
+    static: string[];
+    proxy: any;
+};
 export default devServerConfig;

package/build/configs/jest/index.d.ts

@@ -14,6 +14,38 @@ export const snapshotSerializers: string[];
 export const globals: {
     'ts-jest': {
         tsconfig: string | null;
-        babelConfig: any;
+        babelConfig: {
+            presets: (string | false | (string | {
+                targets: {
+                    browsers: string[];
+                };
+                loose: boolean;
+                useBuiltIns: string;
+                corejs: number;
+                exclude: string[];
+            })[])[];
+            plugins: (string | (string | {
+                legacy: boolean;
+            })[] | (string | {
+                loose: boolean;
+            })[] | (string | {
+                useBuiltIns: boolean;
+            })[] | (string | {
+                corejs: boolean;
+                helpers: boolean;
+                version: string;
+                regenerator: boolean;
+            })[])[];
+            env: {
+                production: {
+                    plugins: (string | (string | {
+                        removeImport: boolean;
+                    })[])[];
+                };
+                test: {
+                    plugins: string[];
+                };
+            };
+        };
     };
 };

package/build/configs/modules.d.ts

@@ -0,0 +1,15 @@
+import { Assets } from 'assets-webpack-plugin';
+import { EmbeddedModuleConfig } from './app-configs/types';
+export declare function processAssetsPluginOutput(assets: Assets): string;
+export declare function haveExposedMfModules(): Record<string, string> | undefined;
+export declare function getCssPrefixForModule(module: EmbeddedModuleConfig): string | undefined;
+export declare function getChunkNamePrefix(module?: EmbeddedModuleConfig): string;
+export declare function getExposeLoadersFormEmbeddedModules(module?: EmbeddedModuleConfig): {
+    test: string;
+    use: {
+        loader: string;
+        options: {
+            exposes: string[];
+        };
+    }[];
+}[];

package/build/configs/modules.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExposeLoadersFormEmbeddedModules = exports.getChunkNamePrefix = exports.getCssPrefixForModule = exports.haveExposedMfModules = exports.processAssetsPluginOutput = void 0;
+const app_configs_1 = __importDefault(require("./app-configs"));
+function processAssetsPluginOutput(assets) {
+    var _a;
+    let adjustedAssets = assets;
+    if (haveExposedMfModules()) { // для mf модулей мы делаем publicPath 'auto', но в самом манифесте нам все равно хочется видеть нормальный путь
+        Object.keys(adjustedAssets).forEach((key) => {
+            adjustedAssets[key] = {
+                css: replaceAutoPath(adjustedAssets[key].css),
+                js: replaceAutoPath(adjustedAssets[key].js),
+            };
+        });
+    }
+    const result = Object.assign(Object.assign({}, adjustedAssets), { __metadata__: {
+            version: app_configs_1.default.version,
+            name: ((_a = app_configs_1.default.mfModules) === null || _a === void 0 ? void 0 : _a.name) || app_configs_1.default.normalizedName,
+        } });
+    return JSON.stringify(result);
+}
+exports.processAssetsPluginOutput = processAssetsPluginOutput;
+function replaceAutoPath(assets) {
+    if (!assets) {
+        return assets;
+    }
+    if (Array.isArray(assets)) {
+        return assets.map((asset) => asset.replace(/^auto\//, app_configs_1.default.publicPath));
+    }
+    return assets.replace(/^auto\//, app_configs_1.default.publicPath);
+}
+function haveExposedMfModules() {
+    var _a;
+    return (_a = app_configs_1.default.mfModules) === null || _a === void 0 ? void 0 : _a.exposes;
+}
+exports.haveExposedMfModules = haveExposedMfModules;
+function getCssPrefixForModule(module) {
+    if (module.cssPrefix) {
+        return module.cssPrefix;
+    }
+    if (module.cssPrefix === false) {
+        return undefined;
+    }
+    return `.module-${module.name}`;
+}
+exports.getCssPrefixForModule = getCssPrefixForModule;
+function getChunkNamePrefix(module) {
+    if (!module) {
+        return '';
+    }
+    return `${module.name}-`;
+}
+exports.getChunkNamePrefix = getChunkNamePrefix;
+function getExposeLoadersFormEmbeddedModules(module) {
+    var _a;
+    const shared = (_a = app_configs_1.default.embeddedModules) === null || _a === void 0 ? void 0 : _a.shared;
+    if (!shared || module) {
+        return [];
+    }
+    return Object.keys(shared).map((libraryName) => {
+        const globalVarName = shared[libraryName];
+        return {
+            test: require.resolve(libraryName),
+            use: [
+                {
+                    loader: require.resolve('expose-loader'),
+                    options: {
+                        exposes: [globalVarName],
+                    },
+                },
+            ],
+        };
+    });
+}
+exports.getExposeLoadersFormEmbeddedModules = getExposeLoadersFormEmbeddedModules;

package/build/configs/server-externals-exemptions.d.ts

@@ -1 +1 @@
-export declare const serverExternalsExemptions: (string | RegExp)[];
+export declare const serverExternalsExemptions: RegExp[];

package/build/configs/server-externals-exemptions.js

@@ -17,4 +17,5 @@ exports.serverExternalsExemptions = (0, apply_overrides_1.default)('serverExtern
     /^date-fns/,
     /^@corp-front\//,
     /^corp-sign-ui-react/,
+    /^arui-sciprts-utils/,
 ]);

package/build/configs/util/apply-overrides.d.ts

@@ -2,14 +2,14 @@ import type { Configuration as WebpackConfiguration, WebpackOptionsNormalized }
 import type { Configuration as WebpackDevServerConfiguration } from 'webpack-dev-server';
 import { AppConfigs } from '../app-configs/types';
 type Overrides = {
-    webpack: WebpackConfiguration;
-    webpackClient: WebpackConfiguration;
-    webpackDev: WebpackConfiguration;
-    webpackClientDev: WebpackConfiguration;
+    webpack: WebpackConfiguration | WebpackConfiguration[];
+    webpackClient: WebpackConfiguration | WebpackConfiguration[];
+    webpackDev: WebpackConfiguration | WebpackConfiguration[];
+    webpackClientDev: WebpackConfiguration | WebpackConfiguration[];
     webpackServer: WebpackConfiguration;
     webpackServerDev: WebpackConfiguration;
     webpackProd: WebpackConfiguration;
-    webpackClientProd: WebpackConfiguration;
+    webpackClientProd: WebpackConfiguration | WebpackConfiguration[];
     webpackServerProd: WebpackConfiguration;
     devServer: WebpackDevServerConfiguration;
     stats: WebpackOptionsNormalized['stats'];
@@ -36,5 +36,5 @@ export type OverrideFile = {
  * @param {Object} config Конфиг, к которому нужно применить оверрайды
  * @returns {*}
  */
-declare function applyOverrides<Key extends keyof Overrides>(overridesKey: Key | Key[], config: Overrides[Key]): Overrides[Key];
+declare function applyOverrides<T extends Overrides[Key], Key extends keyof Overrides>(overridesKey: Key | Key[], config: T): T;
 export default applyOverrides;

package/build/configs/util/get-entry.d.ts

@@ -1,8 +1,9 @@
+export type Entry = string | string[] | Record<string, string | string[]>;
 /**
  * @param {string|string[]|object} entryPoint Строка, массив строк или объект с энтрипоинтами
  * @param {Function} getSingleEntry Функция, возвращающая конфигурацию для одного entryPoint
  * @param args Дополнительные аргументы, которые будут переданы в getSingleEntry функцию
  * @returns {*}
  */
-declare function getEntry<AdditionalArgs extends unknown[]>(entryPoint: string | string[] | Record<string, string | string[]>, getSingleEntry: (entry: string[], ...args: AdditionalArgs) => string[], ...args: AdditionalArgs): string[] | Record<string, string | string[]>;
+declare function getEntry<AdditionalArgs extends unknown[]>(entryPoint: Entry, getSingleEntry: (entry: string[], ...args: AdditionalArgs) => string[], ...args: AdditionalArgs): string[] | Record<string, string | string[]>;
 export default getEntry;

package/build/configs/webpack.client.d.ts

@@ -1,2 +1,5 @@
-import { Configuration } from 'webpack';
-export declare const createClientWebpackConfig: (mode: 'dev' | 'prod') => Configuration;
+import webpack, { Configuration } from 'webpack';
+import { Entry } from './util/get-entry';
+import { EmbeddedModuleConfig } from './app-configs/types';
+export declare const createSingleClientWebpackConfig: (mode: 'dev' | 'prod', entry: Entry, module?: EmbeddedModuleConfig) => Configuration;
+export declare const createClientWebpackConfig: (mode: 'dev' | 'prod') => webpack.Configuration | webpack.Configuration[];

package/build/configs/webpack.client.dev.d.ts

@@ -1,2 +1,2 @@
-declare const config: import("webpack").Configuration;
+declare const config: import("webpack").Configuration | import("webpack").Configuration[];
 export default config;