@nizza/devkit 0.1.0-alpha.2 → 0.1.0-alpha.3

package/dist/{src → esm}/vite/config-builder/configs/base.js

@@ -1,40 +1,38 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "getBaseConfig", {
-    enumerable: true,
-    get: function() {
-        return getBaseConfig;
-    }
-});
-const _plugins = require("../plugins");
-const _shared = require("../shared");
-const _fs = require("fs");
-const _path = require("path");
+import { bundleAnalysisPlugin, basePlugins } from '../plugins.js';
+import { Target, ViteMode, Flag, Stage } from '../shared/types.js';
+import { getPlugins, when } from '../shared/utils/helpers.js';
+import 'minimatch';
+import '../../../shared/logger.js';
+import '@nx/devkit';
+import { existsSync } from 'fs';
+import { resolve } from 'path';
+import 'chalk';
+import 'mri';
+import 'vite';
+
 const getBaseConfig = (ctx)=>{
     const { commonConfig, projectConfig, viteCmd } = ctx;
     const { resolveEnvs, path } = projectConfig;
     const { stage, target, flags: cmdOverrides } = viteCmd;
-    const NODE_ENV = target === _shared.Target.BUILD ? _shared.ViteMode.PROD : _shared.ViteMode.DEV;
-    const sourcemap = cmdOverrides?.[_shared.Flag.SOURCEMAP] ?? stage !== _shared.Stage.PROD;
+    const NODE_ENV = target === Target.BUILD ? ViteMode.PROD : ViteMode.DEV;
+    const sourcemap = cmdOverrides?.[Flag.SOURCEMAP] ?? stage !== Stage.PROD;
     const envPrefix = `${commonConfig.envPrefix.toUpperCase()}_`;
     const omittedStages = resolveEnvs.local ? [
-        _shared.Stage.DEV
+        Stage.DEV
     ] : [
-        _shared.Stage.DEV,
-        _shared.Stage.LOCAL
+        Stage.DEV,
+        Stage.LOCAL
     ];
     const envPath = `environments/environment.${stage}.ts`;
     const fallbackEnvPath = `environments/environment.ts`;
     // Verify if the local Environment file is present
-    const envFilePath = (0, _fs.existsSync)((0, _path.resolve)(path, 'src', envPath)) ? envPath : fallbackEnvPath;
+    const envFilePath = existsSync(resolve(path, 'src', envPath)) ? envPath : fallbackEnvPath;
     return {
         envPrefix,
-        plugins: (0, _shared.getPlugins)(ctx, _plugins.basePlugins, _plugins.bundleAnalysisPlugin),
+        plugins: getPlugins(ctx, basePlugins, bundleAnalysisPlugin),
         resolve: {
             alias: {
-                ...(0, _shared.when)(resolveEnvs.default && !omittedStages.includes(stage), {
+                ...when(resolveEnvs.default && !omittedStages.includes(stage), {
                     '~env': envFilePath
                 })
             }
@@ -53,3 +51,5 @@ const getBaseConfig = (ctx)=>{
         }
     };
 };
+
+export { getBaseConfig };

package/dist/esm/vite/config-builder/configs/index.d.ts

@@ -0,0 +1,7 @@
+import { ProjectType, Context } from "../../../index-f6330edc.js";
+declare const getConfig: (ctx: Context, type?: ProjectType | null) => import("vite").UserConfig;
+export * from "./app.js";
+export * from "./base.js";
+export * from "./lib.js";
+export * from "./script.js";
+export { getConfig };

package/dist/esm/vite/config-builder/configs/index.js

@@ -0,0 +1,30 @@
+import { ProjectType } from '../shared/types.js';
+import '@nx/devkit';
+import 'nanoid';
+import 'path';
+import 'ramda';
+import 'minimatch';
+import '../../../shared/logger.js';
+import 'fs';
+import 'chalk';
+import 'mri';
+import 'vite';
+import { getAppConfig } from './app.js';
+import { getBaseConfig } from './base.js';
+import { getLibConfig } from './lib.js';
+import { getScriptConfig } from './script.js';
+
+const getConfig = (ctx, type = null)=>{
+    switch(type){
+        case ProjectType.APP:
+            return getAppConfig(ctx);
+        case ProjectType.LIB:
+            return getLibConfig(ctx);
+        case ProjectType.SCRIPT:
+            return getScriptConfig(ctx);
+        default:
+            return getBaseConfig(ctx);
+    }
+};
+
+export { getAppConfig, getBaseConfig, getConfig, getLibConfig, getScriptConfig };

package/dist/esm/vite/config-builder/configs/lib.d.ts

@@ -0,0 +1,4 @@
+import { UserConfig } from 'vite';
+import { Context } from "../../../index-f6330edc.js";
+declare const getLibConfig: (ctx: Context) => UserConfig;
+export { getLibConfig };

package/dist/{src → esm}/vite/config-builder/configs/lib.js

@@ -1,34 +1,30 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "getLibConfig", {
-    enumerable: true,
-    get: function() {
-        return getLibConfig;
-    }
-});
-const _path = require("path");
-const _plugins = require("../plugins");
-const _shared = require("../shared");
+import { resolve } from 'path';
+import { dtsPlugin } from '../plugins.js';
+import '../shared/types.js';
+import { when, getPlugins } from '../shared/utils/helpers.js';
+import { getExternalDependencies } from '../shared/utils/projectConfig.js';
+import 'chalk';
+import 'mri';
+import 'vite';
+
 const getLibConfig = (ctx)=>{
     const { projectConfig, commonConfig } = ctx;
     const { externalizeLibGlob = [] } = commonConfig;
     const { name, path, externalizeLibs } = projectConfig;
-    const entry = (0, _path.resolve)(path, projectConfig.entry ?? 'src/index.ts');
+    const entry = resolve(path, projectConfig.entry ?? 'src/index.ts');
     const defaultExternals = {
         react: true,
         'react-dom': true,
         'react/jsx-runtime': true
     };
     // Get external dependencies based on glob patterns
-    const externalDeps = (0, _shared.getExternalDependencies)(path, [
+    const externalDeps = getExternalDependencies(path, [
         ...externalizeLibGlob,
         ...externalizeLibs.glob
     ]);
     const rollupExternal = [
         ...externalDeps,
-        ...Object.keys((0, _shared.when)(externalizeLibs.default, defaultExternals))
+        ...Object.keys(when(externalizeLibs.default, defaultExternals))
     ];
     const rollupGlobals = {
         react: 'React',
@@ -36,7 +32,7 @@ const getLibConfig = (ctx)=>{
         'react/jsx-runtime': 'ReactJsxRuntime'
     };
     return {
-        plugins: (0, _shared.getPlugins)(ctx, _plugins.dtsPlugin),
+        plugins: getPlugins(ctx, dtsPlugin),
         build: {
             lib: {
                 name,
@@ -49,9 +45,11 @@ const getLibConfig = (ctx)=>{
             rollupOptions: {
                 external: rollupExternal,
                 output: {
-                    globals: (0, _shared.when)(externalizeLibs.default, rollupGlobals)
+                    globals: when(externalizeLibs.default, rollupGlobals)
                 }
             }
         }
     };
 };
+
+export { getLibConfig };

package/dist/esm/vite/config-builder/configs/script.d.ts

@@ -0,0 +1,4 @@
+import { UserConfig } from 'vite';
+import { Context } from "../../../index-f6330edc.js";
+declare const getScriptConfig: (ctx: Context) => UserConfig;
+export { getScriptConfig };

package/dist/esm/vite/config-builder/configs/script.js

@@ -0,0 +1,43 @@
+import { resolve } from 'path';
+import { injectCssByJsPlugin, injectCssIntoShadowDomPlugin } from '../plugins.js';
+import '../shared/types.js';
+import { getPlugins, chunkName } from '../shared/utils/helpers.js';
+import 'minimatch';
+import '../../../shared/logger.js';
+import '@nx/devkit';
+import 'fs';
+import 'chalk';
+import 'mri';
+import 'vite';
+
+const getScriptConfig = (ctx)=>{
+    const { commonConfig, projectConfig } = ctx;
+    const { envPrefix } = commonConfig;
+    const { port } = projectConfig;
+    const { name, path, fileName, chunkPrefix } = projectConfig;
+    const entry = resolve(path, projectConfig.entry ?? 'src/main');
+    return {
+        plugins: getPlugins(ctx, injectCssIntoShadowDomPlugin, injectCssByJsPlugin),
+        server: {
+            port,
+            host: true
+        },
+        build: {
+            lib: {
+                name,
+                entry,
+                fileName,
+                formats: [
+                    'es'
+                ]
+            },
+            rollupOptions: {
+                output: {
+                    chunkFileNames: chunkName(`${envPrefix}-${chunkPrefix}`)
+                }
+            }
+        }
+    };
+};
+
+export { getScriptConfig };

package/dist/esm/vite/config-builder/main.d.ts

@@ -0,0 +1,10 @@
+import { UserConfig } from 'vite';
+import { CommonProjectConfig, ProjectConfig } from "../../index-f6330edc.js";
+/**
+ * Builds the configuration based on common and project-specific configurations.
+ *
+ * @param {CommonProjectConfig} commonConfig - The common configuration.
+ * @returns - Returns a function that accepts a project configuration and returns the Vite configuration.
+ */
+declare const createConfigBuilder: (commonConfig: CommonProjectConfig) => (projectConfig: ProjectConfig) => UserConfig;
+export { createConfigBuilder };

package/dist/esm/vite/config-builder/main.js

@@ -0,0 +1,41 @@
+import { defineConfig } from 'vite';
+import { currentLogLevel, LogLevel, logger } from '../../shared/logger.js';
+import { getPkgJson } from '../../shared/utils.js';
+import { getConfig } from './configs/index.js';
+import './shared/types.js';
+import '@nx/devkit';
+import 'nanoid';
+import 'path';
+import 'ramda';
+import { initializeConfig, mergeConfigs } from './shared/utils/projectConfig.js';
+import 'chalk';
+import 'mri';
+
+/**
+ * Builds the configuration based on common and project-specific configurations.
+ *
+ * @param {CommonProjectConfig} commonConfig - The common configuration.
+ * @returns - Returns a function that accepts a project configuration and returns the Vite configuration.
+ */ const createConfigBuilder = (commonConfig)=>(projectConfig)=>{
+        try {
+            const localPkgJson = getPkgJson(projectConfig.path);
+            const { cfg, viteCmd } = initializeConfig(commonConfig, projectConfig, localPkgJson);
+            const isDebug = currentLogLevel === LogLevel.DEBUG;
+            const { type, overrides } = cfg;
+            const ctx = {
+                viteCmd,
+                localPkgJson,
+                commonConfig,
+                projectConfig: cfg
+            };
+            const defaultConfig = mergeConfigs(getConfig(ctx), getConfig(ctx, type));
+            const config = mergeConfigs(defaultConfig, overrides);
+            if (isDebug) logger.debug('Generated config:', config);
+            return defineConfig(config);
+        } catch (err) {
+            logger.error('buildConfig unexpected error:');
+            throw err;
+        }
+    };
+
+export { createConfigBuilder };

package/dist/esm/vite/config-builder/plugins.d.ts

@@ -0,0 +1,30 @@
+import { PluginConfig } from "../../index-f6330edc.js";
+/**
+ * Base plugins configuration for apps and libs.
+ *
+ * Plugins configured:
+ * - vite-tsconfig-paths
+ * - @originjs/vite-plugin-commonjs
+ * - @rollup/plugin-graphql
+ * - @vitejs/plugin-react-swc
+ */
+declare const basePlugins: PluginConfig;
+/**
+ * Plugin configuration for generating type declarations using vite-plugin-dts.
+ */
+declare const dtsPlugin: PluginConfig;
+/**
+ * Plugin configuration for bundle analysis using rollup-plugin-visualizer.
+ */
+declare const bundleAnalysisPlugin: PluginConfig;
+/**
+ * Plugin configuration for injecting CSS into JS files
+ * using vite-plugin-css-injected-by-js.
+ */
+declare const injectCssByJsPlugin: PluginConfig;
+/**
+ * Plugin configuration for injecting CSS into Shadow Dom.
+ * using local plugin.
+ */
+declare const injectCssIntoShadowDomPlugin: PluginConfig;
+export { basePlugins, dtsPlugin, bundleAnalysisPlugin, injectCssByJsPlugin, injectCssIntoShadowDomPlugin };

package/dist/esm/vite/config-builder/plugins.js

@@ -0,0 +1,89 @@
+import { viteCommonjs } from '@originjs/vite-plugin-commonjs';
+import graphql from '@rollup/plugin-graphql';
+import react from '@vitejs/plugin-react-swc';
+import { resolve } from 'path';
+import { visualizer } from 'rollup-plugin-visualizer';
+import cssInjectedByJsPlugin from 'vite-plugin-css-injected-by-js';
+import dts from 'vite-plugin-dts';
+import tsconfigPaths from 'vite-tsconfig-paths';
+import 'vite';
+import { injectCssIntoShadowDom } from '../plugins/shadow-dom-inject-css/index.js';
+import { Stage, Flag } from './shared/types.js';
+import { getNxTsConfigPaths } from './shared/utils/helpers.js';
+import 'minimatch';
+import '../../shared/logger.js';
+import '@nx/devkit';
+import 'fs';
+import 'chalk';
+import 'mri';
+
+/**
+ * Base plugins configuration for apps and libs.
+ *
+ * Plugins configured:
+ * - vite-tsconfig-paths
+ * - @originjs/vite-plugin-commonjs
+ * - @rollup/plugin-graphql
+ * - @vitejs/plugin-react-swc
+ */ const basePlugins = {
+    generate: ({ projectConfig })=>{
+        const projects = getNxTsConfigPaths();
+        return [
+            // tsconfigPaths({
+            //   projects: tsConfigPaths.map(x => resolve(process.cwd(), x)),
+            // }),
+            tsconfigPaths({
+                projects
+            }),
+            viteCommonjs(),
+            graphql(),
+            react({
+                tsDecorators: true
+            })
+        ];
+    }
+};
+/**
+ * Plugin configuration for generating type declarations using vite-plugin-dts.
+ */ const dtsPlugin = {
+    generate: ({ projectConfig })=>[
+            dts({
+                tsconfigPath: resolve(projectConfig.path, 'tsconfig.lib.json'),
+                outDir: resolve(projectConfig.path, 'dist'),
+                entryRoot: resolve(projectConfig.path, 'src')
+            })
+        ],
+    condition: ({ projectConfig, viteCmd })=>viteCmd.stage !== Stage.LOCAL && projectConfig.dts == null ? true : !!projectConfig.dts
+};
+/**
+ * Plugin configuration for bundle analysis using rollup-plugin-visualizer.
+ */ const bundleAnalysisPlugin = {
+    generate: ({ projectConfig })=>[
+            visualizer({
+                emitFile: true,
+                projectRoot: resolve(projectConfig.path, 'dist'),
+                filename: 'bundle-analysis.html'
+            })
+        ],
+    condition: ({ viteCmd })=>viteCmd.flags?.[Flag.ANALYZE] === 'true'
+};
+/**
+ * Plugin configuration for injecting CSS into JS files
+ * using vite-plugin-css-injected-by-js.
+ */ const injectCssByJsPlugin = {
+    generate: (_)=>[
+            cssInjectedByJsPlugin()
+        ],
+    condition: ({ projectConfig })=>!projectConfig.shadowDom
+};
+/**
+ * Plugin configuration for injecting CSS into Shadow Dom.
+ * using local plugin.
+ */ const injectCssIntoShadowDomPlugin = {
+    generate: (_)=>[
+            injectCssIntoShadowDom()
+        ],
+    condition: ({ projectConfig })=>projectConfig.shadowDom
+};
+
+export { basePlugins, bundleAnalysisPlugin, dtsPlugin, injectCssByJsPlugin, injectCssIntoShadowDomPlugin };

package/dist/esm/vite/config-builder/shared/types.d.ts

@@ -0,0 +1,155 @@
+import { ConfigEnv, LibraryOptions, UserConfig } from 'vite';
+import { LogLevel } from "../../../index-17143e35.js";
+declare enum ViteMode {
+    PROD = "production",
+    DEV = "development"
+}
+/**
+ * Project stages, it coincides with the target configurations of the project.json of NX.
+ * @readonly
+ * @enum {string}
+ */
+declare enum Stage {
+    PROD = "prod",
+    DEV = "dev",
+    STAGING = "staging",
+    LOCAL = "local"
+}
+declare enum ProjectType {
+    APP = "app",
+    LIB = "lib",
+    SCRIPT = "script"
+}
+declare enum Flag {
+    SOURCEMAP = "source-maps",
+    ANALYZE = "analyze",
+    VERBOSE = "verbose",
+    VERBOSE_ALIAS = "v"
+}
+declare enum Target {
+    BUILD = "build",
+    PREVIEW = "preview",
+    SERVE = "serve"
+}
+/**
+ * Vite Environment.
+ *
+ * @property {ViteMode} mode - Vite mode.
+ */
+type ViteEnv = ConfigEnv & {
+    mode: ViteMode;
+};
+/**
+ * Externalizing libraries.
+ *
+ * @property {boolean} default - React externalizes and other common dependencies,
+ * this only applies to libraries.
+ * @property {boolean} glob - Glob expression or list of glob expressions to exclude
+ * dependencies from the package.json.
+ */
+type ExternalizeLibs = {
+    default: boolean;
+    glob: string | string[];
+};
+type ResolveEnvs = {
+    default: boolean;
+    local: boolean;
+};
+/**
+ * Project configuration.
+ *
+ * @property {ProjectType} type - Type of the project.
+ * @property {string} path - Path of the project.
+ * @property {string} entry - Path of the file entry point.
+ * @property {string} name - Name of the project, it is also used to define the name of the library.
+ * @property {string} port - Server port.
+ * @property {boolean} debug - Print data purification data.
+ * @property {boolean} dts - Control if the .d.ts files are generated, by default it is True.
+ * @property {Partial<ResolveEnvs>} resolveEnvs - Flag for resolving environment.
+ * @property {boolean} shadowDom - If component is render into shadow dom.
+ * @property {Partial<ExternalizeLibs>} externalizeLibs - Configuration for externalizing libraries.
+ * @property {LibraryOptions['fileName']} fileName - Output file name for library.
+ * @property {string} fileName - Prefix for chunk file name.
+ * @property {ViteEnv} viteEnv - Vite environment configuration.
+ * @property {UserConfig} overrides - Overrides for vite configuration.
+ */
+interface ProjectConfig {
+    type: ProjectType;
+    path: string;
+    entry?: string;
+    name?: string;
+    port?: number;
+    logLevel?: LogLevel;
+    dts?: boolean;
+    resolveEnvs?: Partial<ResolveEnvs>;
+    shadowDom?: boolean;
+    externalizeLibs?: Partial<ExternalizeLibs>;
+    fileName?: LibraryOptions['fileName'];
+    chunkPrefix?: string;
+    viteEnv: ViteEnv;
+    overrides?: UserConfig;
+}
+interface ProjectConfigInitialized extends ProjectConfig {
+    name: string;
+    fileName: string;
+    chunkPrefix: string;
+    logLevel: LogLevel;
+    overrides: UserConfig;
+    shadowDom: boolean;
+    resolveEnvs: ResolveEnvs;
+    externalizeLibs: ExternalizeLibs;
+}
+/**
+ * Vite command details.
+ * @interface
+ * @property {Stage} stage - Stage of the project.
+ * @property {string} target - Command name.
+ * @property {Record<string, any>} flags - Flags for customize command.
+ */
+interface ViteCommand {
+    stage: Stage;
+    target: string;
+    flags: Record<string, any>;
+}
+/**
+ * Common project configuration.
+ *
+ * @property {string} envPrefix - Prefix in lowercase for environment variables and output files.
+ * @property {boolean} externalizeLibGlob - Glob expression or list of glob expressions to exclude
+ * dependencies from the package.json.
+ */
+interface CommonProjectConfig {
+    envPrefix: string;
+    externalizeLibGlob?: string | string[];
+}
+/**
+ * Config builder context.
+ *
+ * @property {CommonProjectConfig} commonConfig - Common configuration for the project.
+ * @property {ProjectConfigInitialized} projectConfig - Initialized project configuration.
+ * @property {ViteCommandDetail} viteCmd - Vite command details.
+ */
+interface Context {
+    commonConfig: CommonProjectConfig;
+    projectConfig: ProjectConfigInitialized;
+    viteCmd: ViteCommand;
+    localPkgJson: Record<string, any>;
+}
+/**
+ * Interface for plugin configuration.
+ */
+interface PluginConfig {
+    /**
+     * Generates plugin(s) based on the provided configuration.
+     * @param {Context} ctx - The main configuration object.
+     * @returns {any[]} An array of plugins.
+     */
+    generate: (ctx: Context) => any[];
+    /**
+     * Condition to determine if the plugin(s) should be included.
+     * @param {Context} ctx - The main configuration object.
+     * @returns {boolean} True if the plugin(s) should be included; false otherwise.
+     */
+    condition?: (ctx: Context) => boolean;
+}
+export { ViteMode, Stage, ProjectType, Flag, Target, ViteEnv, ExternalizeLibs, ResolveEnvs, ProjectConfig, ProjectConfigInitialized, ViteCommand, CommonProjectConfig, Context, PluginConfig };

package/dist/{src → esm}/vite/config-builder/shared/types.js

@@ -1,30 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    Flag: function() {
-        return Flag;
-    },
-    ProjectType: function() {
-        return ProjectType;
-    },
-    Stage: function() {
-        return Stage;
-    },
-    Target: function() {
-        return Target;
-    },
-    ViteMode: function() {
-        return ViteMode;
-    }
-});
 var ViteMode;
 (function(ViteMode) {
     ViteMode["PROD"] = "production";
@@ -56,3 +29,5 @@ var Target;
     Target["PREVIEW"] = "preview";
     Target["SERVE"] = "serve";
 })(Target || (Target = {}));
+
+export { Flag, ProjectType, Stage, Target, ViteMode };

package/dist/esm/vite/config-builder/shared/utils/helpers.d.ts

@@ -0,0 +1,81 @@
+import { PreRenderedChunk } from 'rollup';
+import { PluginOption } from 'vite';
+import { Context, PluginConfig } from "../types.js";
+/**
+ * Generates a short ID string.
+ *
+ * @param {number} length - The length of the ID to generate.
+ * @returns {string} - The generated ID.
+ *
+ * @example
+ * const id = shortId(10);  // Outputs: "Aj3_Dk7_2j"
+ */
+declare const shortId: (length: number) => string;
+/**
+ * Deeply merges two objects, combining their properties.
+ *
+ * @param {Record<string, any>} v1 - The first object.
+ * @param {Record<string, any>} v2 - The second object.
+ * @returns {Record<string, any>} - The merged object.
+ *
+ * @example
+ * const obj1 = { a: 1, b: { c: 2 } };
+ * const obj2 = { b: { d: 3 } };
+ * const merged = deepMerge(obj1, obj2);  // Outputs: { a: 1, b: { c: 2, d: 3 } }
+ */
+declare function deepMerge(v1: Record<string, any>, v2: Record<string, any>): Record<string, any>;
+/**
+ * Generates a name for js files.
+ *
+ * @param {string} [prefix] - An optional prefix for the chunk name.
+ * @returns - A function that takes an item and generates a chunk name.
+ *
+ * @example
+ * const generateChunkName = chunkName('prefix');
+ * const name = generateChunkName({ name: 'example' });  // Outputs: "prefix-example-Aj3_Dk7_2j.js"
+ */
+declare const chunkName: (prefix?: string) => (x: PreRenderedChunk) => string;
+/**
+ * Returns the given object if the condition is true, otherwise returns null.
+ *
+ * @param {any} condition - The condition to evaluate.
+ * @param {Record<string, any>} obj - The object to return if the condition is true.
+ * @returns {Record<string, any> | null} - The object or null based on the condition.
+ *
+ * @example
+ * const obj = { a: 1 };
+ * const result = when(true, obj);  // Outputs: { a: 1 }
+ * const result2 = when(false, obj);  // Outputs: {}
+ */
+declare const when: (condition: any, obj: Record<string, any>) => Record<string, any>;
+/**
+ * Filters and generates plugin configurations based on conditions and the provided context.
+ *
+ * @param {Context} ctx - The main configuration object.
+ * @returns {any[]} - An array of generated plugin configurations.
+ */
+declare const getPlugins: (ctx: Context, ...pluginConfigs: PluginConfig[]) => PluginOption[];
+/**
+ * Gets the paths to the tsconfig files for all relevant projects.
+ *
+ * @returns {string[]} - An array containing paths to tsconfig files for both app and lib projects.
+ *
+ * @example
+ * const projects = {
+ *   'my-app': {
+ *     type: 'app',
+ *     data: { root: 'apps/my-app' }
+ *   },
+ *   'my-lib': {
+ *     type: 'lib',
+ *     data: { root: 'libs/my-lib' }
+ *   }
+ * };
+ *
+ * const tsConfigPaths = getTsConfigPaths(projects);
+ * console.log(tsConfigPaths);
+ * // Output:
+ * // ['apps/my-app/tsconfig.app.json', 'libs/my-lib/tsconfig.lib.json']
+ */
+declare const getNxTsConfigPaths: () => string[];
+export { shortId, deepMerge, chunkName, when, getPlugins, getNxTsConfigPaths };