@nx/angular-rspack 19.0.0-alpha.30

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Colum Ferry
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,15 @@
+<div style="text-align: center;">
+
+# @nx/angular-rspack
+
+[![GitHub Actions](https://github.com/nrwl/angular-rspack/actions/workflows/ci.yml/badge.svg)](https://github.com/nrwl/angular-rspack/actions/workflows/ci.yml)
+![License](https://img.shields.io/badge/License-MIT-blue)
+[![NPM Version](https://img.shields.io/npm/v/%40ng-rspack%2Fbuild?label=%40nx%2Fangular-rspack)](https://www.npmjs.com/package/@ng-rspack/build)
+
+</div>
+
+<hr>
+
+# Build Angular with Rspack
+
+The goal of `@nx/angular-rspack` is to make easy and straightforward to build Angular applications with [rspack](https://rspack.dev).

package/code-pushup.config.ts

@@ -0,0 +1,13 @@
+import { CoreConfig } from '@code-pushup/models';
+import { mergeConfigs } from '@code-pushup/utils';
+import {
+  baseConfig,
+  coverageCoreConfig,
+  eslintConfig,
+} from '../../tools/reports/code-pushup.preset.config';
+
+export default mergeConfigs(
+  baseConfig as CoreConfig,
+  await eslintConfig(),
+  await coverageCoreConfig()
+);

package/dist/lib/config/create-config.d.ts

@@ -0,0 +1,11 @@
+import { Configuration } from '@rspack/core';
+import { AngularRspackPluginOptions } from '../models';
+export declare function _createConfig(options: AngularRspackPluginOptions, rspackConfigOverrides?: Partial<Configuration>): Promise<Configuration[]>;
+export declare function createConfig(defaultOptions: {
+    options: AngularRspackPluginOptions;
+    rspackConfigOverrides?: Partial<Configuration>;
+}, configurations?: Record<string, {
+    options: Partial<AngularRspackPluginOptions>;
+    rspackConfigOverrides?: Partial<Configuration>;
+}>, configEnvVar?: string): Promise<Configuration[]>;
+//# sourceMappingURL=create-config.d.ts.map

package/dist/lib/config/create-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-config.d.ts","sourceRoot":"","sources":["../../../src/lib/config/create-config.ts"],"names":[],"mappings":"AACA,OAAO,EACL,aAAa,EAMd,MAAM,cAAc,CAAC;AAGtB,OAAO,EACL,0BAA0B,EAG3B,MAAM,WAAW,CAAC;AAkEnB,wBAAsB,aAAa,CACjC,OAAO,EAAE,0BAA0B,EACnC,qBAAqB,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,GAC7C,OAAO,CAAC,aAAa,EAAE,CAAC,CAkX1B;AAED,wBAAsB,YAAY,CAChC,cAAc,EAAE;IACd,OAAO,EAAE,0BAA0B,CAAC;IACpC,qBAAqB,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,CAAC;CAChD,EACD,cAAc,GAAE,MAAM,CACpB,MAAM,EACN;IACE,OAAO,EAAE,OAAO,CAAC,0BAA0B,CAAC,CAAC;IAC7C,qBAAqB,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,CAAC;CAChD,CACG,EACN,YAAY,SAAgB,GAC3B,OAAO,CAAC,aAAa,EAAE,CAAC,CAyB1B"}

package/dist/lib/config/create-config.js

@@ -0,0 +1,417 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._createConfig = _createConfig;
+exports.createConfig = createConfig;
+const ng_rspack_1 = require("../plugins/ng-rspack");
+const core_1 = require("@rspack/core");
+const webpack_merge_1 = require("webpack-merge");
+const path_1 = require("path");
+const models_1 = require("../models");
+const angular_rspack_compiler_1 = require("@nx/angular-rspack-compiler");
+const style_config_utils_1 = require("./style-config-utils");
+const helpers_1 = require("./helpers");
+const dev_server_config_utils_1 = require("./dev-server-config-utils");
+const dev_tools_ignore_plugin_1 = require("../plugins/tools/dev-tools-ignore-plugin");
+function configureSourceMap(sourceMap) {
+    const { scripts, styles, hidden, vendor } = sourceMap;
+    const sourceMapRules = [];
+    const sourceMapPlugins = [];
+    if (scripts || styles) {
+        const include = [];
+        if (scripts) {
+            include.push(/js$/);
+        }
+        if (styles) {
+            include.push(/css$/);
+        }
+        sourceMapPlugins.push(new dev_tools_ignore_plugin_1.DevToolsIgnorePlugin());
+        sourceMapPlugins.push(new core_1.SourceMapDevToolPlugin({
+            filename: '[file].map',
+            include,
+            // We want to set sourceRoot to  `webpack:///` for non
+            // inline sourcemaps as otherwise paths to sourcemaps will be broken in browser
+            // `webpack:///` is needed for Visual Studio breakpoints to work properly as currently
+            // there is no way to set the 'webRoot'
+            sourceRoot: 'webpack:///',
+            moduleFilenameTemplate: '[resource-path]',
+            append: hidden ? false : undefined,
+        }));
+        sourceMapRules.push({
+            test: /\.[cm]?jsx?$/,
+            enforce: 'pre',
+            loader: require.resolve('source-map-loader'),
+            options: {
+                filterSourceMappingUrl: (_mapUri, resourcePath) => {
+                    if (vendor) {
+                        // Consume all sourcemaps when vendor option is enabled.
+                        return true;
+                    }
+                    // Don't consume sourcemaps in node_modules when vendor is disabled.
+                    // But, do consume local libraries sourcemaps.
+                    return !resourcePath.includes('node_modules');
+                },
+            },
+        });
+    }
+    return { sourceMapRules, sourceMapPlugins };
+}
+const VENDORS_TEST = /[\\/]node_modules[\\/]/;
+async function _createConfig(options, rspackConfigOverrides) {
+    const normalizedOptions = (0, models_1.normalizeOptions)(options);
+    const isProduction = process.env['NODE_ENV'] === 'production';
+    const isDevServer = process.env['WEBPACK_SERVE'];
+    const hashFormat = (0, helpers_1.getOutputHashFormat)(normalizedOptions.outputHashing);
+    const { root } = normalizedOptions;
+    const { sourceMapRules, sourceMapPlugins } = configureSourceMap(normalizedOptions.sourceMap);
+    const defaultConfig = {
+        context: root,
+        mode: isProduction ? 'production' : 'development',
+        devtool: normalizedOptions.sourceMap.scripts ? 'source-map' : undefined,
+        output: {
+            uniqueName: 'rspack-angular',
+            publicPath: 'auto',
+            clean: true,
+            crossOriginLoading: false,
+            trustedTypes: { policyName: 'angular#bundler' },
+            sourceMapFilename: normalizedOptions.sourceMap.scripts
+                ? '[file].map'
+                : undefined,
+        },
+        resolve: {
+            extensions: ['.ts', '.tsx', '.mjs', '.js'],
+            modules: ['node_modules'],
+            mainFields: ['es2020', 'es2015', 'browser', 'module', 'main'],
+            conditionNames: ['es2020', 'es2015', '...'],
+            tsConfig: {
+                configFile: normalizedOptions.tsConfig,
+            },
+        },
+        experiments: {
+            css: true,
+        },
+        module: {
+            parser: {
+                javascript: {
+                    requireContext: false,
+                    url: false,
+                },
+                'css/auto': {
+                    esModule: true,
+                },
+            },
+            rules: [
+                ...(0, style_config_utils_1.getStyleLoaders)(normalizedOptions.stylePreprocessorOptions, normalizedOptions.sourceMap),
+                ...sourceMapRules,
+                { test: /[/\\]rxjs[/\\]add[/\\].+\.js$/, sideEffects: true },
+                {
+                    test: angular_rspack_compiler_1.TS_ALL_EXT_REGEX,
+                    use: [
+                        {
+                            loader: 'builtin:swc-loader',
+                            options: {
+                                jsc: {
+                                    parser: {
+                                        syntax: 'typescript',
+                                    },
+                                    target: 'es2022',
+                                },
+                            },
+                        },
+                        {
+                            loader: require.resolve('@nx/angular-rspack/loaders/angular-loader'),
+                        },
+                    ],
+                },
+                {
+                    test: angular_rspack_compiler_1.JS_ALL_EXT_REGEX,
+                    use: [
+                        {
+                            loader: require.resolve('@nx/angular-rspack/loaders/angular-partial-transform-loader'),
+                        },
+                    ],
+                },
+            ],
+        },
+        plugins: [...sourceMapPlugins],
+    };
+    const configs = [];
+    if (normalizedOptions.hasServer) {
+        const serverConfig = {
+            ...defaultConfig,
+            name: 'server',
+            target: 'node',
+            entry: {
+                server: {
+                    import: [normalizedOptions.ssr.entry],
+                },
+            },
+            output: {
+                ...defaultConfig.output,
+                publicPath: 'auto',
+                clean: true,
+                path: normalizedOptions.outputPath.server,
+                filename: '[name].js',
+                chunkFilename: '[name].js',
+            },
+            devServer: {
+                headers: {
+                    'Access-Control-Allow-Origin': '*',
+                },
+                allowedHosts: 'auto',
+                client: {
+                    webSocketURL: {
+                        hostname: 'localhost',
+                        port: normalizedOptions.devServer?.port ?? 4200,
+                    },
+                    overlay: {
+                        errors: true,
+                        warnings: false,
+                        runtimeErrors: true,
+                    },
+                    reconnect: true,
+                },
+                port: normalizedOptions.devServer?.port ?? 4200,
+                hot: false,
+                liveReload: true,
+                watchFiles: ['./src/**/*.*', './public/**/*.*'],
+                historyApiFallback: {
+                    index: '/index.html',
+                    rewrites: [{ from: /^\/$/, to: 'index.html' }],
+                },
+                devMiddleware: {
+                    writeToDisk: (file) => !file.includes('.hot-update.'),
+                },
+                server: {
+                    options: normalizedOptions.devServer?.sslKey &&
+                        normalizedOptions.devServer?.sslCert
+                        ? {
+                            key: (0, path_1.resolve)(root, normalizedOptions.devServer.sslKey),
+                            cert: (0, path_1.resolve)(root, normalizedOptions.devServer.sslCert),
+                        }
+                        : {},
+                    type: normalizedOptions.devServer?.ssl ? 'https' : 'http',
+                },
+                proxy: await (0, dev_server_config_utils_1.getProxyConfig)(root, normalizedOptions.devServer?.proxyConfig),
+            },
+            optimization: {
+                chunkIds: normalizedOptions.namedChunks ? 'named' : 'deterministic',
+                moduleIds: 'deterministic',
+                ...(normalizedOptions.optimization && !isDevServer
+                    ? {
+                        minimize: true,
+                        runtimeChunk: 'single',
+                        splitChunks: {
+                            chunks: 'async',
+                            minChunks: 1,
+                            minSize: 20000,
+                            maxAsyncRequests: 30,
+                            maxInitialRequests: 30,
+                            cacheGroups: {
+                                default: normalizedOptions.commonChunk && {
+                                    chunks: 'async',
+                                    minChunks: 2,
+                                    priority: 10,
+                                },
+                                common: normalizedOptions.commonChunk && {
+                                    name: 'common',
+                                    chunks: 'async',
+                                    minChunks: 2,
+                                    enforce: true,
+                                    priority: 5,
+                                },
+                                vendors: false,
+                                defaultVendors: normalizedOptions.vendorChunk && {
+                                    name: 'vendor',
+                                    chunks: (chunk) => chunk.name === 'main',
+                                    enforce: true,
+                                    test: VENDORS_TEST,
+                                },
+                            },
+                        },
+                        minimizer: [
+                            new core_1.SwcJsMinimizerRspackPlugin({
+                                minimizerOptions: {
+                                    minify: true,
+                                    compress: {
+                                        passes: 2,
+                                    },
+                                    format: {
+                                        comments: false,
+                                    },
+                                },
+                            }),
+                        ],
+                    }
+                    : {
+                        minimize: false,
+                        minimizer: [],
+                    }),
+            },
+            plugins: [
+                ...(defaultConfig.plugins ?? []),
+                new ng_rspack_1.NgRspackPlugin({
+                    ...normalizedOptions,
+                    polyfills: ['zone.js/node'],
+                }),
+            ],
+        };
+        const mergedConfig = (0, webpack_merge_1.merge)(serverConfig, rspackConfigOverrides ?? {});
+        configs.push(mergedConfig);
+    }
+    const browserConfig = {
+        ...defaultConfig,
+        name: 'browser',
+        ...(normalizedOptions.hasServer && isDevServer
+            ? { dependencies: ['server'] }
+            : {}),
+        target: 'web',
+        entry: {
+            main: {
+                import: [normalizedOptions.browser],
+            },
+        },
+        devServer: {
+            headers: {
+                'Access-Control-Allow-Origin': '*',
+            },
+            allowedHosts: 'auto',
+            client: {
+                webSocketURL: {
+                    hostname: 'localhost',
+                    port: options.devServer?.port ?? 4200,
+                },
+                overlay: {
+                    errors: true,
+                    warnings: false,
+                    runtimeErrors: true,
+                },
+                reconnect: true,
+            },
+            hot: false,
+            liveReload: true,
+            watchFiles: ['./src/**/*.*', './public/**/*.*'],
+            historyApiFallback: {
+                index: '/index.html',
+                rewrites: [{ from: /^\/$/, to: 'index.html' }],
+            },
+            devMiddleware: {
+                writeToDisk: (file) => !file.includes('.hot-update.'),
+            },
+            port: options.devServer?.port ?? 4200,
+            server: {
+                options: normalizedOptions.devServer?.sslKey &&
+                    normalizedOptions.devServer?.sslCert
+                    ? {
+                        key: (0, path_1.resolve)(root, normalizedOptions.devServer.sslKey),
+                        cert: (0, path_1.resolve)(root, normalizedOptions.devServer.sslCert),
+                    }
+                    : {},
+                type: normalizedOptions.devServer?.ssl ? 'https' : 'http',
+            },
+            proxy: await (0, dev_server_config_utils_1.getProxyConfig)(root, normalizedOptions.devServer?.proxyConfig),
+            onListening: (devServer) => {
+                if (!devServer) {
+                    throw new Error('@rspack/dev-server is not defined');
+                }
+                const port = devServer.server?.address()?.port ?? 4200;
+                console.log('Listening on port:', port);
+            },
+        },
+        output: {
+            ...defaultConfig.output,
+            hashFunction: isProduction ? 'xxhash64' : undefined,
+            publicPath: 'auto',
+            clean: true,
+            path: normalizedOptions.outputPath.browser,
+            cssFilename: `[name]${hashFormat.file}.css`,
+            filename: `[name]${hashFormat.chunk}.js`,
+            chunkFilename: `[name]${hashFormat.chunk}.js`,
+            scriptType: 'module',
+            module: true,
+        },
+        optimization: {
+            chunkIds: normalizedOptions.namedChunks ? 'named' : 'deterministic',
+            moduleIds: 'deterministic',
+            ...(normalizedOptions.optimization && !isDevServer
+                ? {
+                    minimize: true,
+                    runtimeChunk: false,
+                    splitChunks: {
+                        chunks: 'all',
+                        minChunks: 1,
+                        minSize: 20000,
+                        maxAsyncRequests: 30,
+                        maxInitialRequests: 30,
+                        cacheGroups: {
+                            default: normalizedOptions.commonChunk && {
+                                chunks: 'async',
+                                minChunks: 2,
+                                priority: 10,
+                            },
+                            common: normalizedOptions.commonChunk && {
+                                name: 'common',
+                                chunks: 'async',
+                                minChunks: 2,
+                                enforce: true,
+                                priority: 5,
+                            },
+                            vendors: false,
+                            defaultVendors: normalizedOptions.vendorChunk && {
+                                name: 'vendor',
+                                chunks: (chunk) => chunk.name === 'main',
+                                enforce: true,
+                                test: VENDORS_TEST,
+                            },
+                        },
+                    },
+                    minimizer: [
+                        new core_1.SwcJsMinimizerRspackPlugin({
+                            minimizerOptions: {
+                                minify: true,
+                                mangle: true,
+                                compress: {
+                                    passes: 2,
+                                },
+                                format: {
+                                    comments: false,
+                                },
+                            },
+                        }),
+                    ],
+                }
+                : {
+                    minimize: false,
+                    minimizer: [],
+                }),
+        },
+        plugins: [
+            ...(defaultConfig.plugins ?? []),
+            new ng_rspack_1.NgRspackPlugin({
+                ...normalizedOptions,
+                polyfills: ['zone.js'],
+                hasServer: false,
+            }),
+        ],
+    };
+    const mergedConfig = (0, webpack_merge_1.merge)(browserConfig, rspackConfigOverrides ?? {});
+    configs.unshift(mergedConfig);
+    return configs;
+}
+async function createConfig(defaultOptions, configurations = {}, configEnvVar = 'NGRS_CONFIG') {
+    const configurationMode = process.env[configEnvVar] ?? 'production';
+    const isDefault = configurationMode === 'default';
+    const isModeConfigured = configurationMode in configurations;
+    const mergedBuildOptionsOptions = {
+        ...defaultOptions.options,
+        ...((!isDefault && isModeConfigured
+            ? configurations[configurationMode]?.options
+            : {}) ?? {}),
+    };
+    let mergedRspackConfigOverrides = defaultOptions.rspackConfigOverrides ?? {};
+    if (!isDefault &&
+        isModeConfigured &&
+        configurations[configurationMode]?.rspackConfigOverrides) {
+        mergedRspackConfigOverrides = (0, webpack_merge_1.merge)(mergedRspackConfigOverrides, configurations[configurationMode]?.rspackConfigOverrides ?? {});
+    }
+    return _createConfig(mergedBuildOptionsOptions, mergedRspackConfigOverrides);
+}

package/dist/lib/config/dev-server-config-utils.d.ts

@@ -0,0 +1,3 @@
+import type { DevServer } from '@rspack/core';
+export declare function getProxyConfig(root: string, proxyConfig: string | undefined): Promise<DevServer['proxy'] | undefined>;
+//# sourceMappingURL=dev-server-config-utils.d.ts.map

package/dist/lib/config/dev-server-config-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev-server-config-utils.d.ts","sourceRoot":"","sources":["../../../src/lib/config/dev-server-config-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAM9C,wBAAsB,cAAc,CAClC,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,GAAG,SAAS,GAC9B,OAAO,CAAC,SAAS,CAAC,OAAO,CAAC,GAAG,SAAS,CAAC,CA2EzC"}

package/dist/lib/config/dev-server-config-utils.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProxyConfig = getProxyConfig;
+const tslib_1 = require("tslib");
+const node_assert_1 = tslib_1.__importDefault(require("node:assert"));
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_url_1 = require("node:url");
+async function getProxyConfig(root, proxyConfig) {
+    if (!proxyConfig) {
+        return undefined;
+    }
+    const proxyPath = (0, node_path_1.resolve)(root, proxyConfig);
+    if (!(0, node_fs_1.existsSync)(proxyPath)) {
+        throw new Error(`Proxy configuration file ${proxyPath} does not exist.`);
+    }
+    let proxyConfiguration;
+    switch ((0, node_path_1.extname)(proxyPath)) {
+        case '.json': {
+            const content = await node_fs_1.promises.readFile(proxyPath, 'utf-8');
+            const { parse, printParseErrorCode } = await Promise.resolve().then(() => tslib_1.__importStar(require('jsonc-parser')));
+            const parseErrors = [];
+            proxyConfiguration = parse(content, parseErrors, {
+                allowTrailingComma: true,
+            });
+            if (parseErrors.length > 0) {
+                let errorMessage = `Proxy configuration file ${proxyPath} contains parse errors:`;
+                for (const parseError of parseErrors) {
+                    const { line, column } = getJsonErrorLineColumn(parseError.offset, content);
+                    errorMessage += `\n[${line}, ${column}] ${printParseErrorCode(parseError.error)}`;
+                }
+                throw new Error(errorMessage);
+            }
+            break;
+        }
+        case '.mjs':
+            // Load the ESM configuration file using the TypeScript dynamic import workaround.
+            // Once TypeScript provides support for keeping the dynamic import this workaround can be
+            // changed to a direct dynamic import.
+            proxyConfiguration = (await loadEsmModule((0, node_url_1.pathToFileURL)(proxyPath))).default;
+            break;
+        case '.cjs':
+            proxyConfiguration = require(proxyPath);
+            break;
+        default:
+            // The file could be either CommonJS or ESM.
+            // CommonJS is tried first then ESM if loading fails.
+            try {
+                proxyConfiguration = require(proxyPath);
+            }
+            catch (e) {
+                assertIsError(e);
+                if (e.code !== 'ERR_REQUIRE_ESM') {
+                    throw e;
+                }
+                // Load the ESM configuration file using the TypeScript dynamic import workaround.
+                // Once TypeScript provides support for keeping the dynamic import this workaround can be
+                // changed to a direct dynamic import.
+                proxyConfiguration = (await loadEsmModule((0, node_url_1.pathToFileURL)(proxyPath))).default;
+            }
+    }
+    return normalizeProxyConfiguration(proxyConfiguration);
+}
+function getJsonErrorLineColumn(offset, content) {
+    if (offset === 0) {
+        return { line: 1, column: 1 };
+    }
+    let line = 0;
+    let position = 0;
+    while (true) {
+        ++line;
+        const nextNewline = content.indexOf('\n', position);
+        if (nextNewline === -1 || nextNewline > offset) {
+            break;
+        }
+        position = nextNewline + 1;
+    }
+    return { line, column: offset - position + 1 };
+}
+function normalizeProxyConfiguration(proxy) {
+    return Array.isArray(proxy)
+        ? proxy
+        : Object.entries(proxy).map(([context, value]) => ({
+            context: [context],
+            ...value,
+        }));
+}
+function assertIsError(value) {
+    const isError = value instanceof Error ||
+        // The following is needing to identify errors coming from RxJs.
+        (typeof value === 'object' &&
+            value &&
+            'name' in value &&
+            'message' in value);
+    (0, node_assert_1.default)(isError, 'catch clause variable is not an Error instance');
+}
+let load;
+function loadEsmModule(modulePath) {
+    load ??= new Function('modulePath', `return import(modulePath);`);
+    return load(modulePath);
+}

package/dist/lib/config/helpers.d.ts

@@ -0,0 +1,3 @@
+import { OutputHashing, HashFormat } from '../models';
+export declare function getOutputHashFormat(outputHashing?: OutputHashing, length?: number): HashFormat;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/lib/config/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/lib/config/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAEtD,wBAAgB,mBAAmB,CACjC,aAAa,GAAE,aAAsB,EACrC,MAAM,SAAI,GACT,UAAU,CAkCZ"}

package/dist/lib/config/helpers.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOutputHashFormat = getOutputHashFormat;
+function getOutputHashFormat(outputHashing = 'none', length = 8) {
+    const hashTemplate = `.[contenthash:${length}]`;
+    switch (outputHashing) {
+        case 'media':
+            return {
+                chunk: '',
+                extract: '',
+                file: hashTemplate,
+                script: '',
+            };
+        case 'bundles':
+            return {
+                chunk: hashTemplate,
+                extract: hashTemplate,
+                file: '',
+                script: hashTemplate,
+            };
+        case 'all':
+            return {
+                chunk: hashTemplate,
+                extract: hashTemplate,
+                file: hashTemplate,
+                script: hashTemplate,
+            };
+        case 'none':
+        default:
+            return {
+                chunk: '',
+                extract: '',
+                file: '',
+                script: '',
+            };
+    }
+}