arui-scripts 15.3.0 → 15.4.1

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,2 +1,16 @@
-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

@@ -13,6 +13,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/postcss.config.d.ts

@@ -4,7 +4,7 @@
  * @param {Object} options коллекция конфигураций плагинов, где ключ - название плагина, а значение - аргумент для инициализации
  * @returns {*}
  */
-export declare function createPostcssConfig(plugins: string[], options: Record<string, unknown>): (string | unknown[])[];
+export declare function createPostcssConfig(plugins: string[], options: Record<string, unknown>): string[] | unknown[];
 export declare const postcssPlugins: string[];
 export declare const postcssPluginsOptions: {
     'postcss-import': {

package/build/configs/postcss.d.ts

@@ -1,2 +1,2 @@
-declare const postcssConfig: any[];
+declare const postcssConfig: string[] | unknown[];
 export default postcssConfig;

package/build/configs/process-assets-plugin-output.d.ts

@@ -0,0 +1,2 @@
+import { Assets } from 'assets-webpack-plugin';
+export declare function processAssetsPluginOutput(assets: Assets): string;

package/build/configs/process-assets-plugin-output.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processAssetsPluginOutput = void 0;
+const app_configs_1 = __importDefault(require("./app-configs"));
+function processAssetsPluginOutput(assets) {
+    let adjustedAssets = assets;
+    Object.keys(adjustedAssets).forEach((key) => {
+        // заменяем путь к файлам на корректный в случае если в нем есть 'auto/'
+        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: 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);
+}

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

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

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

@@ -1,15 +1,16 @@
 import type { Configuration as WebpackConfiguration, WebpackOptionsNormalized } from 'webpack';
 import type { Configuration as WebpackDevServerConfiguration } from 'webpack-dev-server';
 import { AppConfigs } from '../app-configs/types';
+import { createSingleClientWebpackConfig } from "../webpack.client";
 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'];
@@ -26,7 +27,21 @@ type Overrides = {
     'start.sh': string;
     serverExternalsExemptions: Array<string | RegExp>;
 };
-type OverrideFunction<K extends keyof Overrides> = (config: Overrides[K], appConfig: AppConfigs) => Overrides[K];
+type OmitFirstArg<F> = F extends (x: any, ...args: infer P) => infer R ? (...args: P) => R : never;
+type BoundCreateSingleClientWebpackConfig = OmitFirstArg<typeof createSingleClientWebpackConfig>;
+type ClientWebpackAdditionalArgs = {
+    createSingleClientWebpackConfig: BoundCreateSingleClientWebpackConfig;
+};
+/**
+ * Дополнительные аргументы, которые будут переданы в функцию оверрайда
+ */
+type OverridesAdditionalArgs = {
+    webpack: ClientWebpackAdditionalArgs;
+    webpackClient: ClientWebpackAdditionalArgs;
+    webpackDev: ClientWebpackAdditionalArgs;
+    webpackClientDev: ClientWebpackAdditionalArgs;
+};
+type OverrideFunction<K extends keyof Overrides, AdditionalArgs = K extends keyof OverridesAdditionalArgs ? OverridesAdditionalArgs[K] : undefined> = (config: Overrides[K], appConfig: AppConfigs, additionalArgs: AdditionalArgs) => Overrides[K];
 export type OverrideFile = {
     [K in keyof Overrides]?: OverrideFunction<K>;
 };
@@ -34,7 +49,8 @@ export type OverrideFile = {
  *
  * @param {String|String[]} overridesKey Ключи оверрайда
  * @param {Object} config Конфиг, к которому нужно применить оверрайды
+ * @param args Дополнительные аргументы, которые будут переданы в функцию оверрайда
  * @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, Args = Key extends keyof OverridesAdditionalArgs ? OverridesAdditionalArgs[Key] : undefined>(overridesKey: Key | Key[], config: T, args?: any): T;
 export default applyOverrides;

package/build/configs/util/apply-overrides.js

@@ -24,9 +24,10 @@ overrides = app_configs_1.default.overridesPath.map(path => {
  *
  * @param {String|String[]} overridesKey Ключи оверрайда
  * @param {Object} config Конфиг, к которому нужно применить оверрайды
+ * @param args Дополнительные аргументы, которые будут переданы в функцию оверрайда
  * @returns {*}
  */
-function applyOverrides(overridesKey, config) {
+function applyOverrides(overridesKey, config, args) {
     if (typeof overridesKey === 'string') {
         overridesKey = [overridesKey];
     }
@@ -37,7 +38,7 @@ function applyOverrides(overridesKey, config) {
                 if (typeof overrideFn !== 'function') {
                     throw new TypeError(`Override ${key} must be a function`);
                 }
-                config = overrideFn(config, app_configs_1.default);
+                config = overrideFn(config, app_configs_1.default, args);
             }
         });
     });

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,10 @@
-import { Configuration } from 'webpack';
-export declare const createClientWebpackConfig: (mode: 'dev' | 'prod') => Configuration;
+import webpack, { Configuration } from 'webpack';
+import { Entry } from './util/get-entry';
+/**
+ * Создает конфигурацию для сборки клиентского кода. Может быть использована для создания дополнительных конфигураций.
+ * @param mode Режим сборки (dev или prod)
+ * @param entry Точка входа, любой валидный вход для webpack
+ * @param configName Имя конфигурации, если не указано, то используется имя по умолчанию
+ */
+export declare const createSingleClientWebpackConfig: (mode: 'dev' | 'prod', entry: Entry, configName?: string) => Configuration;
+export declare const createClientWebpackConfig: (mode: 'dev' | 'prod') => webpack.Configuration;

package/build/configs/webpack.client.dev.js

@@ -5,5 +5,5 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const apply_overrides_1 = __importDefault(require("./util/apply-overrides"));
 const webpack_client_1 = require("./webpack.client");
-const config = (0, apply_overrides_1.default)(['webpack', 'webpackClient', 'webpackDev', 'webpackClientDev'], (0, webpack_client_1.createClientWebpackConfig)('dev'));
+const config = (0, apply_overrides_1.default)(['webpack', 'webpackClient', 'webpackDev', 'webpackClientDev'], (0, webpack_client_1.createClientWebpackConfig)('dev'), { createSingleClientWebpackConfig: webpack_client_1.createSingleClientWebpackConfig.bind(null, 'dev') });
 exports.default = config;