@depup/nestjs__cli 11.0.24-depup.8 → 12.0.0-depup.0

package/lib/compiler/defaults/swc-defaults.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.swcDefaultsFactory = void 0;
-const swcDefaultsFactory = (tsOptions, configuration) => {
+export const swcDefaultsFactory = (tsOptions, configuration, tsConfigExclude = []) => {
     const builderOptions = typeof configuration?.compilerOptions?.builder !== 'string'
         ? configuration?.compilerOptions?.builder?.options
         : {};
@@ -37,14 +34,33 @@ const swcDefaultsFactory = (tsOptions, configuration) => {
             extensions: ['.js', '.ts'],
             copyFiles: false,
             includeDotfiles: false,
+            ignore: tsConfigExclude.length ? tsConfigExclude : undefined,
             quiet: false,
             watch: false,
-            stripLeadingPaths: !tsOptions?.rootDir,
+            stripLeadingPaths: shouldStripLeadingPaths(tsOptions?.rootDir, configuration?.sourceRoot ?? 'src'),
             ...builderOptions,
         },
     };
 };
-exports.swcDefaultsFactory = swcDefaultsFactory;
+/**
+ * Mirrors tsc's output layout: tsc flattens the source directory out of the
+ * output when its (effective) rootDir is the source root, so swc must strip
+ * leading paths in the same cases — no rootDir configured (tsc infers the
+ * common source directory), or a rootDir that points at the source root
+ * (relative or resolved absolute). A rootDir above the source root (e.g. '.')
+ * keeps the source directory in the output, so nothing is stripped.
+ */
+function shouldStripLeadingPaths(rootDir, sourceRoot) {
+    if (!rootDir) {
+        return true;
+    }
+    const normalizedRootDir = convertPath(rootDir).replace(/\/+$/, '');
+    const normalizedSourceRoot = convertPath(sourceRoot)
+        .replace(/^\.\//, '')
+        .replace(/\/+$/, '');
+    return (normalizedRootDir === normalizedSourceRoot ||
+        normalizedRootDir.endsWith(`/${normalizedSourceRoot}`));
+}
 /**
  * Converts Windows specific file paths to posix
  * @param windowsPath

package/lib/compiler/defaults/webpack-defaults.d.ts

@@ -1,3 +1,3 @@
-import { MultiNestCompilerPlugins } from '../plugins/plugins-loader';
-import webpack = require('webpack');
+import type webpack from 'webpack';
+import { MultiNestCompilerPlugins } from '../plugins/plugins-loader.js';
 export declare const webpackDefaultsFactory: (sourceRoot: string, relativeSourceRoot: string, entryFilename: string, isDebugEnabled: boolean | undefined, tsConfigFile: string | undefined, plugins: MultiNestCompilerPlugins) => webpack.Configuration;

package/lib/compiler/defaults/webpack-defaults.js

@@ -1,23 +1,64 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.webpackDefaultsFactory = void 0;
-const path_1 = require("path");
-const tsconfig_paths_webpack_plugin_1 = require("tsconfig-paths-webpack-plugin");
-const defaults_1 = require("../../configuration/defaults");
-const append_extension_1 = require("../helpers/append-extension");
-const webpack = require("webpack");
-const nodeExternals = require("webpack-node-externals");
-const webpackDefaultsFactory = (sourceRoot, relativeSourceRoot, entryFilename, isDebugEnabled = false, tsConfigFile = defaults_1.defaultTsconfigFilename, plugins) => {
+import { readFileSync } from 'fs';
+import { createRequire } from 'module';
+import { join } from 'path';
+import { defaultTsconfigFilename } from '../../configuration/defaults.js';
+import { appendTsExtension } from '../helpers/append-extension.js';
+const require = createRequire(import.meta.url);
+/**
+ * Wraps a `require` of an optional webpack dependency so a missing package
+ * reports the install command instead of a raw MODULE_NOT_FOUND. Every
+ * optional webpack dependency must be loaded through here — they are declared
+ * as optional peers, so any unguarded `require` surfaces as a bare crash.
+ */
+function withInstallAdvice(load) {
+    try {
+        return load();
+    }
+    catch (e) {
+        if (e?.code !== 'MODULE_NOT_FOUND' && e?.code !== 'ERR_MODULE_NOT_FOUND') {
+            // Only the "package missing" branch is wrapped with install advice.
+            // Surfacing unrelated errors as "package not found" would mislead
+            // users into reinstalling perfectly valid dependencies.
+            throw e;
+        }
+        // Use a non-greedy match so error messages that contain multiple
+        // quoted paths (e.g. ESM "Cannot find package 'foo' imported from
+        // '/abs/path.mjs'") still extract the package name rather than the
+        // importing file path.
+        const pkg = e?.message?.match?.(/Cannot find.*?'([^']+)'/)?.[1] ?? 'webpack';
+        throw new Error(`The "${pkg}" package is required when using the webpack compiler but could not be found. ` +
+            `Please install it:\n\n  npm install --save-dev webpack webpack-node-externals tsconfig-paths-webpack-plugin ts-loader fork-ts-checker-webpack-plugin\n`, { cause: e });
+    }
+}
+function loadWebpackDeps() {
+    return withInstallAdvice(() => {
+        const wp = require('webpack');
+        const externals = require('webpack-node-externals');
+        const { TsconfigPathsPlugin } = require('tsconfig-paths-webpack-plugin');
+        return { webpack: wp, nodeExternals: externals, TsconfigPathsPlugin };
+    });
+}
+function getBaseUrl(tsConfigFile) {
+    try {
+        const { compilerOptions } = JSON.parse(readFileSync(tsConfigFile, 'utf8'));
+        return compilerOptions?.baseUrl ?? '.';
+    }
+    catch {
+        return '.';
+    }
+}
+export const webpackDefaultsFactory = (sourceRoot, relativeSourceRoot, entryFilename, isDebugEnabled = false, tsConfigFile = defaultTsconfigFilename, plugins) => {
+    const { webpack: wp, nodeExternals: externals, TsconfigPathsPlugin, } = loadWebpackDeps();
     const isPluginRegistered = isAnyPluginRegistered(plugins);
     const webpackConfiguration = {
-        entry: (0, append_extension_1.appendTsExtension)((0, path_1.join)(sourceRoot, entryFilename)),
+        entry: appendTsExtension(join(sourceRoot, entryFilename)),
         devtool: isDebugEnabled ? 'inline-source-map' : false,
         target: 'node',
         output: {
-            filename: (0, path_1.join)(relativeSourceRoot, `${entryFilename}.js`),
+            filename: join(relativeSourceRoot, `${entryFilename}.js`).replace(/\\/g, '/'),
         },
         ignoreWarnings: [/^(?!CriticalDependenciesWarning$)/],
-        externals: [nodeExternals()],
+        externals: [externals()],
         externalsPresets: { node: true },
         module: {
             rules: [
@@ -44,8 +85,9 @@ const webpackDefaultsFactory = (sourceRoot, relativeSourceRoot, entryFilename, i
         resolve: {
             extensions: ['.tsx', '.ts', '.js'],
             plugins: [
-                new tsconfig_paths_webpack_plugin_1.TsconfigPathsPlugin({
+                new TsconfigPathsPlugin({
                     configFile: tsConfigFile,
+                    baseUrl: getBaseUrl(tsConfigFile),
                 }),
             ],
         },
@@ -58,7 +100,7 @@ const webpackDefaultsFactory = (sourceRoot, relativeSourceRoot, entryFilename, i
             __dirname: false,
         },
         plugins: [
-            new webpack.IgnorePlugin({
+            new wp.IgnorePlugin({
                 checkResource(resource) {
                     const lazyImports = [
                         '@nestjs/microservices',
@@ -76,7 +118,7 @@ const webpackDefaultsFactory = (sourceRoot, relativeSourceRoot, entryFilename, i
                             paths: [process.cwd()],
                         });
                     }
-                    catch (err) {
+                    catch {
                         return true;
                     }
                     return false;
@@ -85,8 +127,7 @@ const webpackDefaultsFactory = (sourceRoot, relativeSourceRoot, entryFilename, i
         ],
     };
     if (!isPluginRegistered) {
-        // eslint-disable-next-line @typescript-eslint/no-var-requires
-        const ForkTsCheckerWebpackPlugin = require('fork-ts-checker-webpack-plugin');
+        const ForkTsCheckerWebpackPlugin = withInstallAdvice(() => require('fork-ts-checker-webpack-plugin'));
         webpackConfiguration.plugins.push(new ForkTsCheckerWebpackPlugin({
             typescript: {
                 configFile: tsConfigFile,
@@ -95,7 +136,6 @@ const webpackDefaultsFactory = (sourceRoot, relativeSourceRoot, entryFilename, i
     }
     return webpackConfiguration;
 };
-exports.webpackDefaultsFactory = webpackDefaultsFactory;
 function isAnyPluginRegistered(plugins) {
     return ((plugins.afterHooks && plugins.afterHooks.length > 0) ||
         (plugins.beforeHooks && plugins.beforeHooks.length > 0) ||

package/lib/compiler/helpers/append-extension.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.appendTsExtension = appendTsExtension;
-const path_1 = require("path");
-function appendTsExtension(path) {
-    return (0, path_1.extname)(path) === '.ts' ? path : path + '.ts';
+import { extname } from 'path';
+export function appendTsExtension(path) {
+    return extname(path) === '.ts' ? path : path + '.ts';
 }

package/lib/compiler/helpers/copy-path-resolve.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.copyPathResolve = copyPathResolve;
-const path = require("path");
+import * as path from 'path';
 /**
  * Helper function for returning a copy destination filename
  *
  * @description used in `assets-manager.ts` (copy from `copyfiles`)
  * @see https://github.com/calvinmetcalf/copyfiles/blob/master/index.js#L22
  */
-function copyPathResolve(filePath, outDir, up) {
+export function copyPathResolve(filePath, outDir, up) {
     return path.join(outDir, dealWith(filePath, up));
 }
 function dealWith(inPath, up) {

package/lib/compiler/helpers/delete-out-dir.d.ts

@@ -1,3 +1,3 @@
 import * as ts from 'typescript';
-import { Configuration } from '../../configuration';
+import { Configuration } from '../../configuration/index.js';
 export declare function deleteOutDirIfEnabled(configuration: Required<Configuration>, appName: string | undefined, dirPath: string, tsOptions?: ts.CompilerOptions): Promise<void>;

package/lib/compiler/helpers/delete-out-dir.js

@@ -1,15 +1,50 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.deleteOutDirIfEnabled = deleteOutDirIfEnabled;
-const promises_1 = require("fs/promises");
-const get_value_or_default_1 = require("./get-value-or-default");
-async function deleteOutDirIfEnabled(configuration, appName, dirPath, tsOptions) {
-    const isDeleteEnabled = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'compilerOptions.deleteOutDir', appName);
+import { rm } from 'fs/promises';
+import * as ts from 'typescript';
+import { getValueOrDefault } from './get-value-or-default.js';
+import { areOutsidePathsAllowed, assertPathInsideProject, } from './path-confinement.js';
+/**
+ * A recursive delete is not atomic: it walks the tree, and anything created
+ * between the "readdir" of a directory and its "rmdir" makes the removal fail
+ * with ENOTEMPTY. Concurrent writers into "outDir" are common in monorepos
+ * (a sibling "tsc --noEmit --incremental" dropping its buildinfo there, for
+ * instance), which turns "deleteOutDir" into a flaky build. Node already
+ * treats ENOTEMPTY - along with EBUSY, EMFILE, ENFILE and EPERM, the errors
+ * Windows raises for a file another process still holds - as retryable, but
+ * only retries when "maxRetries" is set; it defaults to 0.
+ *
+ * See https://github.com/nestjs/nest-cli/issues/3509
+ */
+const RM_MAX_RETRIES = 3;
+export async function deleteOutDirIfEnabled(configuration, appName, dirPath, tsOptions) {
+    const isDeleteEnabled = getValueOrDefault(configuration, 'compilerOptions.deleteOutDir', appName);
     if (!isDeleteEnabled) {
         return;
     }
-    await (0, promises_1.rm)(dirPath, { recursive: true, force: true });
-    if (tsOptions?.tsBuildInfoFile) {
-        await (0, promises_1.rm)(tsOptions.tsBuildInfoFile, { force: true });
+    const shouldValidate = !areOutsidePathsAllowed(configuration, appName);
+    // With "incremental" enabled but no explicit "tsBuildInfoFile", TypeScript
+    // derives a default location that can fall outside "outDir" (with "outDir"
+    // and "rootDir" both set, "tsconfig.build.tsbuildinfo" lands next to the
+    // tsconfig), so the recursive delete below would leave it behind. Reuse the
+    // compiler's own resolution to remove the buildinfo wherever it actually is.
+    const tsBuildInfoFile = tsOptions &&
+        (tsOptions.tsBuildInfoFile ?? ts.getTsBuildInfoEmitOutputFilePath(tsOptions));
+    // Both paths are validated before anything is removed, so that a rejected
+    // "tsBuildInfoFile" cannot leave a half-deleted output directory behind.
+    const outDirToDelete = shouldValidate
+        ? assertPathInsideProject(dirPath, 'outDir')
+        : dirPath;
+    const tsBuildInfoFileToDelete = shouldValidate && tsBuildInfoFile
+        ? assertPathInsideProject(tsBuildInfoFile, 'tsBuildInfoFile')
+        : tsBuildInfoFile;
+    await rm(outDirToDelete, {
+        recursive: true,
+        force: true,
+        maxRetries: RM_MAX_RETRIES,
+    });
+    if (tsBuildInfoFileToDelete) {
+        await rm(tsBuildInfoFileToDelete, {
+            force: true,
+            maxRetries: RM_MAX_RETRIES,
+        });
     }
 }

package/lib/compiler/helpers/get-builder.d.ts

@@ -1,5 +1,4 @@
-import { Input } from '../../../commands';
-import { Configuration } from '../../configuration';
+import { Configuration } from '../../configuration/index.js';
 /**
  * Returns the builder to use for the given application.
  * @param configuration Configuration object.
@@ -7,15 +6,18 @@ import { Configuration } from '../../configuration';
  * @param appName Application name.
  * @returns The builder to use.
  */
-export declare function getBuilder(configuration: Required<Configuration>, cmdOptions: Input[], appName: string | undefined): {
+export declare function getBuilder(configuration: Required<Configuration>, cmdOptions: Record<string, any>, appName: string | undefined): {
     type: "webpack";
-    options?: import("../../configuration").WebpackBuilderOptions;
+    options?: import("../../configuration/configuration.js").WebpackBuilderOptions;
+} | {
+    type: "rspack";
+    options?: import("../../configuration/configuration.js").RspackBuilderOptions;
 } | {
     type: "swc";
-    options?: import("../../configuration").SwcBuilderOptions;
+    options?: import("../../configuration/configuration.js").SwcBuilderOptions;
 } | {
     type: "tsc";
-    options?: import("../../configuration").TscBuilderOptions;
+    options?: import("../../configuration/configuration.js").TscBuilderOptions;
 } | {
-    type: import("../../configuration").BuilderVariant;
+    type: import("../../configuration/configuration.js").BuilderVariant;
 };

package/lib/compiler/helpers/get-builder.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getBuilder = getBuilder;
-const get_value_or_default_1 = require("./get-value-or-default");
+import { getValueOrDefault } from './get-value-or-default.js';
 /**
  * Returns the builder to use for the given application.
  * @param configuration Configuration object.
@@ -9,8 +6,8 @@ const get_value_or_default_1 = require("./get-value-or-default");
  * @param appName Application name.
  * @returns The builder to use.
  */
-function getBuilder(configuration, cmdOptions, appName) {
-    const builderValue = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'compilerOptions.builder', appName, 'builder', cmdOptions, 'tsc');
+export function getBuilder(configuration, cmdOptions, appName) {
+    const builderValue = getValueOrDefault(configuration, 'compilerOptions.builder', appName, 'builder', cmdOptions, 'tsc');
     return typeof builderValue === 'string'
         ? {
             type: builderValue,

package/lib/compiler/helpers/get-effective-root-dir.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Computes the effective TypeScript rootDir for an emit, mirroring how the
+ * TypeScript compiler determines it when `rootDir` is not set in tsconfig.
+ *
+ * When `rootDir` is explicitly configured, its absolute, normalized form is
+ * returned. Otherwise the longest common parent directory of the input file
+ * list is used (the same heuristic TypeScript applies through
+ * `Program#getCommonSourceDirectory`).
+ *
+ * Returns `undefined` if no rootDir can be determined (e.g. no input files).
+ *
+ * @param explicitRootDir Value of `compilerOptions.rootDir` from tsconfig, if any.
+ * @param fileNames List of TypeScript input files (absolute paths).
+ * @param cwd Current working directory used to resolve relative paths.
+ */
+export declare function getEffectiveRootDir(explicitRootDir: string | undefined, fileNames: readonly string[] | undefined, cwd?: string): string | undefined;

package/lib/compiler/helpers/get-effective-root-dir.js

@@ -0,0 +1,56 @@
+import { dirname, isAbsolute, normalize, resolve, sep } from 'path';
+/**
+ * Computes the effective TypeScript rootDir for an emit, mirroring how the
+ * TypeScript compiler determines it when `rootDir` is not set in tsconfig.
+ *
+ * When `rootDir` is explicitly configured, its absolute, normalized form is
+ * returned. Otherwise the longest common parent directory of the input file
+ * list is used (the same heuristic TypeScript applies through
+ * `Program#getCommonSourceDirectory`).
+ *
+ * Returns `undefined` if no rootDir can be determined (e.g. no input files).
+ *
+ * @param explicitRootDir Value of `compilerOptions.rootDir` from tsconfig, if any.
+ * @param fileNames List of TypeScript input files (absolute paths).
+ * @param cwd Current working directory used to resolve relative paths.
+ */
+export function getEffectiveRootDir(explicitRootDir, fileNames, cwd = process.cwd()) {
+    if (explicitRootDir) {
+        return normalize(isAbsolute(explicitRootDir)
+            ? explicitRootDir
+            : resolve(cwd, explicitRootDir));
+    }
+    if (!fileNames || fileNames.length === 0) {
+        return undefined;
+    }
+    // Declaration files are excluded from the common source directory, matching
+    // TypeScript: they produce no emit, so a `typings/**/*.d.ts` entry outside
+    // `src` must not drag the computed root up to the project root and push
+    // every copied asset into a `dist/src` subdirectory.
+    const emittedFiles = fileNames.filter((file) => !isDeclarationFileName(file));
+    if (emittedFiles.length === 0) {
+        return undefined;
+    }
+    const absolutePaths = emittedFiles.map((file) => normalize(isAbsolute(file) ? file : resolve(cwd, file)));
+    let commonDir = dirname(absolutePaths[0]);
+    for (let i = 1; i < absolutePaths.length; i++) {
+        commonDir = commonParentDir(commonDir, dirname(absolutePaths[i]));
+        if (!commonDir) {
+            return undefined;
+        }
+    }
+    return commonDir;
+}
+function isDeclarationFileName(fileName) {
+    return /\.d\.[cm]?ts$/i.test(fileName);
+}
+function commonParentDir(a, b) {
+    const aSegments = a.split(sep);
+    const bSegments = b.split(sep);
+    const length = Math.min(aSegments.length, bSegments.length);
+    let i = 0;
+    while (i < length && aSegments[i] === bSegments[i]) {
+        i++;
+    }
+    return aSegments.slice(0, i).join(sep);
+}

package/lib/compiler/helpers/get-rspack-config-path.d.ts

@@ -0,0 +1,10 @@
+import { Configuration } from '../../configuration/index.js';
+/**
+ * Returns the path to the rspack configuration file to use for the given application.
+ * CLI option `rspackPath` takes precedence over the configuration file.
+ * @param configuration Configuration object.
+ * @param cmdOptions Command line options.
+ * @param appName Application name.
+ * @returns The path to the rspack configuration file to use.
+ */
+export declare function getRspackConfigPath(configuration: Required<Configuration>, cmdOptions: Record<string, any>, appName: string | undefined): string | undefined;

package/lib/compiler/helpers/get-rspack-config-path.js

@@ -0,0 +1,19 @@
+import { getValueOrDefault } from './get-value-or-default.js';
+/**
+ * Returns the path to the rspack configuration file to use for the given application.
+ * CLI option `rspackPath` takes precedence over the configuration file.
+ * @param configuration Configuration object.
+ * @param cmdOptions Command line options.
+ * @param appName Application name.
+ * @returns The path to the rspack configuration file to use.
+ */
+export function getRspackConfigPath(configuration, cmdOptions, appName) {
+    if (cmdOptions?.rspackPath) {
+        return cmdOptions.rspackPath;
+    }
+    const builder = getValueOrDefault(configuration, 'compilerOptions.builder', appName);
+    const rspackPath = typeof builder === 'object' && builder?.type === 'rspack'
+        ? builder.options?.configPath
+        : undefined;
+    return rspackPath;
+}

package/lib/compiler/helpers/get-tsc-config.path.d.ts

@@ -1,5 +1,4 @@
-import { Input } from '../../../commands';
-import { Configuration } from '../../configuration';
+import { Configuration } from '../../configuration/index.js';
 /**
  * Returns the path to the tsc configuration file to use for the given application.
  * @param configuration Configuration object.
@@ -7,4 +6,4 @@ import { Configuration } from '../../configuration';
  * @param appName Application name.
  * @returns The path to the tsc configuration file to use.
  */
-export declare function getTscConfigPath(configuration: Required<Configuration>, cmdOptions: Input[], appName: string | undefined): string;
+export declare function getTscConfigPath(configuration: Required<Configuration>, cmdOptions: Record<string, any>, appName: string | undefined): string;

package/lib/compiler/helpers/get-tsc-config.path.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTscConfigPath = getTscConfigPath;
-const get_default_tsconfig_path_1 = require("../../utils/get-default-tsconfig-path");
-const get_value_or_default_1 = require("./get-value-or-default");
+import { getDefaultTsconfigPath } from '../../utils/get-default-tsconfig-path.js';
+import { getValueOrDefault } from './get-value-or-default.js';
 /**
  * Returns the path to the tsc configuration file to use for the given application.
  * @param configuration Configuration object.
@@ -10,15 +7,15 @@ const get_value_or_default_1 = require("./get-value-or-default");
  * @param appName Application name.
  * @returns The path to the tsc configuration file to use.
  */
-function getTscConfigPath(configuration, cmdOptions, appName) {
-    let tsconfigPath = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'compilerOptions.tsConfigPath', appName, 'path', cmdOptions);
+export function getTscConfigPath(configuration, cmdOptions, appName) {
+    let tsconfigPath = getValueOrDefault(configuration, 'compilerOptions.tsConfigPath', appName, 'path', cmdOptions);
     if (tsconfigPath) {
         return tsconfigPath;
     }
-    const builder = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'compilerOptions.builder', appName);
+    const builder = getValueOrDefault(configuration, 'compilerOptions.builder', appName);
     tsconfigPath =
         typeof builder === 'object' && builder?.type === 'tsc'
             ? builder.options?.configPath
             : undefined;
-    return tsconfigPath ?? (0, get_default_tsconfig_path_1.getDefaultTsconfigPath)();
+    return tsconfigPath ?? getDefaultTsconfigPath();
 }

package/lib/compiler/helpers/get-value-or-default.d.ts

@@ -1,4 +1,3 @@
-import { Input } from '../../../commands';
-import { Configuration } from '../../configuration';
-export declare function getValueOrDefault<T = any>(configuration: Required<Configuration>, propertyPath: string, appName: string | undefined, key?: 'path' | 'webpack' | 'webpackPath' | 'entryFile' | 'sourceRoot' | 'exec' | 'builder' | 'typeCheck', options?: Input[], defaultValue?: T): T;
+import { Configuration } from '../../configuration/index.js';
+export declare function getValueOrDefault<T = any>(configuration: Required<Configuration>, propertyPath: string, appName: string | undefined, key?: 'path' | 'webpack' | 'webpackPath' | 'entryFile' | 'sourceRoot' | 'exec' | 'builder' | 'typeCheck' | 'emitDeclarations', options?: Record<string, any>, defaultValue?: T): T;
 export declare function getValueOfPath<T = any>(object: Record<string, any>, propertyPath: string): T;

package/lib/compiler/helpers/get-value-or-default.js

@@ -1,10 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getValueOrDefault = getValueOrDefault;
-exports.getValueOfPath = getValueOfPath;
-function getValueOrDefault(configuration, propertyPath, appName, key, options = [], defaultValue) {
-    const item = options.find((option) => option.name === key);
-    const origValue = item && item.value;
+export function getValueOrDefault(configuration, propertyPath, appName, key, options = {}, defaultValue) {
+    const origValue = key != null ? options[key] : undefined;
     if (origValue !== undefined && origValue !== null) {
         return origValue;
     }
@@ -23,7 +18,7 @@ function getValueOrDefault(configuration, propertyPath, appName, key, options =
     }
     return value;
 }
-function getValueOfPath(object, propertyPath) {
+export function getValueOfPath(object, propertyPath) {
     const fragments = propertyPath.split('.');
     let propertyValue = object;
     let isConcatInProgress = false;

package/lib/compiler/helpers/get-webpack-config-path.d.ts

@@ -1,5 +1,4 @@
-import { Input } from '../../../commands';
-import { Configuration } from '../../configuration';
+import { Configuration } from '../../configuration/index.js';
 /**
  * Returns the path to the webpack configuration file to use for the given application.
  * @param configuration Configuration object.
@@ -7,4 +6,4 @@ import { Configuration } from '../../configuration';
  * @param appName Application name.
  * @returns The path to the webpack configuration file to use.
  */
-export declare function getWebpackConfigPath(configuration: Required<Configuration>, cmdOptions: Input[], appName: string | undefined): string | undefined;
+export declare function getWebpackConfigPath(configuration: Required<Configuration>, cmdOptions: Record<string, any>, appName: string | undefined): string | undefined;

package/lib/compiler/helpers/get-webpack-config-path.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getWebpackConfigPath = getWebpackConfigPath;
-const get_value_or_default_1 = require("./get-value-or-default");
+import { getValueOrDefault } from './get-value-or-default.js';
 /**
  * Returns the path to the webpack configuration file to use for the given application.
  * @param configuration Configuration object.
@@ -9,12 +6,12 @@ const get_value_or_default_1 = require("./get-value-or-default");
  * @param appName Application name.
  * @returns The path to the webpack configuration file to use.
  */
-function getWebpackConfigPath(configuration, cmdOptions, appName) {
-    let webpackPath = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'compilerOptions.webpackConfigPath', appName, 'webpackPath', cmdOptions);
+export function getWebpackConfigPath(configuration, cmdOptions, appName) {
+    let webpackPath = getValueOrDefault(configuration, 'compilerOptions.webpackConfigPath', appName, 'webpackPath', cmdOptions);
     if (webpackPath) {
         return webpackPath;
     }
-    const builder = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'compilerOptions.builder', appName);
+    const builder = getValueOrDefault(configuration, 'compilerOptions.builder', appName);
     if (typeof builder === 'object' && builder?.type === 'webpack') {
         const webpackConfigPath = builder.options?.configPath;
         if (webpackConfigPath) {

package/lib/compiler/helpers/glob.d.ts

@@ -0,0 +1,19 @@
+export interface GlobSyncOptions {
+    /** A single glob pattern; every path matching it is removed from the result. */
+    ignore?: string;
+    /** When true, `*` and `**` also match entries whose name starts with a dot. */
+    dot?: boolean;
+}
+export interface GlobEntry {
+    /** Absolute path, always `/`-separated regardless of platform. */
+    path: string;
+    isFile: boolean;
+    isDirectory: boolean;
+}
+/**
+ * Expands `pattern` to every matching path, with the type of each entry.
+ * See the file header for the compatibility rules this preserves.
+ */
+export declare function globEntriesSync(pattern: string, options?: GlobSyncOptions): GlobEntry[];
+/** Expands `pattern` to every matching path. */
+export declare function globSync(pattern: string, options?: GlobSyncOptions): string[];