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

package/dist/esm/executors/vtex-link/helpers.d.ts

@@ -0,0 +1,77 @@
+import { SharedContext } from "../../types-1282e639.js";
+/**
+ * Links the local package to the VTEX environment.
+ *
+ * @param {SharedContext} ctx - The shared context containing paths and configurations.
+ * @returns {Promise<void>} A promise that resolves when the package is linked or rejects on error.
+ */
+declare function vtexLink(ctx: SharedContext): Promise<void>;
+/**
+ * Updates the package.json file within the VTEX project to use the local version of the package.
+ *
+ * @param {SharedContext} ctx - The shared context containing paths and configurations.
+ * @param {string} packageName - The name of the package to link.
+ * @returns {Promise<void>} A promise that resolves when the package.json is updated.
+ */
+declare function changePackageJsonFromVtexProject(ctx: SharedContext, packageName: string): Promise<void>;
+/**
+ * Restores the original package.json from the backup created before modifications.
+ *
+ * @param {SharedContext} ctx - The shared context containing paths and configurations.
+ * @returns {Promise<void>} A promise that resolves when the package.json is restored.
+ */
+declare function restorePackageJsonFromVtexProject(ctx: SharedContext): Promise<void>;
+/**
+ * Renames the generated package file with a unique identifier.
+ *
+ * @param {SharedContext} ctx - The shared context containing paths and configurations.
+ * @returns {Promise<string>} A promise that resolves with the new name of the package.
+ */
+declare function renamePackage(ctx: SharedContext): Promise<string>;
+/**
+ * Creates a pnpm package for uploading to VTEX.
+ *
+ * @param {SharedContext} ctx - The shared context containing paths and configurations.
+ * @returns {Promise<string>} A promise that resolves with the name of the created package.
+ */
+declare function createPackage(ctx: SharedContext): Promise<string>;
+/**
+ * Searches for and lists all outdated packages in the VTEX project directory.
+ *
+ * @param {SharedContext} ctx - The shared context containing paths and configurations.
+ * @returns {Promise<string[]>} A promise that resolves with a list of deprecated package names.
+ */
+declare function findLastPackages(ctx: SharedContext): Promise<string[]>;
+/**
+ * Removes all outdated packages in the VTEX project directory.
+ *
+ * @param {SharedContext} ctx - The shared context containing paths and configurations.
+ * @returns {Promise<void>} A promise that resolves when the old packages are removed.
+ */
+declare function removeOldPackages(ctx: SharedContext): Promise<void>;
+/**
+ * Moves a package to the VTEX project directory.
+ *
+ * @param {SharedContext} ctx - The shared context containing paths and configurations.
+ * @param {string} packageName - The name of the package to move.
+ * @returns {Promise<void>} A promise that resolves when the package is moved successfully.
+ */
+declare function movePackage(ctx: SharedContext, packageName: string): Promise<void>;
+/**
+ * Builds the package, moves it to the VTEX project, and updates the project's package.json.
+ *
+ * @param {SharedContext} ctx - The shared context containing paths and configurations.
+ * @returns {Promise<void>} A promise that resolves when the build is complete.
+ */
+declare function buildPackage(ctx: SharedContext): Promise<void>;
+/**
+ * Cleans the VTEX project by removing old packages and restoring the original package.json.
+ *
+ * @param {SharedContext} ctx - The shared context containing paths and configurations.
+ * @returns {Promise<void>} A promise that resolves when the clean-up is complete.
+ */
+declare function clean(ctx: SharedContext): Promise<void>;
+declare function validateEnvironment(): void;
+declare function performRollback(sharedContext: SharedContext): Promise<import("../../index-f6330edc.js").ExecutorResponse>;
+declare function buildAndLink(sharedContext: SharedContext, skipLink?: boolean): Promise<void>;
+export { vtexLink, changePackageJsonFromVtexProject, restorePackageJsonFromVtexProject, renamePackage, createPackage, findLastPackages, removeOldPackages, movePackage, buildPackage, clean, validateEnvironment, performRollback, buildAndLink };

package/dist/esm/executors/vtex-link/helpers.js

@@ -0,0 +1,192 @@
+import { logger } from '@nx/devkit';
+import { exec, spawn } from 'child_process';
+import { promises, existsSync } from 'fs';
+import { join, resolve } from 'path';
+import { promisify } from 'util';
+import '../../shared/logger.js';
+import { getPkgJson } from '../../shared/utils.js';
+import { ok, shortId } from '../shared/utils.js';
+import { VTEX_PROJECT_PATH, ERROR_LINKING_FLAG, SUCCESS_LINKING_FLAG } from './constants.js';
+
+const execAsync = promisify(exec);
+const getPkgJsonPath = (vtexProjectPath)=>resolve(vtexProjectPath, 'package.json');
+/**
+ * Links the local package to the VTEX environment.
+ *
+ * @param {SharedContext} ctx - The shared context containing paths and configurations.
+ * @returns {Promise<void>} A promise that resolves when the package is linked or rejects on error.
+ */ function vtexLink(ctx) {
+    const { vtexProjectPath } = ctx;
+    return new Promise((resolve, reject)=>{
+        logger.info('🔗 Linking package to VTEX...');
+        const link = spawn('vtex', [
+            'link',
+            '-u'
+        ], {
+            cwd: vtexProjectPath,
+            detached: true
+        });
+        link.stdout.on('data', (chunk)=>{
+            const data = chunk.toString('utf8');
+            if (data.includes(ERROR_LINKING_FLAG)) {
+                reject('could not link package in VTEX');
+            }
+            if (data.includes(SUCCESS_LINKING_FLAG)) {
+                link.pid && process.kill(-link.pid);
+                setTimeout(()=>{
+                    link.kill();
+                    logger.info('✅ Successfully linked package to VTEX.');
+                }, 200);
+                resolve();
+            }
+            logger.info(data);
+        });
+        link.on('error', (error)=>reject(error.message));
+    });
+}
+/**
+ * Updates the package.json file within the VTEX project to use the local version of the package.
+ *
+ * @param {SharedContext} ctx - The shared context containing paths and configurations.
+ * @param {string} packageName - The name of the package to link.
+ * @returns {Promise<void>} A promise that resolves when the package.json is updated.
+ */ async function changePackageJsonFromVtexProject(ctx, packageName) {
+    const { vtexProjectPath, projectName, packageOrg } = ctx;
+    const pkgJsonPath = getPkgJsonPath(vtexProjectPath);
+    // Make backup of package.json
+    await promises.copyFile(pkgJsonPath, join(vtexProjectPath, 'package.json.nxback'));
+    logger.info('🔃 Created package.json backup.');
+    // Find and edit value "@${packageOrg}/${projectName}" dependency
+    const packageJson = getPkgJson(vtexProjectPath);
+    const newPackageJson = {
+        ...packageJson,
+        dependencies: {
+            ...packageJson.dependencies,
+            [`@${packageOrg}/${projectName}`]: `file:./${packageName}`
+        }
+    };
+    await promises.unlink(pkgJsonPath);
+    await promises.writeFile(pkgJsonPath, JSON.stringify(newPackageJson, null, 2));
+    logger.info('📝 Updated package.json in VTEX project.');
+}
+/**
+ * Restores the original package.json from the backup created before modifications.
+ *
+ * @param {SharedContext} ctx - The shared context containing paths and configurations.
+ * @returns {Promise<void>} A promise that resolves when the package.json is restored.
+ */ async function restorePackageJsonFromVtexProject(ctx) {
+    const { vtexProjectPath } = ctx;
+    const pkgJsonPath = getPkgJsonPath(vtexProjectPath);
+    const backupFile = resolve(vtexProjectPath, 'package.json.nxback');
+    if (!existsSync(backupFile)) return;
+    await promises.unlink(pkgJsonPath);
+    await promises.copyFile(backupFile, pkgJsonPath);
+    await promises.unlink(backupFile);
+    logger.info('🔄 Restored package.json in VTEX project.');
+}
+/**
+ * Renames the generated package file with a unique identifier.
+ *
+ * @param {SharedContext} ctx - The shared context containing paths and configurations.
+ * @returns {Promise<string>} A promise that resolves with the new name of the package.
+ */ async function renamePackage(ctx) {
+    const { projectRoot, projectName, packageOrg } = ctx;
+    const packageJson = getPkgJson('./');
+    const oldName = `${packageOrg}-${projectName}-${packageJson.version}.tgz`;
+    const oldPath = join(projectRoot, oldName);
+    const newName = `${packageOrg}-${projectName}-${packageJson.version}-${shortId(8)}.tgz`;
+    const newPath = join(projectRoot, newName);
+    await promises.rename(oldPath, newPath);
+    logger.info(`🏷️ New package name: ${newName}`);
+    return newName;
+}
+/**
+ * Creates a pnpm package for uploading to VTEX.
+ *
+ * @param {SharedContext} ctx - The shared context containing paths and configurations.
+ * @returns {Promise<string>} A promise that resolves with the name of the created package.
+ */ async function createPackage(ctx) {
+    const command = 'pnpm pack';
+    const { stderr } = await execAsync(command);
+    if (stderr) logger.error(stderr);
+    logger.info('📦 Package generated successfully.');
+    return renamePackage(ctx);
+}
+/**
+ * Searches for and lists all outdated packages in the VTEX project directory.
+ *
+ * @param {SharedContext} ctx - The shared context containing paths and configurations.
+ * @returns {Promise<string[]>} A promise that resolves with a list of deprecated package names.
+ */ async function findLastPackages(ctx) {
+    const { vtexProjectPath, projectName, packageOrg } = ctx;
+    const matchedFiles = [];
+    const files = await promises.readdir(vtexProjectPath);
+    for (const file of files){
+        const regex = new RegExp(`^${packageOrg}-${projectName}-.*$`);
+        if (regex.test(file)) {
+            matchedFiles.push(file);
+            logger.info(`🔍 Found deprecated package: ${file}`);
+        }
+    }
+    return matchedFiles;
+}
+/**
+ * Removes all outdated packages in the VTEX project directory.
+ *
+ * @param {SharedContext} ctx - The shared context containing paths and configurations.
+ * @returns {Promise<void>} A promise that resolves when the old packages are removed.
+ */ async function removeOldPackages(ctx) {
+    const { vtexProjectPath } = ctx;
+    const files = await findLastPackages(ctx);
+    const toRemove = files.map((x)=>promises.unlink(resolve(vtexProjectPath, x)));
+    await Promise.all(toRemove);
+    logger.info('🗑️ Removed old packages in VTEX project.');
+}
+/**
+ * Moves a package to the VTEX project directory.
+ *
+ * @param {SharedContext} ctx - The shared context containing paths and configurations.
+ * @param {string} packageName - The name of the package to move.
+ * @returns {Promise<void>} A promise that resolves when the package is moved successfully.
+ */ async function movePackage(ctx, packageName) {
+    const { vtexProjectPath } = ctx;
+    await promises.rename(resolve(packageName), join(vtexProjectPath, packageName));
+    logger.info(`🚚 Moved package "${packageName}" to VTEX project.`);
+}
+/**
+ * Builds the package, moves it to the VTEX project, and updates the project's package.json.
+ *
+ * @param {SharedContext} ctx - The shared context containing paths and configurations.
+ * @returns {Promise<void>} A promise that resolves when the build is complete.
+ */ async function buildPackage(ctx) {
+    const packageName = await createPackage(ctx);
+    await Promise.all([
+        movePackage(ctx, packageName),
+        changePackageJsonFromVtexProject(ctx, packageName)
+    ]);
+}
+/**
+ * Cleans the VTEX project by removing old packages and restoring the original package.json.
+ *
+ * @param {SharedContext} ctx - The shared context containing paths and configurations.
+ * @returns {Promise<void>} A promise that resolves when the clean-up is complete.
+ */ async function clean(ctx) {
+    await Promise.all([
+        removeOldPackages(ctx),
+        restorePackageJsonFromVtexProject(ctx)
+    ]);
+}
+function validateEnvironment() {
+    if (!VTEX_PROJECT_PATH) throw new Error('The NZ_VTEX_PROJECT environment variable is missing. Set it in the project root in a .env.local file.');
+}
+async function performRollback(sharedContext) {
+    await clean(sharedContext);
+    return ok();
+}
+async function buildAndLink(sharedContext, skipLink = false) {
+    await clean(sharedContext);
+    await buildPackage(sharedContext);
+    if (!skipLink) await vtexLink(sharedContext);
+}
+
+export { buildAndLink, buildPackage, changePackageJsonFromVtexProject, clean, createPackage, findLastPackages, movePackage, performRollback, removeOldPackages, renamePackage, restorePackageJsonFromVtexProject, validateEnvironment, vtexLink };

package/dist/esm/executors/vtex-link/index.d.ts

@@ -0,0 +1,5 @@
+import { ExecutorContext } from '@nx/devkit';
+import { ExecutorResponse } from "../../index-f6330edc.js";
+import { ExecutorOptions } from "../../types-1282e639.js";
+declare function runExecutor(opts: ExecutorOptions, ctx: ExecutorContext): Promise<ExecutorResponse>;
+export { runExecutor as default };

package/dist/esm/executors/vtex-link/index.js

@@ -0,0 +1,28 @@
+import { resolve } from 'path';
+import { getProjectConfig, ok, err } from '../shared/utils.js';
+import { validateEnvironment, performRollback, buildAndLink } from './helpers.js';
+
+const VTEX_PROJECT_PATH = process.env.NZ_VTEX_PROJECT;
+async function runExecutor(opts, ctx) {
+    try {
+        const { rollback, skipLink, packageOrg } = opts;
+        const projectName = ctx.projectName || '';
+        validateEnvironment();
+        const projectConfig = getProjectConfig(ctx);
+        const projectRoot = projectConfig.root;
+        const vtexProjectPath = resolve(VTEX_PROJECT_PATH, 'react');
+        const sharedContext = {
+            packageOrg,
+            projectRoot,
+            projectName,
+            vtexProjectPath
+        };
+        if (rollback) return await performRollback(sharedContext);
+        await buildAndLink(sharedContext, skipLink);
+        return ok();
+    } catch (error) {
+        return err(error);
+    }
+}
+
+export { runExecutor as default };

package/dist/esm/executors/vtex-link/schema.json

@@ -0,0 +1,25 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "version": 2,
+  "title": "VtexLink executor",
+  "description": "",
+  "type": "object",
+  "properties": {
+    "packageOrg": {
+      "type": "string",
+      "description": "Name of the npm organization in which the packages are published"
+    },
+    "rollback": {
+      "type": "boolean",
+      "description": "Perform a rollback.",
+      "default": false
+    },
+    "skipLink": {
+      "type": "boolean",
+      "description": "Skip the linking step.",
+      "default": false
+    }
+  },
+  "required": [],
+  "additionalProperties": true
+}

package/dist/esm/index-0ce2daf7.d.ts

@@ -0,0 +1,2 @@
+export * from "./index-3080371d.js";
+export * from "./vite/plugins/shadow-dom-inject-css/index.js";

package/dist/esm/index-17143e35.d.ts

@@ -0,0 +1,2 @@
+export * from "./shared/logger.js";
+export * from "./shared/utils.js";

package/dist/esm/index-3080371d.d.ts

@@ -0,0 +1,3 @@
+import { thirdPartyCssInjectPlugin } from "./vite/plugins/third-party-css-inject/main.js";
+export * from "./vite/plugins/third-party-css-inject/main.js";
+export { thirdPartyCssInjectPlugin as default };

package/dist/esm/index-f6330edc.d.ts

@@ -0,0 +1,2 @@
+export * from "./types-7377dcc9.js";
+export * from "./executors/shared/utils.js";

package/dist/esm/index.d.ts

@@ -0,0 +1,10 @@
+export { default as deployExecutor } from "./executors/deploy/index.js";
+export { default as environmentsExecutor } from "./executors/environments/index.js";
+export { default as publishExecutor } from "./executors/publish/index.js";
+export { default as updateExecutorsFileExecutor } from "./executors/update-executors-file/index.js";
+export { default as vtexLinkExecutor } from "./executors/vtex-link/index.js";
+export * from "./scripts/changeset-pre-mode.js";
+export * from "./vite/config-builder/main.js";
+export * from "./index-f6330edc.js";
+export * from "./index-0ce2daf7.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts","../../src/executors/index.ts","../../src/scripts/index.ts","../../src/vite/config-builder/index.ts","../../src/vite/index.ts"],"names":[],"mappings":""}

package/dist/esm/index.js

@@ -0,0 +1,13 @@
+export { default as deployExecutor } from './executors/deploy/index.js';
+export { default as environmentsExecutor } from './executors/environments/index.js';
+export { default as publishExecutor } from './executors/publish/index.js';
+export { default as updateExecutorsFileExecutor } from './executors/update-executors-file/index.js';
+export { default as vtexLinkExecutor } from './executors/vtex-link/index.js';
+export { main } from './scripts/changeset-pre-mode.js';
+export { createConfigBuilder } from './vite/config-builder/main.js';
+export { Flag, ProjectType, Stage, Target, ViteMode } from './vite/config-builder/shared/types.js';
+export { chunkName, deepMerge, getNxTsConfigPaths, getPlugins, shortId, when } from './vite/config-builder/shared/utils/helpers.js';
+export { getExternalDependencies, getInitials, initializeConfig, mergeConfigs } from './vite/config-builder/shared/utils/projectConfig.js';
+export { getViteCmdFlags, getViteCommand } from './vite/config-builder/shared/utils/viteCommand.js';
+export { thirdPartyCssInjectPlugin } from './vite/plugins/third-party-css-inject/main.js';
+export { injectCssIntoShadowDom } from './vite/plugins/shadow-dom-inject-css/index.js';

package/dist/esm/scripts/changeset-pre-mode.d.ts

@@ -0,0 +1,2 @@
+declare function main(): Promise<void>;
+export { main };

package/dist/esm/scripts/changeset-pre-mode.js

@@ -0,0 +1,39 @@
+import { logger } from '@nx/devkit';
+import { exec } from 'child_process';
+import { readFile } from 'fs/promises';
+import { resolve } from 'path';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+const changesetDir = resolve('.changeset');
+const preJsonPath = resolve(changesetDir, 'pre.json');
+let preJson;
+async function main() {
+    try {
+        const data = await readFile(preJsonPath, 'utf8');
+        preJson = JSON.parse(data);
+    } catch  {
+        preJson = {
+            mode: 'exit'
+        };
+    }
+    // Execute "version" command using @changeset/cli
+    try {
+        const { mode } = preJson;
+        if (mode === 'exit') {
+            const command = `pnpm changeset pre enter beta`;
+            const { stdout, stderr } = await execAsync(command);
+            logger.info(stdout);
+            logger.info(stderr);
+            logger.info(`🚀 Successfully enter prerelease mode`);
+        } else {
+            logger.info(`🚀 Prerelease mode has been previously entered`);
+        }
+    } catch (error) {
+        logger.error('❌ An error occurred!');
+        throw error;
+    }
+}
+main();
+
+export { main };

package/dist/esm/shared/logger.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Enum representing the different log levels.
+ */
+declare enum LogLevel {
+    ERROR = 0,
+    WARN = 1,
+    INFO = 2,
+    DEBUG = 3
+}
+declare let currentLogLevel: LogLevel;
+/**
+ * Sets the log level for the logger.
+ * Only logs at this level and above will be displayed.
+ *
+ * @param {LogLevel} level - The log level to set.
+ * @example
+ * // Set log level to WARN
+ * setLogLevel(LogLevel.WARN);
+ *
+ * // Now only WARN and ERROR logs will be displayed
+ * logger.debug('Debug message');  // Will not be logged
+ * logger.info('Info message');  // Will not be logged
+ * logger.warn('Warn message');  // Will be logged
+ * logger.error('Error message');  // Will be logged
+ */
+declare const setLogLevel: (level: LogLevel) => void;
+declare const logger: {
+    error: (message: string, ...rest: any[]) => void;
+    warn: (message: string, ...rest: any[]) => void;
+    info: (message: string, ...rest: any[]) => void;
+    debug: (message: string, ...rest: any[]) => void;
+};
+export { LogLevel, currentLogLevel, setLogLevel, logger };

package/dist/{src → esm/shared}/logger.js

@@ -1,33 +1,6 @@
-"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, {
-    LogLevel: function() {
-        return LogLevel;
-    },
-    currentLogLevel: function() {
-        return currentLogLevel;
-    },
-    default: function() {
-        return _default;
-    },
-    logger: function() {
-        return logger;
-    },
-    setLogLevel: function() {
-        return setLogLevel;
-    }
-});
-const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
-const _chalk = /*#__PURE__*/ _interop_require_default._(require("chalk"));
-const _ramda = require("ramda");
+import chalk from 'chalk';
+import { pipe, map, join } from 'ramda';
+
 var LogLevel;
 (function(LogLevel) {
     LogLevel[LogLevel["ERROR"] = 0] = "ERROR";
@@ -35,6 +8,7 @@ var LogLevel;
     LogLevel[LogLevel["INFO"] = 2] = "INFO";
     LogLevel[LogLevel["DEBUG"] = 3] = "DEBUG";
 })(LogLevel || (LogLevel = {}));
+// Default log level
 let currentLogLevel = 2;
 /**
  * Object mapping log levels to console log functions.
@@ -51,15 +25,29 @@ let currentLogLevel = 2;
  *
  * @constant {Object} colorFunctions
  */ const colorFunctions = {
-    [0]: _chalk.default.red,
-    [1]: _chalk.default.yellow,
-    [2]: _chalk.default.blue,
-    [3]: _chalk.default.magenta
+    [0]: chalk.red,
+    [1]: chalk.yellow,
+    [2]: chalk.blue,
+    [3]: chalk.magenta
 };
 const getLogLevelKey = (value)=>{
     return Object.keys(LogLevel).find((key)=>LogLevel[key] === value);
 };
-const setLogLevel = (level)=>{
+/**
+ * Sets the log level for the logger.
+ * Only logs at this level and above will be displayed.
+ *
+ * @param {LogLevel} level - The log level to set.
+ * @example
+ * // Set log level to WARN
+ * setLogLevel(LogLevel.WARN);
+ *
+ * // Now only WARN and ERROR logs will be displayed
+ * logger.debug('Debug message');  // Will not be logged
+ * logger.info('Info message');  // Will not be logged
+ * logger.warn('Warn message');  // Will be logged
+ * logger.error('Error message');  // Will be logged
+ */ const setLogLevel = (level)=>{
     currentLogLevel = level;
 };
 /**
@@ -68,7 +56,7 @@ const setLogLevel = (level)=>{
  *
  * @param {any[]} args - The arguments to process.
  * @returns {string} - The processed string.
- */ const processArgs = (0, _ramda.pipe)((0, _ramda.map)((arg)=>JSON.stringify(arg, null, 2)), (0, _ramda.join)('\n'));
+ */ const processArgs = pipe(map((arg)=>JSON.stringify(arg, null, 2)), join('\n'));
 /**
  * Formats the log message with a timestamp, log level, and any additional variables.
  *
@@ -89,8 +77,8 @@ const setLogLevel = (level)=>{
  * @returns - The log function.
  */ const log = (level)=>(message, ...rest)=>{
         if (level > currentLogLevel) return; // Skip logging if level is below the current log level
-        const pipeline = (0, _ramda.pipe)(()=>formatMessage(level, message, ...rest), colorFunctions[level], logFunctions[level]);
-        const errPipeline = (0, _ramda.pipe)((err)=>`Failed to log message: ${err.message}`, colorFunctions[0], logFunctions[0]);
+        const pipeline = pipe(()=>formatMessage(level, message, ...rest), colorFunctions[level], logFunctions[level]);
+        const errPipeline = pipe((err)=>`Failed to log message: ${err.message}`, colorFunctions[0], logFunctions[0]);
         try {
             pipeline();
         } catch (err) {
@@ -103,4 +91,5 @@ const logger = {
     info: log(2),
     debug: log(3)
 };
-const _default = logger;
+
+export { LogLevel, currentLogLevel, logger, setLogLevel };

package/dist/esm/shared/utils.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Reads and parses the package.json file from the given project path.
+ *
+ * @param {string} projectPath - The path to the project.
+ * @returns {Record<string, any>} - The parsed package.json data.
+ *
+ * @example
+ * const pkgJsonData = getPkgJson('/path/to/project');
+ */
+declare const getPkgJson: (projectPath: string) => Record<string, any>;
+export { getPkgJson };

package/dist/esm/shared/utils.js

@@ -0,0 +1,23 @@
+import { logger } from '@nx/devkit';
+import { readFileSync } from 'fs';
+import { resolve } from 'path';
+
+/**
+ * Reads and parses the package.json file from the given project path.
+ *
+ * @param {string} projectPath - The path to the project.
+ * @returns {Record<string, any>} - The parsed package.json data.
+ *
+ * @example
+ * const pkgJsonData = getPkgJson('/path/to/project');
+ */ const getPkgJson = (projectPath)=>{
+    try {
+        const data = readFileSync(resolve(projectPath, './package.json'), 'utf-8');
+        return JSON.parse(data);
+    } catch (err) {
+        logger.error('Error reading or parsing package.json');
+        throw err;
+    }
+};
+
+export { getPkgJson };

package/dist/esm/types-1282e639.d.ts

@@ -0,0 +1,12 @@
+interface SharedContext {
+    vtexProjectPath: string;
+    projectRoot: string;
+    projectName: string;
+    packageOrg: string;
+}
+interface ExecutorOptions {
+    packageOrg: string;
+    rollback?: boolean;
+    skipLink?: boolean;
+}
+export { SharedContext, ExecutorOptions };

package/dist/esm/types-7377dcc9.d.ts

@@ -0,0 +1,4 @@
+type ExecutorResponse = {
+    success: boolean;
+};
+export { ExecutorResponse };

package/dist/esm/types-763439e4.d.ts

@@ -0,0 +1,14 @@
+interface ExecutorOptions {
+}
+interface ExecutorConfig {
+    implementation: string;
+    schema: string;
+    description: string;
+}
+interface Executors {
+    [executorName: string]: ExecutorConfig;
+}
+interface ExecutorsFile {
+    executors: Executors;
+}
+export { ExecutorOptions, ExecutorConfig, Executors, ExecutorsFile };

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

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

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

@@ -0,0 +1,11 @@
+const getAppConfig = (ctx)=>{
+    const { port } = ctx.projectConfig;
+    return {
+        server: {
+            port,
+            host: true
+        }
+    };
+};
+
+export { getAppConfig };

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

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