@nizza/devkit 0.1.0-alpha.1 → 0.1.0-alpha.11

package/dist/esm/vite-utils/config-builder/shared/utils/viteCommand.mjs

@@ -0,0 +1,56 @@
+import chalk from 'chalk';
+import argv from 'mri';
+import { loadEnv } from 'vite';
+import { ViteMode, Stage, Target } from '../types.mjs';
+
+/**
+ * Retrieves the Vite command details.
+ *
+ * @param {ViteMode} mode - The Vite mode.
+ * @returns {ViteCommand} - The command details.
+ *
+ * @example
+ * const command = getViteCommand(ViteMode.PROD);
+ * // Outputs: { stage: Stage.PROD, target: 'build', flags: {} }
+ */ function getViteCommand(mode) {
+    const nxEnv = loadEnv(mode, process.cwd(), 'NX');
+    const nxCommandString = process?.env?.['npm_package_scripts_nx'];
+    const modeIsProd = mode === ViteMode.PROD;
+    const stage = (nxEnv?.['NX_TASK_TARGET_CONFIGURATION']) ?? (modeIsProd ? Stage.PROD : Stage.DEV);
+    const target = nxEnv?.['NX_TASK_TARGET_TARGET'] ?? Target.BUILD;
+    const flags = getViteCmdFlags(nxCommandString);
+    const showIn = {
+        prod: (...args)=>modeIsProd && console.log(...args),
+        dev: (...args)=>!modeIsProd && console.log(...args)
+    };
+    try {
+        showIn.prod(chalk.cyan('Build Stage:'), chalk.green(stage));
+        showIn.dev(chalk.green('  ➜ '), chalk.bold.white(`Stage:  `), chalk.cyan(stage));
+    } catch  {
+        showIn.prod(console.log('Build Stage:', stage));
+        showIn.dev(console.log(`  ➜  Stage:  `, stage));
+    }
+    return {
+        stage,
+        target,
+        flags
+    };
+}
+/**
+ * Parses the command string to extract flags.
+ *
+ * @param {string | undefined} commandString - The command string.
+ * @returns {Record<string, string>} - The flags extracted from the command string.
+ *
+ * @example
+ * const flags = getViteCmdFlags('nx run core:build --source-maps');
+ * // Outputs: { 'source-maps: 'true' }
+ */ function getViteCmdFlags(commandString) {
+    if (!commandString) return {};
+    const cleanedCommandString = commandString.replace(/"/g, '');
+    const args = argv(cleanedCommandString.split(' '));
+    delete args['_'];
+    return args;
+}
+
+export { getViteCmdFlags, getViteCommand };

package/dist/esm/vite-utils/plugins/shadow-dom-inject-css/index.mjs

@@ -0,0 +1,27 @@
+function injectCssIntoShadowDom() {
+    const fileRegex = /\.(css)$/;
+    let server;
+    return {
+        name: 'nizza:inject-css-into-shadow-dom',
+        configureServer (_server) {
+            server = _server;
+        },
+        transform (src, id) {
+            if (server) {
+                const relativeId = /\/lib\/.*/.exec(id)?.[0].replace('/lib/', '');
+                if (fileRegex.test(id)) {
+                    server.ws.send({
+                        type: 'custom',
+                        event: 'inject-css-into-shadow-dom:hot-updated',
+                        data: {
+                            id: relativeId,
+                            content: src
+                        }
+                    });
+                }
+            }
+        }
+    };
+}
+
+export { injectCssIntoShadowDom };

package/dist/esm/vite-utils/plugins/third-party-css-inject/main.mjs

@@ -0,0 +1,45 @@
+import { removeLinkStyleSheets, buildCSSInjectionCode } from './utils.mjs';
+
+/**
+ * Inject the CSS compiled with JS.
+ *
+ * @return {Plugin}
+ */ function thirdPartyCssInjectPlugin({ topExecutionPriority, execute } = {
+    topExecutionPriority: true,
+    execute: []
+}) {
+    //Globally so we can add it to legacy and non-legacy bundle.
+    let config;
+    return {
+        apply: 'build',
+        enforce: 'post',
+        name: 'nizza:third-party-css-inject',
+        configResolved (_config) {
+            config = _config;
+        },
+        async generateBundle (opts, bundle) {
+            if (config.build.ssr) {
+                return;
+            }
+            const htmlFiles = Object.keys(bundle).filter((i)=>i.endsWith('.html'));
+            const cssAssets = Object.keys(bundle).filter((i)=>bundle[i]?.type == 'asset' && bundle[i]?.fileName.endsWith('.css'));
+            const jsAssets = Object.keys(bundle).filter((i)=>bundle[i]?.type == 'chunk' && bundle[i]?.fileName.match(/.[cm]?js$/) != null && !bundle[i]?.fileName.includes('polyfill'));
+            for (const name of htmlFiles){
+                const htmlChunk = bundle[name];
+                let replacedHtml = htmlChunk.source;
+                cssAssets.forEach((cssName)=>{
+                    replacedHtml = removeLinkStyleSheets(replacedHtml, cssName);
+                    htmlChunk.source = replacedHtml;
+                });
+            }
+            const jsAsset = bundle[jsAssets[0]];
+            const cssInjectionCode = await buildCSSInjectionCode(execute);
+            const appCode = jsAsset.code;
+            jsAsset.code = topExecutionPriority ? '' : appCode;
+            jsAsset.code += cssInjectionCode ? cssInjectionCode.code : '';
+            jsAsset.code += !topExecutionPriority ? '' : appCode;
+        }
+    };
+}
+
+export { thirdPartyCssInjectPlugin };

package/dist/esm/vite-utils/plugins/third-party-css-inject/utils.mjs

@@ -0,0 +1,97 @@
+import { build } from 'vite';
+
+const cssInjectedByJsId = '\0vite/all-css';
+const waitForElement = (selector, observerElementName = 'body')=>{
+    const getElement = (selector)=>document.querySelector(selector);
+    return new Promise((resolve)=>{
+        if (getElement(selector)) return resolve(getElement(selector));
+        const observer = new MutationObserver(()=>{
+            if (getElement(selector)) {
+                resolve(getElement(selector));
+                observer.disconnect();
+            }
+        });
+        let observerElement = document.body;
+        switch(observerElementName){
+            case 'body':
+                observerElement = document.body;
+                break;
+            case 'head':
+                observerElement = document.head;
+                break;
+            default:
+                observerElement = document.body;
+                break;
+        }
+        observer.observe(observerElement, {
+            childList: true,
+            subtree: true
+        });
+    });
+};
+async function buildCSSInjectionCode(execute) {
+    const res = await build({
+        root: '',
+        configFile: false,
+        logLevel: 'error',
+        plugins: [
+            injectionCSSCodePlugin(execute)
+        ],
+        build: {
+            write: false,
+            target: 'es2015',
+            minify: 'esbuild',
+            assetsDir: '',
+            rollupOptions: {
+                input: {
+                    'all-css': cssInjectedByJsId
+                },
+                output: {
+                    format: 'iife',
+                    manualChunks: undefined
+                }
+            }
+        }
+    });
+    const _cssChunk = Array.isArray(res) ? res[0] : res;
+    if (!('output' in _cssChunk)) return null;
+    return _cssChunk.output[0];
+}
+/**
+ * @param {string} cssToInject
+ * @param {string|null} styleId
+ * @return {Plugin}
+ */ function injectionCSSCodePlugin(execute) {
+    return {
+        name: 'vite:third-party-css-inject',
+        // @ts-ignore
+        resolveId (id) {
+            if (id == cssInjectedByJsId) {
+                return id;
+            }
+        },
+        // @ts-ignore
+        load (id) {
+            if (id == cssInjectedByJsId) {
+                let executeJs = [];
+                if (execute?.length) {
+                    executeJs = execute.map((executeData, index)=>{
+                        return `waitForElement('${executeData.observer}', '${executeData.listen}').then((elm)=>{
+              const extra${index}=${executeData.function};extra${index}(elm)
+            });`;
+                    });
+                }
+                return `try{if(typeof document != 'undefined'){
+        const waitForElement=${waitForElement.toString()};
+        ${executeJs.join(' ')}
+      }}catch(e){console.error('vite'-third-party-css-inject-plugin', e);}`;
+            }
+        }
+    };
+}
+function removeLinkStyleSheets(html, cssFileName) {
+    const removeCSS = new RegExp(`<link rel=".*"[^>]*?href=".*/?${cssFileName}"[^>]*?>`);
+    return html.replace(removeCSS, '');
+}
+
+export { buildCSSInjectionCode, removeLinkStyleSheets };

package/dist/index.d.ts

@@ -0,0 +1,367 @@
+// Generated by dts-bundle-generator v7.2.0
+
+import { ExecutorContext } from '@nx/devkit';
+import { PreRenderedChunk } from 'rollup';
+import { ConfigEnv, LibraryOptions, Plugin, PluginOption, UserConfig, ViteDevServer } from 'vite';
+
+export type ExecutorResponse = {
+	success: boolean;
+};
+export interface ExecutorOptions {
+	s3BucketPath: string;
+	cloudFrontDistributionId: string;
+	cloudFrontInvalidationPaths: string[];
+	buildTarget: string;
+	skipBuild?: boolean;
+}
+export function deployExecutor(opts: ExecutorOptions, ctx: ExecutorContext): Promise<ExecutorResponse>;
+export interface ExecutorOptions {
+}
+declare function runExecutor(_opts: ExecutorOptions, ctx: ExecutorContext): Promise<ExecutorResponse>;
+export interface ExecutorOptions {
+	tag: string;
+	dryRun?: boolean;
+}
+declare function runExecutor(opts: ExecutorOptions, ctx: ExecutorContext): Promise<ExecutorResponse>;
+export interface ExecutorOptions {
+}
+declare function runExecutor(_opts: ExecutorOptions, ctx: ExecutorContext): Promise<ExecutorResponse>;
+export interface ExecutorOptions {
+	packageOrg: string;
+	rollback?: boolean;
+	skipLink?: boolean;
+}
+declare function runExecutor(opts: ExecutorOptions, ctx: ExecutorContext): Promise<ExecutorResponse>;
+declare enum LogLevel {
+	ERROR = 0,
+	WARN = 1,
+	INFO = 2,
+	DEBUG = 3
+}
+export declare enum ViteMode {
+	PROD = "production",
+	DEV = "development"
+}
+/**
+ * Project stages, it coincides with the target configurations of the project.json of NX.
+ * @readonly
+ * @enum {string}
+ */
+export declare enum Stage {
+	PROD = "prod",
+	DEV = "dev",
+	STAGING = "staging",
+	LOCAL = "local"
+}
+export declare enum ProjectType {
+	APP = "app",
+	LIB = "lib",
+	SCRIPT = "script"
+}
+export declare enum Flag {
+	SOURCEMAP = "source-maps",
+	ANALYZE = "analyze",
+	VERBOSE = "verbose",
+	VERBOSE_ALIAS = "v"
+}
+export declare enum Target {
+	BUILD = "build",
+	PREVIEW = "preview",
+	SERVE = "serve"
+}
+/**
+ * Vite Environment.
+ *
+ * @property {ViteMode} mode - Vite mode.
+ */
+export 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.
+ */
+export type ExternalizeLibs = {
+	default: boolean;
+	glob: string | string[];
+};
+export 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.
+ */
+export 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;
+}
+export 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.
+ */
+export 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.
+ */
+export 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.
+ */
+export interface Context {
+	commonConfig: CommonProjectConfig;
+	projectConfig: ProjectConfigInitialized;
+	viteCmd: ViteCommand;
+	localPkgJson: Record<string, any>;
+}
+/**
+ * Interface for plugin configuration.
+ */
+export 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;
+}
+/**
+ * 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 } }
+ */
+export 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"
+ */
+export 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: {}
+ */
+export 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.
+ */
+export 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']
+ */
+export declare const getNxTsConfigPaths: () => string[];
+/**
+ * Initializes the project configuration with default values.
+ *
+ * @example
+ * const config = { type: ProjectType.APP, path: '/path/to/project', viteEnv: { mode: ViteMode.DEV } };
+ * const initializedConfig = initializeConfig(config);
+ */
+export declare const initializeConfig: (ccfg: CommonProjectConfig, pcfg: ProjectConfig, localPkgJson: Record<string, any>) => {
+	viteCmd: ViteCommand;
+	cfg: ProjectConfigInitialized;
+};
+/**
+ * Handles merging configurations and logs any errors.
+ *
+ * @param {UserConfig} defaultConfig - The default configuration.
+ * @param {UserConfig} overrides - The overrides configuration.
+ * @returns {UserConfig} - The merged configuration.
+ */
+export declare const mergeConfigs: (defaultConfig: UserConfig, overrides: UserConfig) => UserConfig;
+/**
+ * Resolves glob patterns to actual package names found in package.json dependencies.
+ * This function is used to determine which packages should be treated as external
+ * in a Rollup or Vite build configuration.
+ *
+ * @param {string} path - The base path where package.json is located.
+ * @param {string | string[]} globs - A glob pattern or an array of glob patterns to match dependencies against.
+ * @returns {string[]} An array of package names that match the given glob patterns.
+ *
+ * @example
+ * // Example of using `getExternalDependencies` to find all dependencies starting with "my-lib" and "lodash"
+ * const projectPath = '/path/to/project';
+ * const globs = ['my-lib*', 'lodash'];
+ * const externalDependencies = getExternalDependencies(projectPath, globs);
+ * console.log(externalDependencies);
+ * // Output might be: ['my-lib/utils', 'my-lib/core', 'lodash']
+ */
+export declare const getExternalDependencies: (path: string, globs?: string | string[]) => string[];
+/**
+ * Generates a string of initials based on the input string,
+ * following certain rules:
+ * 1. A word is considered as a sequence of characters
+ * separated by hyphens.
+ * 2. If the string contains '@', any characters before
+ * and including the next '/' are ignored.
+ * 3. The first character of each word is taken to form
+ * the initials.
+ *
+ * @param {string} input - The input string from which to generate the initials.
+ * @returns {string} The initials formed by taking the first character
+ * of each word, after applying the specified rules.
+ *
+ * @example
+ * getInitials("player-script"); // returns "ps"
+ * getInitials("ssv-admin"); // returns "sa"
+ * getInitials("@nizza/customize-live"); // returns "cl"
+ */
+export declare function getInitials(input: string): string;
+/**
+ * Retrieves the Vite command details.
+ *
+ * @param {ViteMode} mode - The Vite mode.
+ * @returns {ViteCommand} - The command details.
+ *
+ * @example
+ * const command = getViteCommand(ViteMode.PROD);
+ * // Outputs: { stage: Stage.PROD, target: 'build', flags: {} }
+ */
+export declare function getViteCommand(mode: ViteMode): ViteCommand;
+/**
+ * Parses the command string to extract flags.
+ *
+ * @param {string | undefined} commandString - The command string.
+ * @returns {Record<string, string>} - The flags extracted from the command string.
+ *
+ * @example
+ * const flags = getViteCmdFlags('nx run core:build --source-maps');
+ * // Outputs: { 'source-maps: 'true' }
+ */
+export declare function getViteCmdFlags(commandString: string | undefined): Record<string, string>;
+/**
+ * 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.
+ */
+export declare const createConfigBuilder: (commonConfig: CommonProjectConfig) => (projectConfig: ProjectConfig) => UserConfig;
+export interface Execute {
+	function: (data?: string) => void;
+	listen: string;
+	observer: string;
+}
+export interface ThirdPartyCssInjectPlugin {
+	topExecutionPriority?: boolean;
+	execute?: Execute[];
+}
+/**
+ * Inject the CSS compiled with JS.
+ *
+ * @return {Plugin}
+ */
+export declare function thirdPartyCssInjectPlugin({ topExecutionPriority, execute }?: ThirdPartyCssInjectPlugin | undefined): Plugin;
+export declare function injectCssIntoShadowDom(): {
+	name: string;
+	configureServer(_server: ViteDevServer): void;
+	transform(src: string, id: string): void;
+};
+
+export {};

package/executors.json

@@ -0,0 +1,29 @@
+{
+  "executors": {
+    "environments": {
+      "implementation": "./dist/cjs/executors/environments/index.cjs",
+      "schema": "./dist/cjs/executors/environments/schema.json",
+      "description": "Configure project with custom environments"
+    },
+    "vtex-link": {
+      "implementation": "./dist/cjs/executors/vtex-link/index.cjs",
+      "schema": "./dist/cjs/executors/vtex-link/schema.json",
+      "description": "Links a package to a VTEX project."
+    },
+    "publish": {
+      "implementation": "./dist/cjs/executors/publish/index.cjs",
+      "schema": "./dist/cjs/executors/publish/schema.json",
+      "description": "publish executor"
+    },
+    "update-executors-file": {
+      "implementation": "./dist/cjs/executors/update-executors-file/index.cjs",
+      "schema": "./dist/cjs/executors/update-executors-file/schema.json",
+      "description": "update-executors-file executor"
+    },
+    "deploy": {
+      "implementation": "./dist/cjs/executors/deploy/index.cjs",
+      "schema": "./dist/cjs/executors/deploy/schema.json",
+      "description": "deploy executor"
+    }
+  }
+}

package/package.json

@@ -1,12 +1,58 @@
 {
   "name": "@nizza/devkit",
-  "version": "0.1.0-alpha.1",
+  "version": "0.1.0-alpha.11",
+  "type": "module",
+  "main": "dist/cjs/index.cjs",
+  "module": "dist/esm/index.mjs",
   "source": "src/index.ts",
-  "main": "dist/src/index.js",
-  "types": "dist/src/index.d.ts",
+  "types": "dist/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": "./dist/esm/index.mjs",
+      "require": "./dist/cjs/index.cjs"
+    },
+    "./import": {
+      "default": "./dist/esm/index.mjs"
+    },
+    "./require": {
+      "default": "./dist/cjs/index.cjs"
+    }
+  },
   "files": [
-    "dist"
+    "dist",
+    "executors.json"
   ],
-  "dependencies": {},
-  "executors": "./executors.json"
+  "executors": "./executors.json",
+  "dependencies": {
+    "chalk": "^4",
+    "minimatch": "^9.0.3",
+    "mri": "^1.2.0",
+    "ramda": "^0.29.1",
+    "semver": "^7.5.4"
+  },
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^25.0.7",
+    "@rollup/plugin-json": "^6.0.1",
+    "@rollup/plugin-node-resolve": "^15.2.3",
+    "@types/semver": "^7.5.0",
+    "rollup": "^4.2.0",
+    "rollup-plugin-copy": "^3.5.0",
+    "rollup-plugin-delete": "^2.0.0",
+    "rollup-plugin-dts": "^6.1.0",
+    "rollup-plugin-dts-bundle-generator": "^1.4.0",
+    "rollup-plugin-swc3": "^0.10.3",
+    "rollup-plugin-ts": "^3.4.5"
+  },
+  "peerDependencies": {
+    "@nx/devkit": "17.0.2",
+    "@originjs/vite-plugin-commonjs": "^1.0.3",
+    "@rollup/plugin-graphql": "^2.0.4",
+    "@vitejs/plugin-react-swc": "^3.4.1",
+    "rollup-plugin-visualizer": "^5.9.2",
+    "vite": "^4.5.0",
+    "vite-plugin-css-injected-by-js": "^3.3.0",
+    "vite-plugin-dts": "^3.6.3",
+    "vite-tsconfig-paths": "^4.2.1"
+  }
 }