arui-scripts 0.0.0-next-20230725145300

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,46 @@
+"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 path_1 = __importDefault(require("path"));
+const app_configs_1 = __importDefault(require("./app-configs"));
+const modules_1 = require("./modules");
+function processAssetsPluginOutput(assets) {
+    var _a;
+    let adjustedAssets = assets;
+    Object.keys(adjustedAssets).forEach((key) => {
+        // заменяем путь к файлам на корректный в случае если в нем есть 'auto/'
+        adjustedAssets[key] = {
+            css: replaceAutoPath(adjustedAssets[key].css),
+            js: replaceAutoPath(adjustedAssets[key].js),
+        };
+    });
+    // добавляем в манифест js-файлы для mf модулей
+    Object.keys(((_a = app_configs_1.default.mfModules) === null || _a === void 0 ? void 0 : _a.exposes) || {}).forEach((moduleName) => {
+        var _a, _b;
+        if ((_b = (_a = app_configs_1.default.embeddedModules) === null || _a === void 0 ? void 0 : _a.exposes) === null || _b === void 0 ? void 0 : _b[moduleName]) {
+            throw new Error(`Модуль ${moduleName} определен как mf и как embedded. Поменяйте название одного из модулей или удалите его`);
+        }
+        adjustedAssets[moduleName] = {
+            mode: 'mf',
+            js: path_1.default.join(app_configs_1.default.publicPath, modules_1.MF_ENTRY_NAME),
+        };
+    });
+    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

@@ -0,0 +1 @@
+export declare const serverExternalsExemptions: RegExp[];

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

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serverExternalsExemptions = void 0;
+const apply_overrides_1 = __importDefault(require("./util/apply-overrides"));
+exports.serverExternalsExemptions = (0, apply_overrides_1.default)('serverExternalsExemptions', [
+    /^arui-feather/,
+    /^arui-ft-private/,
+    /^arui-private/,
+    /^alfaform-core-ui/,
+    /^@alfa-bank\/newclick-composite-components/,
+    /^#/,
+    /^@alfalab\/icons/,
+    /^@alfalab\/core-components/,
+    /^date-fns/,
+    /^@corp-front\//,
+    /^corp-sign-ui-react/,
+    /^@alfalab\/scripts-/,
+]);

package/build/configs/stats-options.d.ts

@@ -0,0 +1,3 @@
+import type { WebpackOptionsNormalized } from 'webpack';
+declare const statsOptions: WebpackOptionsNormalized['stats'];
+export default statsOptions;

package/build/configs/stats-options.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const apply_overrides_1 = __importDefault(require("./util/apply-overrides"));
+const statsOptions = (0, apply_overrides_1.default)('stats', {
+    // Add asset Information
+    assets: false,
+    // Add information about cached (not built) modules
+    cached: false,
+    // Show cached assets (setting this to `false` only shows emitted files)
+    cachedAssets: false,
+    // Add children information
+    children: false,
+    // Add chunk information (setting this to `false` allows for a less verbose output)
+    chunks: false,
+    // Add built modules information to chunk information
+    chunkModules: false,
+    // Add the origins of chunks and chunk merging info
+    chunkOrigins: false,
+    // `webpack --colors` equivalent
+    colors: true,
+    // Add errors
+    errors: true,
+    // Add details to errors (like resolving log)
+    errorDetails: true,
+    // Add the hash of the compilation
+    hash: false,
+    // Add built modules information
+    modules: true,
+    // Show dependencies and origin of warnings/errors (since webpack 2.5.0)
+    moduleTrace: true,
+    // Show performance hint when file size exceeds `performance.maxAssetSize`
+    performance: true,
+    // Add public path information
+    publicPath: false,
+    // Add information about the reasons why modules are included
+    reasons: false,
+    // Add timing information
+    timings: true,
+    // Add webpack version information
+    version: false,
+    // Add warnings
+    warnings: true,
+    // ignore warning from missing types
+    warningsFilter: /export .* was not found in/
+});
+exports.default = statsOptions;

package/build/configs/supporting-browsers.d.ts

@@ -0,0 +1,2 @@
+declare const supportingBrowsers: string[];
+export default supportingBrowsers;

package/build/configs/supporting-browsers.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const apply_overrides_1 = __importDefault(require("./util/apply-overrides"));
+const supportingBrowsers = (0, apply_overrides_1.default)(['browsers', 'supportingBrowsers'], [
+    'last 2 versions',
+    'ie >= 10',
+    'Android >= 4',
+    'iOS >= 9'
+]);
+exports.default = supportingBrowsers;

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

@@ -0,0 +1,56 @@
+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 | WebpackConfiguration[];
+    webpackClient: WebpackConfiguration | WebpackConfiguration[];
+    webpackDev: WebpackConfiguration | WebpackConfiguration[];
+    webpackClientDev: WebpackConfiguration | WebpackConfiguration[];
+    webpackServer: WebpackConfiguration;
+    webpackServerDev: WebpackConfiguration;
+    webpackProd: WebpackConfiguration;
+    webpackClientProd: WebpackConfiguration | WebpackConfiguration[];
+    webpackServerProd: WebpackConfiguration;
+    devServer: WebpackDevServerConfiguration;
+    stats: WebpackOptionsNormalized['stats'];
+    babel: any;
+    babelClient: any;
+    babelServer: any;
+    babelDependencies: any;
+    postcss: any[];
+    browsers: string[];
+    supportingBrowsers: string[];
+    Dockerfile: string;
+    'DockerfileCompiled': string;
+    nginx: string;
+    'start.sh': string;
+    serverExternalsExemptions: Array<string | RegExp>;
+};
+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>;
+};
+/**
+ *
+ * @param {String|String[]} overridesKey Ключи оверрайда
+ * @param {Object} config Конфиг, к которому нужно применить оверрайды
+ * @param args Дополнительные аргументы, которые будут переданы в функцию оверрайда
+ * @returns {*}
+ */
+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

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const app_configs_1 = __importDefault(require("../app-configs"));
+let overrides = [];
+overrides = app_configs_1.default.overridesPath.map(path => {
+    try {
+        const requireResult = require(path);
+        if (requireResult.__esModule) {
+            // ts-node импортирует esModules, из них надо вытягивать default именно так
+            return requireResult.default;
+        }
+        return requireResult;
+    }
+    catch (e) {
+        console.error(`Unable to process override file "${path}"`);
+        console.log(e);
+        return {};
+    }
+});
+/**
+ *
+ * @param {String|String[]} overridesKey Ключи оверрайда
+ * @param {Object} config Конфиг, к которому нужно применить оверрайды
+ * @param args Дополнительные аргументы, которые будут переданы в функцию оверрайда
+ * @returns {*}
+ */
+function applyOverrides(overridesKey, config, args) {
+    if (typeof overridesKey === 'string') {
+        overridesKey = [overridesKey];
+    }
+    overridesKey.forEach(key => {
+        overrides.forEach((override) => {
+            if (override.hasOwnProperty(key)) {
+                const overrideFn = override[key];
+                if (typeof overrideFn !== 'function') {
+                    throw new TypeError(`Override ${key} must be a function`);
+                }
+                config = overrideFn(config, app_configs_1.default, args);
+            }
+        });
+    });
+    return config;
+}
+exports.default = applyOverrides;

package/build/configs/util/check-node-version.d.ts

@@ -0,0 +1,2 @@
+declare function checkNodeVersion(majorVersion: number): boolean;
+export default checkNodeVersion;

package/build/configs/util/check-node-version.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function checkNodeVersion(majorVersion) {
+    const actualVersion = process.versions.node.split('.');
+    return parseInt(actualVersion[0], 10) >= majorVersion;
+}
+exports.default = checkNodeVersion;

package/build/configs/util/find-loader.d.ts

@@ -0,0 +1,2 @@
+import webpack from "webpack";
+export declare function findLoader(config: webpack.Configuration, testRule: string): webpack.RuleSetRule | undefined;

package/build/configs/util/find-loader.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findLoader = void 0;
+function findLoader(config, testRule) {
+    var _a;
+    for (const rule of config.module.rules) {
+        if (rule === '...' || !rule) {
+            // Webpack имеет странный тип для rules, который позволяет в него положить строку '...'. Успокаиваем TS
+            continue;
+        }
+        if (rule.test && rule.test.toString() === testRule) {
+            return rule;
+        }
+        if (rule.oneOf) {
+            for (const oneOfRule of rule.oneOf) {
+                if (oneOfRule && oneOfRule.test && ((_a = oneOfRule === null || oneOfRule === void 0 ? void 0 : oneOfRule.test) === null || _a === void 0 ? void 0 : _a.toString()) === testRule) {
+                    return oneOfRule;
+                }
+            }
+        }
+    }
+}
+exports.findLoader = findLoader;

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

@@ -0,0 +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: Entry, getSingleEntry: (entry: string[], ...args: AdditionalArgs) => string[], ...args: AdditionalArgs): string[] | Record<string, string | string[]>;
+export default getEntry;

package/build/configs/util/get-entry.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @param {string|string[]|object} entryPoint Строка, массив строк или объект с энтрипоинтами
+ * @param {Function} getSingleEntry Функция, возвращающая конфигурацию для одного entryPoint
+ * @param args Дополнительные аргументы, которые будут переданы в getSingleEntry функцию
+ * @returns {*}
+ */
+function getEntry(entryPoint, getSingleEntry, ...args) {
+    if (typeof entryPoint === 'string') {
+        return getSingleEntry([entryPoint], ...args);
+    }
+    if (Array.isArray(entryPoint)) {
+        return getSingleEntry(entryPoint, ...args);
+    }
+    // client entry also can be an object, so we must add hot loader to each entry point
+    return Object.keys(entryPoint).reduce((result, entryPointName) => {
+        const entry = getEntry(entryPoint[entryPointName], getSingleEntry, ...args);
+        return Object.assign(Object.assign({}, result), { [entryPointName]: entry });
+    }, {});
+}
+exports.default = getEntry;

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

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+import { AppConfigs } from '../app-configs/types';
+export declare function getPolyfills(config: AppConfigs, requireResolve?: RequireResolve): string[];

package/build/configs/util/get-polyfills.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPolyfills = void 0;
+// require.resolve вынесен как параметр функции для того, чтоб это можно было протестировать.
+// на данный момент jest не дает возможности мокать require.resolve https://github.com/facebook/jest/issues/9543
+function getPolyfills(config, requireResolve = require.resolve) {
+    const polyfills = [];
+    if (config.clientPolyfillsEntry && Array.isArray(config.clientPolyfillsEntry)) {
+        polyfills.push(...config.clientPolyfillsEntry);
+    }
+    else if (config.clientPolyfillsEntry) {
+        polyfills.push(config.clientPolyfillsEntry);
+    }
+    else {
+        // Для сохранения обратной совместимости нам надо добавлять полифилы из физера только тогда, когда пользователь
+        // не задал свои кастомные полифилы.
+        try {
+            const aruiPolyfills = requireResolve('arui-feather/polyfills');
+            polyfills.push(aruiPolyfills);
+        }
+        catch (error) {
+            // just ignore it
+        }
+    }
+    return polyfills;
+}
+exports.getPolyfills = getPolyfills;

package/build/configs/util/install-sourcemap-support.d.ts

@@ -0,0 +1 @@
+export {};

package/build/configs/util/install-sourcemap-support.js

@@ -0,0 +1,7 @@
+"use strict";
+try {
+    require('source-map-support').install();
+}
+catch (e) {
+    console.error('unable to install source map support. Please add `source-map-support` as a dependency.');
+}

package/build/configs/util/node-assets-ignore.js

@@ -0,0 +1,31 @@
+"use strict";
+// ignore attempts to require any types of assets
+(() => {
+    // simply ignore css files, it wont cause any damage
+    const ignoreExtensions = [
+        '.css'
+    ];
+    // warn about other requires, because it may lead to unexpected behaviour in production
+    const warnExtensions = [
+        '.gif',
+        '.jpeg',
+        '.jpg',
+        '.ico',
+        '.png',
+        '.xml',
+        '.svg',
+        '.mp4',
+        '.webm',
+        '.ogv',
+        '.aac',
+        '.mp3',
+        '.wav',
+        '.ogg'
+    ];
+    const noop = () => { };
+    const warn = (_, path) => console.warn(`\u001B[0;31mWARNING!
+    Trying to require ${path} in node.js.
+    Non-js files is ignored when required in node_modules\u001B[0m`);
+    ignoreExtensions.forEach(e => require.extensions[e] = noop);
+    warnExtensions.forEach(e => require.extensions[e] = warn);
+})();

package/build/configs/util/noop.d.ts

@@ -0,0 +1 @@
+export {};

package/build/configs/util/noop.js

@@ -0,0 +1,2 @@
+"use strict";
+module.exports = {};

package/build/configs/util/register-ts-node.js

@@ -0,0 +1,17 @@
+"use strict";
+// Мы используем ts-node для работы c конфигами, описаными на ts
+require('ts-node')
+    .register({
+    transpileOnly: true,
+    ignore: [],
+    compilerOptions: {
+        target: 'ES2016',
+        module: 'CommonJS',
+        skipLibCheck: true,
+        allowJs: false,
+        allowSyntheticDefaultImports: true,
+        moduleResolution: 'node',
+        esModuleInterop: true,
+    },
+    skipProject: true,
+});

package/build/configs/util/resolve.d.ts

@@ -0,0 +1,12 @@
+export declare function tryResolve(...args: Parameters<typeof require.resolve>): string | undefined;
+/**
+ * Возвращает полный путь до модуля из node_modules относительно базового пути.
+ * Может быть полезно для определения пути до модуля, когда в проекте установлено сразу несколько модулей.
+ * /project
+ * --/node_modules
+ * ----/module1 // через эту функцию мы получим этот модуль
+ * ----/arui-scripts
+ * ------/node_modules
+ * --------/module1 // через require.resolve мы получим этот модуль
+ */
+export declare function resolveNodeModuleRelativeTo(basePath: string, moduleName: string): string;

package/build/configs/util/resolve.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveNodeModuleRelativeTo = exports.tryResolve = void 0;
+const path_1 = __importDefault(require("path"));
+function tryResolve(...args) {
+    try {
+        return require.resolve(...args);
+    }
+    catch (e) {
+        return undefined;
+    }
+}
+exports.tryResolve = tryResolve;
+/**
+ * Возвращает полный путь до модуля из node_modules относительно базового пути.
+ * Может быть полезно для определения пути до модуля, когда в проекте установлено сразу несколько модулей.
+ * /project
+ * --/node_modules
+ * ----/module1 // через эту функцию мы получим этот модуль
+ * ----/arui-scripts
+ * ------/node_modules
+ * --------/module1 // через require.resolve мы получим этот модуль
+ */
+function resolveNodeModuleRelativeTo(basePath, moduleName) {
+    return path_1.default.resolve(basePath, `node_modules/${moduleName}`);
+}
+exports.resolveNodeModuleRelativeTo = resolveNodeModuleRelativeTo;

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

@@ -0,0 +1,10 @@
+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 | webpack.Configuration[];

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

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

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

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": 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'), { createSingleClientWebpackConfig: webpack_client_1.createSingleClientWebpackConfig.bind(null, 'dev') });
+exports.default = config;