@gravity-ui/app-builder 0.2.2 → 0.4.0

package/dist/common/webpack/config.js

@@ -22,17 +22,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -90,7 +79,7 @@ function webpackConfigFactory(webpackMode, config, { logger } = {}) {
         optimization: configureOptimization(helperOptions),
         externals: config.externals,
         node: config.node,
-        watchOptions: config.watchOptions,
+        watchOptions: configureWatchOptions(helperOptions),
         ignoreWarnings: [/Failed to parse source map/],
         infrastructureLogging: config.verbose
             ? {
@@ -110,6 +99,9 @@ function webpackConfigFactory(webpackMode, config, { logger } = {}) {
                     : undefined,
             }
             : undefined,
+        snapshot: {
+            managedPaths: config.watchOptions?.watchPackages ? [] : undefined,
+        },
     };
 }
 exports.webpackConfigFactory = webpackConfigFactory;
@@ -149,10 +141,10 @@ function updateIncludesFactory() {
             // eslint-disable-next-line security/detect-non-literal-regexp
             !new RegExp(linkedPackage.name).test(pathname)));
             result = [...result, ...linkedPackagesJsIncludes];
-            if (options === null || options === void 0 ? void 0 : options.includeRootAssets) {
+            if (options?.includeRootAssets) {
                 result = [...result, ...linkedPackagesRootAssetsIncludes];
             }
-            if (options === null || options === void 0 ? void 0 : options.includeRootStyles) {
+            if (options?.includeRootStyles) {
                 result = [...result, ...linkedPackagesRootStylesIncludes];
             }
             return result;
@@ -167,6 +159,17 @@ function configureDevTool({ isEnvProduction, config }) {
     }
     return config.disableSourceMapGeneration ? false : format;
 }
+function configureWatchOptions({ config }) {
+    const watchOptions = {
+        ...config.watchOptions,
+        followSymlinks: config.watchOptions?.followSymlinks ??
+            (!config.symlinks && config.watchOptions?.watchPackages)
+            ? true
+            : undefined,
+    };
+    delete watchOptions.watchPackages;
+    return watchOptions;
+}
 function configureResolve({ isEnvProduction, config, tsLinkedPackages, }) {
     let alias = config.alias || {};
     alias = Object.entries(alias).reduce((result, [key, value]) => {
@@ -184,10 +187,13 @@ function configureResolve({ isEnvProduction, config, tsLinkedPackages, }) {
     }
     const { aliases, modules = [] } = (0, utils_1.resolveTsconfigPathsToAlias)(path_1.default.resolve(paths_1.default.appClient, 'tsconfig.json')) || {};
     return {
-        alias: Object.assign(Object.assign({}, aliases), alias),
+        alias: {
+            ...aliases,
+            ...alias,
+        },
         modules: ['node_modules', ...modules, ...(config.modules || [])],
         extensions: ['.mjs', '.cjs', '.js', '.jsx', '.ts', '.tsx', '.json'],
-        symlinks: config.symlinks || false,
+        symlinks: config.symlinks,
         fallback: config.fallback,
     };
 }
@@ -197,12 +203,15 @@ function createEntryArray(entry) {
 }
 function addEntry(entry, file) {
     const newEntry = path_1.default.resolve(paths_1.default.appEntry, file);
-    return Object.assign(Object.assign({}, entry), { [path_1.default.parse(file).name]: createEntryArray(newEntry) });
+    return {
+        ...entry,
+        [path_1.default.parse(file).name]: createEntryArray(newEntry),
+    };
 }
 function configureEntry({ config }) {
     let entries = fs_1.default.readdirSync(paths_1.default.appEntry).filter((file) => /\.[jt]sx?$/.test(file));
     if (Array.isArray(config.entryFilter) && config.entryFilter.length) {
-        entries = entries.filter((entry) => { var _a, _b; return (_a = config.entryFilter) === null || _a === void 0 ? void 0 : _a.includes((_b = entry.split('.')[0]) !== null && _b !== void 0 ? _b : ''); });
+        entries = entries.filter((entry) => config.entryFilter?.includes(entry.split('.')[0] ?? ''));
     }
     if (!entries.length) {
         throw new Error('No entries were found after applying UI_CORE_ENTRY_FILTER');
@@ -217,12 +226,14 @@ function getFileNames({ isEnvProduction }) {
             : 'js/[name].chunk.js',
     };
 }
-function configureOutput(_a) {
-    var { isEnvDevelopment } = _a, rest = __rest(_a, ["isEnvDevelopment"]);
-    return Object.assign(Object.assign({}, getFileNames(Object.assign({ isEnvDevelopment }, rest))), { path: paths_1.default.appBuild, pathinfo: isEnvDevelopment });
+function configureOutput({ isEnvDevelopment, ...rest }) {
+    return {
+        ...getFileNames({ isEnvDevelopment, ...rest }),
+        path: paths_1.default.appBuild,
+        pathinfo: isEnvDevelopment,
+    };
 }
 function createJavaScriptLoader({ isEnvProduction, isEnvDevelopment, config, }) {
-    var _a;
     return {
         loader: require.resolve('babel-loader'),
         options: {
@@ -233,7 +244,7 @@ function createJavaScriptLoader({ isEnvProduction, isEnvDevelopment, config, })
                 isEnvDevelopment &&
                     !config.disableReactRefresh && [
                     require.resolve('react-refresh/babel'),
-                    ((_a = config.devServer) === null || _a === void 0 ? void 0 : _a.webSocketPath)
+                    config.devServer?.webSocketPath
                         ? {
                             overlay: {
                                 sockPath: config.devServer.webSocketPath,
@@ -283,14 +294,18 @@ function createWorkerRule(options) {
         test: /\.worker\.[jt]sx?$/,
         exclude: /node_modules/,
         use: [
-            {
-                loader: require.resolve('worker-loader'),
-                // currently workers located on cdn are not working properly, so we are enforcing loading workers from
-                // service instead
-                options: {
-                    inline: 'no-fallback',
+            options.config.newWebWorkerSyntax
+                ? {
+                    loader: require.resolve('./worker/worker-loader'),
+                }
+                : {
+                    loader: require.resolve('worker-loader'),
+                    // currently workers located on cdn are not working properly, so we are enforcing loading workers from
+                    // service instead
+                    options: {
+                        inline: 'no-fallback',
+                    },
                 },
-            },
             createJavaScriptLoader(options),
         ],
     };
@@ -346,36 +361,44 @@ function createStylesRule({ isEnvDevelopment, isEnvProduction, config, }) {
 }
 function createIconsRule({ isEnvProduction, config }, jsLoader) {
     const iconIncludes = config.icons || [];
-    return Object.assign({ 
+    return {
         // eslint-disable-next-line security/detect-unsafe-regex
-        test: /\.svg(\?v=\d+\.\d+\.\d+)?$/, 
+        test: /\.svg(\?v=\d+\.\d+\.\d+)?$/,
         // we can't use one rule with issuer: /\.[jt]sx?$/ cause of https://github.com/webpack/webpack/issues/9309
-        issuer: jsLoader ? undefined : /\.s?css$/, include: [
+        issuer: jsLoader ? undefined : /\.s?css$/,
+        include: [
             /icons\/.*\.svg$/,
             // eslint-disable-next-line security/detect-non-literal-regexp
             ...iconIncludes.map((dir) => new RegExp(dir)),
-        ] }, (jsLoader
-        ? {
-            use: [
-                jsLoader,
-                {
-                    loader: require.resolve('@svgr/webpack'),
-                    options: Object.assign({ babel: false, dimensions: false }, config.svgr),
+        ],
+        ...(jsLoader
+            ? {
+                use: [
+                    jsLoader,
+                    {
+                        loader: require.resolve('@svgr/webpack'),
+                        options: {
+                            babel: false,
+                            dimensions: false,
+                            jsxRuntime: config.newJsxTransform ? 'automatic' : 'classic',
+                            ...config.svgr,
+                        },
+                    },
+                ],
+            }
+            : {
+                type: 'asset',
+                parser: {
+                    dataUrlCondition: {
+                        maxSize: imagesSizeLimit,
+                    },
                 },
-            ],
-        }
-        : {
-            type: 'asset',
-            parser: {
-                dataUrlCondition: {
-                    maxSize: imagesSizeLimit,
+                generator: {
+                    filename: 'assets/images/[name].[contenthash:8][ext]',
+                    publicPath: isEnvProduction ? '../' : undefined,
                 },
-            },
-            generator: {
-                filename: 'assets/images/[name].[contenthash:8][ext]',
-                publicPath: isEnvProduction ? '../' : undefined,
-            },
-        }));
+            }),
+    };
 }
 function createAssetsRules({ updateIncludes = lodash_1.default.identity, isEnvProduction, config, }) {
     const imagesRule = {
@@ -470,16 +493,14 @@ function createFallbackRules({ isEnvProduction }) {
     return rules;
 }
 function createMomentTimezoneDataPlugin(options = {}) {
-    var _a, _b;
     const currentYear = new Date().getFullYear();
     // By default get data for current year only
     // https://momentjs.com/timezone/docs/#/use-it/webpack/
-    const startYear = (_a = options.startYear) !== null && _a !== void 0 ? _a : currentYear;
-    const endYear = (_b = options.endYear) !== null && _b !== void 0 ? _b : currentYear;
-    return new moment_timezone_data_webpack_plugin_1.default(Object.assign(Object.assign({}, options), { startYear, endYear }));
+    const startYear = options.startYear ?? currentYear;
+    const endYear = options.endYear ?? currentYear;
+    return new moment_timezone_data_webpack_plugin_1.default({ ...options, startYear, endYear });
 }
 function configurePlugins(options) {
-    var _a;
     const { isEnvDevelopment, isEnvProduction, config } = options;
     const excludeFromClean = config.excludeFromClean || [];
     const plugins = [
@@ -496,7 +517,10 @@ function configurePlugins(options) {
             publicPath: '',
         }),
         createMomentTimezoneDataPlugin(config.momentTz),
-        new webpack.DefinePlugin(Object.assign({ 'process.env.NODE_ENV': JSON.stringify(process.env.NODE_ENV) }, config.definitions)),
+        new webpack.DefinePlugin({
+            'process.env.NODE_ENV': JSON.stringify(process.env.NODE_ENV),
+            ...config.definitions,
+        }),
     ];
     if (options.logger) {
         plugins.push(new progress_plugin_1.ProgressPlugin({ logger: options.logger }));
@@ -518,14 +542,19 @@ function configurePlugins(options) {
     }
     if (config.monaco) {
         const MonacoEditorWebpackPlugin = require('monaco-editor-webpack-plugin');
-        plugins.push(new MonacoEditorWebpackPlugin(Object.assign(Object.assign({}, config.monaco), { 
+        plugins.push(new MonacoEditorWebpackPlugin({
+            ...config.monaco,
             // currently, workers located on cdn are not working properly, so we are enforcing loading workers from
             // service instead
-            publicPath: path_1.default.normalize(config.publicPathPrefix + '/build/') })));
+            publicPath: path_1.default.normalize(config.publicPathPrefix + '/build/'),
+        }));
     }
     if (isEnvDevelopment && !config.disableReactRefresh) {
         const { webSocketPath = path_1.default.normalize(`/${config.publicPathPrefix}/build/sockjs-node`) } = config.devServer || {};
-        plugins.push(new react_refresh_webpack_plugin_1.default({ overlay: { sockPath: webSocketPath } }));
+        plugins.push(new react_refresh_webpack_plugin_1.default({
+            overlay: { sockPath: webSocketPath },
+            exclude: /\.worker\.[jt]sx?$/,
+        }));
     }
     if (config.detectCircularDependencies) {
         let circularPluginOptions = {
@@ -549,7 +578,7 @@ function configurePlugins(options) {
             },
         }));
     }
-    if ((_a = config.polyfill) === null || _a === void 0 ? void 0 : _a.process) {
+    if (config.polyfill?.process) {
         plugins.push(new webpack.ProvidePlugin({ process: 'process/browser.js' }));
     }
     if (isEnvProduction) {
@@ -639,8 +668,7 @@ function configurePlugins(options) {
     return plugins;
 }
 function configureOptimization({ isEnvProduction, config, }) {
-    var _a;
-    const configVendors = (_a = config.vendors) !== null && _a !== void 0 ? _a : [];
+    const configVendors = config.vendors ?? [];
     const vendorsList = [
         'react',
         'react-dom',

package/dist/common/webpack/public-path.js

@@ -1,2 +1,2 @@
 "use strict";
-__webpack_public_path__ = window.__PUBLIC_PATH__;
+__webpack_public_path__ = window.__PUBLIC_PATH__ ?? '/build/';

package/dist/common/webpack/storybook.js

@@ -12,27 +12,52 @@ const config_1 = require("./config");
 const config_2 = require("../config");
 const models_1 = require("../models");
 async function configureServiceWebpackConfig(mode, storybookConfig) {
-    var _a, _b, _c, _d, _e;
     const serviceConfig = await (0, config_2.getProjectConfig)(mode === "production" /* WebpackMode.Prod */ ? 'build' : 'dev', {});
-    if (!(0, models_1.isServiceConfig)(serviceConfig)) {
-        throw new Error('configureServiceWebpackConfig can be used only for services, but got the library config');
+    let options = {};
+    if ((0, models_1.isLibraryConfig)(serviceConfig)) {
+        options = {
+            includes: ['src'],
+            newJsxTransform: serviceConfig.lib?.newJsxTransform,
+        };
     }
-    const webpackConfig = await configureWebpackConfigForStorybook(mode, serviceConfig.client);
-    return Object.assign(Object.assign({}, storybookConfig), { plugins: [...((_a = storybookConfig.plugins) !== null && _a !== void 0 ? _a : []), ...webpackConfig.plugins], resolve: Object.assign(Object.assign(Object.assign({}, storybookConfig.resolve), webpackConfig.resolve), { alias: Object.assign(Object.assign({}, (_b = storybookConfig.resolve) === null || _b === void 0 ? void 0 : _b.alias), webpackConfig.resolve.alias), modules: [
-                ...(((_c = storybookConfig.resolve) === null || _c === void 0 ? void 0 : _c.modules) || []),
+    else {
+        options = serviceConfig.client;
+    }
+    const webpackConfig = await configureWebpackConfigForStorybook(mode, options);
+    return {
+        ...storybookConfig,
+        plugins: [...(storybookConfig.plugins ?? []), ...webpackConfig.plugins],
+        resolve: {
+            ...storybookConfig.resolve,
+            ...webpackConfig.resolve,
+            alias: {
+                ...storybookConfig.resolve?.alias,
+                ...webpackConfig.resolve.alias,
+            },
+            modules: [
+                ...(storybookConfig.resolve?.modules || []),
                 ...(webpackConfig.resolve.modules || []),
-            ], extensions: [
-                ...((_e = (_d = storybookConfig.resolve) === null || _d === void 0 ? void 0 : _d.extensions) !== null && _e !== void 0 ? _e : []),
+            ],
+            extensions: [
+                ...(storybookConfig.resolve?.extensions ?? []),
                 ...(webpackConfig.resolve.extensions || []),
-            ] }), module: Object.assign(Object.assign({}, storybookConfig.module), { rules: webpackConfig.module.rules }) });
+            ],
+        },
+        module: {
+            ...storybookConfig.module,
+            rules: webpackConfig.module.rules,
+        },
+    };
 }
 exports.configureServiceWebpackConfig = configureServiceWebpackConfig;
 async function configureWebpackConfigForStorybook(mode, userConfig = {}) {
-    var _a;
     const isEnvDevelopment = mode === "development" /* WebpackMode.Dev */;
     const isEnvProduction = mode === "production" /* WebpackMode.Prod */;
     const config = await (0, config_2.normalizeConfig)({
-        client: Object.assign(Object.assign({}, userConfig), { includes: ((_a = userConfig.includes) !== null && _a !== void 0 ? _a : []).concat(['.storybook']) }),
+        client: {
+            ...userConfig,
+            includes: (userConfig.includes ?? []).concat(['.storybook']),
+        },
     });
     const helperOptions = {
         isEnvDevelopment,
@@ -53,14 +78,18 @@ function configurePlugins({ isEnvDevelopment, isEnvProduction, config }) {
     if (config.definitions) {
         // eslint-disable-next-line security/detect-non-literal-require
         const webpack = require(path_1.default.resolve(process.cwd(), 'node_modules/webpack'));
-        plugins.push(new webpack.DefinePlugin(Object.assign({}, config.definitions)));
+        plugins.push(new webpack.DefinePlugin({
+            ...config.definitions,
+        }));
     }
     if (config.monaco) {
         const MonacoEditorWebpackPlugin = require('monaco-editor-webpack-plugin');
-        plugins.push(new MonacoEditorWebpackPlugin(Object.assign(Object.assign({}, config.monaco), { 
+        plugins.push(new MonacoEditorWebpackPlugin({
+            ...config.monaco,
             // currently, workers located on cdn are not working properly, so we are enforcing loading workers from
             // service instead
-            publicPath: '/' })));
+            publicPath: '/',
+        }));
     }
     if (isEnvDevelopment) {
         plugins.push(new react_refresh_webpack_plugin_1.default());

package/dist/common/webpack/utils.js

@@ -29,7 +29,7 @@ function webpackCompilerHandlerFactory(logger, onCompilationEnd) {
         if (onCompilationEnd) {
             await onCompilationEnd();
         }
-        const time = (stats === null || stats === void 0 ? void 0 : stats.endTime) - (stats === null || stats === void 0 ? void 0 : stats.startTime);
+        const time = stats?.endTime - stats?.startTime;
         logger.success(`Client was successfully compiled in ${(0, pretty_time_1.prettyTime)(BigInt(time) * BigInt(1000000))}`);
     };
 }
@@ -63,9 +63,11 @@ exports.resolveTsconfigPathsToAlias = resolveTsconfigPathsToAlias;
 function readJsonConfig(pathname) {
     try {
         const json = fs_1.default.readFileSync(pathname, 'utf-8');
-        return Object.assign({}, JSON.parse(json));
+        return {
+            ...JSON.parse(json),
+        };
     }
-    catch (_a) {
+    catch {
         throw new Error(`Couldn't read config ${pathname}`);
     }
 }

package/dist/common/webpack/worker/public-path.worker.js

@@ -0,0 +1,3 @@
+"use strict";
+// eslint-disable-next-line camelcase, no-implicit-globals
+__webpack_public_path__ = self.__PUBLIC_PATH__;

package/dist/common/webpack/worker/web-worker.d.ts

@@ -0,0 +1,4 @@
+declare class WebWorker extends Worker {
+    constructor(url: string | URL, options?: WorkerOptions);
+}
+export { WebWorker as Worker };

package/dist/common/webpack/worker/web-worker.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Worker = void 0;
+class WebWorker extends Worker {
+    constructor(url, options) {
+        // eslint-disable-next-line camelcase
+        const publicPath = __webpack_public_path__;
+        const workerPublicPath = publicPath.match(/^https?:\/\//)
+            ? publicPath
+            : new URL(publicPath, window.location.href).toString();
+        const objectURL = URL.createObjectURL(new Blob([
+            [
+                `self.__PUBLIC_PATH__ = ${JSON.stringify(workerPublicPath)}`,
+                `importScripts(${JSON.stringify(url.toString())});`,
+            ].join('\n'),
+        ], {
+            type: 'application/javascript',
+        }));
+        super(objectURL, options);
+        URL.revokeObjectURL(objectURL);
+    }
+}
+exports.Worker = WebWorker;

package/dist/common/webpack/worker/worker-loader.d.ts

@@ -0,0 +1,2 @@
+import webpack from 'webpack';
+export declare const pitch: webpack.PitchLoaderDefinitionFunction;

package/dist/common/webpack/worker/worker-loader.js

@@ -0,0 +1,123 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pitch = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const webpack_1 = __importDefault(require("webpack"));
+const NodeTargetPlugin_1 = __importDefault(require("webpack/lib/node/NodeTargetPlugin"));
+const WebWorkerTemplatePlugin_1 = __importDefault(require("webpack/lib/webworker/WebWorkerTemplatePlugin"));
+const FetchCompileWasmPlugin_1 = __importDefault(require("webpack/lib/web/FetchCompileWasmPlugin"));
+const FetchCompileAsyncWasmPlugin_1 = __importDefault(require("webpack/lib/web/FetchCompileAsyncWasmPlugin"));
+const paths_1 = __importDefault(require("../../paths"));
+const publicPath = node_path_1.default.resolve(__dirname, 'public-path.worker.js');
+const pitch = function (request) {
+    this.cacheable(false);
+    if (!this._compiler || !this._compilation) {
+        throw new Error('Something went wrong');
+    }
+    const compilerOptions = this._compiler.options;
+    const logger = this.getLogger('APP_BUILDER_WORKER_LOADER');
+    if (compilerOptions.output.globalObject === 'window') {
+        logger.warn('Warning (app-builder-worker-loader): output.globalObject is set to "window". It should be set to "self" or "this" to support HMR in Workers.');
+    }
+    const isEnvProduction = compilerOptions.mode === 'production';
+    const filename = isEnvProduction
+        ? 'js/[name].[contenthash:8].worker.js'
+        : 'js/[name].worker.js';
+    const workerOptions = {
+        filename,
+        chunkFilename: filename,
+        publicPath: compilerOptions.output.publicPath,
+        globalObject: 'self',
+        devtoolNamespace: node_path_1.default.resolve('/', node_path_1.default.relative(paths_1.default.app, this.resource)),
+    };
+    const workerCompiler = this._compilation.createChildCompiler(`worker ${request}`, workerOptions);
+    new WebWorkerTemplatePlugin_1.default().apply(workerCompiler);
+    if (this.target !== 'webworker' && this.target !== 'web') {
+        new NodeTargetPlugin_1.default().apply(workerCompiler);
+    }
+    new FetchCompileWasmPlugin_1.default({
+        mangleImports: this._compiler.options.optimization.mangleWasmImports,
+    }).apply(workerCompiler);
+    new FetchCompileAsyncWasmPlugin_1.default().apply(workerCompiler);
+    const bundleName = node_path_1.default.parse(this.resourcePath).name;
+    new webpack_1.default.EntryPlugin(this.context, `!!${publicPath}`, bundleName).apply(workerCompiler);
+    new webpack_1.default.EntryPlugin(this.context, `!!${request}`, bundleName).apply(workerCompiler);
+    configureSourceMap(workerCompiler);
+    const cb = this.async();
+    workerCompiler.compile((err, compilation) => {
+        if (!compilation) {
+            return undefined;
+        }
+        workerCompiler.parentCompilation?.children.push(compilation);
+        if (err) {
+            return cb(err);
+        }
+        if (compilation.errors && compilation.errors.length) {
+            const errorDetails = compilation.errors
+                .map((error) => {
+                if (error instanceof Error) {
+                    return error.stack;
+                }
+                return error;
+            })
+                .join('\n');
+            return cb(new Error('Child compilation failed:\n' + errorDetails));
+        }
+        const file = Object.keys(compilation.assets)[0];
+        if (file) {
+            const contents = compilation.assets[file]?.source();
+            const mapFile = `${file}.map`;
+            let map = compilation.assets[mapFile]?.source();
+            if (map) {
+                const sourceMap = JSON.parse(map.toString());
+                if (Array.isArray(sourceMap.sources)) {
+                    sourceMap.sources = sourceMap.sources.map((pathname) => pathname.replace(/webpack:\/\/[^/]+\//, 'webpack://'));
+                }
+                map = JSON.stringify(sourceMap);
+            }
+            for (const [fileName, asset] of Object.entries(compilation.assets)) {
+                if ([file, mapFile].includes(fileName)) {
+                    continue;
+                }
+                workerCompiler.parentCompilation?.emitAsset(fileName, asset, compilation.assetsInfo.get(fileName));
+            }
+            return cb(null, contents, map?.toString());
+        }
+        return cb(null, undefined);
+    });
+};
+exports.pitch = pitch;
+function configureSourceMap(compiler) {
+    const devtool = compiler.options.devtool;
+    if (devtool) {
+        if (devtool.includes('source-map')) {
+            // remove parent SourceMapDevToolPlugin from compilation
+            for (const hook of Object.values(compiler.hooks)) {
+                for (let i = hook.taps.length - 1; i >= 0; i--) {
+                    const tap = hook.taps[i];
+                    if (tap?.name === 'SourceMapDevToolPlugin') {
+                        hook.taps.splice(i, 1);
+                    }
+                }
+            }
+            const hidden = devtool.includes('hidden');
+            const inline = devtool.includes('inline');
+            const cheap = devtool.includes('cheap');
+            const moduleMaps = devtool.includes('module');
+            new webpack_1.default.SourceMapDevToolPlugin({
+                filename: inline ? null : compiler.options.output.sourceMapFilename,
+                moduleFilenameTemplate: compiler.options.output.devtoolModuleFilenameTemplate,
+                fallbackModuleFilenameTemplate: compiler.options.output.devtoolFallbackModuleFilenameTemplate,
+                append: hidden ? false : undefined,
+                module: moduleMaps ? true : !cheap,
+                columns: !cheap,
+                noSources: false,
+                namespace: (compiler.parentCompilation?.outputOptions.devtoolNamespace ?? '') +
+                    compiler.options.output.devtoolNamespace,
+            }).apply(compiler);
+        }
+    }
+}

package/dist/create-cli.d.ts

@@ -2,9 +2,9 @@ export type CliArgs = Awaited<ReturnType<typeof createCli>>;
 export declare function createCli(argv: string[]): {
     [x: string]: unknown;
     verbose: boolean;
+    c: unknown;
     inspect: number | undefined;
     target: "client" | "server" | undefined;
-    c: unknown;
     env: string[] | undefined;
     inspectBrk: number | undefined;
     "inspect-brk": number | undefined;
@@ -28,9 +28,9 @@ export declare function createCli(argv: string[]): {
 } | Promise<{
     [x: string]: unknown;
     verbose: boolean;
+    c: unknown;
     inspect: number | undefined;
     target: "client" | "server" | undefined;
-    c: unknown;
     env: string[] | undefined;
     inspectBrk: number | undefined;
     "inspect-brk": number | undefined;

package/dist/create-cli.js

@@ -195,7 +195,7 @@ function getCommandHandler(command, handler) {
     return async (argv) => {
         logger_1.default.setVerbose(Boolean(argv.verbose));
         const config = await (0, config_1.getProjectConfig)(command, argv);
-        const args = Object.assign(Object.assign({}, config), { logger: logger_1.default });
+        const args = { ...config, logger: logger_1.default };
         const localCmd = resolveLocalCommand(command);
         logger_1.default.verbose(`running command: ${command}`);
         return handler ? handler(args, localCmd) : localCmd(args);

package/dist/index.d.ts

@@ -1,3 +1,5 @@
 export { configureWebpackConfigForStorybook, configureServiceWebpackConfig, } from './common/webpack/storybook';
+export * from './common/s3-upload';
 export { createTransformPathsToLocalModules } from './common/typescript/transformers';
-export type { ProjectConfig, ServiceConfig, LibraryConfig } from './common/models';
+export { defineConfig } from './common/models';
+export type { ProjectConfig, ServiceConfig, LibraryConfig, ProjectFileConfig } from './common/models';

package/dist/index.js

@@ -1,8 +1,25 @@
 "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 });
-exports.createTransformPathsToLocalModules = exports.configureServiceWebpackConfig = exports.configureWebpackConfigForStorybook = void 0;
+exports.defineConfig = exports.createTransformPathsToLocalModules = exports.configureServiceWebpackConfig = exports.configureWebpackConfigForStorybook = void 0;
 var storybook_1 = require("./common/webpack/storybook");
 Object.defineProperty(exports, "configureWebpackConfigForStorybook", { enumerable: true, get: function () { return storybook_1.configureWebpackConfigForStorybook; } });
 Object.defineProperty(exports, "configureServiceWebpackConfig", { enumerable: true, get: function () { return storybook_1.configureServiceWebpackConfig; } });
+__exportStar(require("./common/s3-upload"), exports);
 var transformers_1 = require("./common/typescript/transformers");
 Object.defineProperty(exports, "createTransformPathsToLocalModules", { enumerable: true, get: function () { return transformers_1.createTransformPathsToLocalModules; } });
+var models_1 = require("./common/models");
+Object.defineProperty(exports, "defineConfig", { enumerable: true, get: function () { return models_1.defineConfig; } });