@nizza/devkit 0.2.6 → 0.2.8-beta.0

package/dist/cjs/executors/deploy/helpers.cjs

@@ -10,7 +10,7 @@ async function cleanS3Bucket(s3BucketPath) {
 }
 async function copyAssetsToS3(s3BucketPath, projectRoot) {
     devkit.logger.info('📦 Copying assets to S3 bucket...');
-    await utils.runCommand(`aws s3 cp ${projectRoot}/dist ${s3BucketPath} --recursive`);
+    await utils.runCommand(`aws s3 cp ${projectRoot}/dist ${s3BucketPath} --recursive --exclude "*.map"`);
     devkit.logger.info('🚚 Assets files copied.');
 }
 async function copyTypingsToS3(s3BucketPath, projectRoot) {

package/dist/cjs/executors/publish/helpers.cjs

@@ -2,52 +2,98 @@
 
 var devkit = require('@nx/devkit');
 var child_process = require('child_process');
+var semver = require('semver');
 var util = require('util');
 
 const execAsync = util.promisify(child_process.exec);
 /**
- * Retrieves the version of a published package with a given name and tag.
+ * Checks if an exact package version is already available in the npm registry.
  *
- * @param {string} packageName The name of the package to retrieve the version for.
- * @param {string} tag The tag to retrieve the version for.
- * @returns The version of the package as a string or an object containing versions for each tag.
- */ async function getPublishedPackageVersion(packageName, tag) {
-    const withTag = tag ? `.${tag}` : ' --json';
-    const command = `npm view ${packageName} dist-tags${withTag}`;
-    const { stdout, stderr } = await execAsync(command);
-    if (stderr) {
-        devkit.logger.warn(stderr.trim());
+ * @param {string} packageName The name of the package to check.
+ * @param {string} version The exact version to look for.
+ * @returns {Promise<boolean>} True when the version exists in the registry.
+ */ async function isVersionPublished(packageName, version) {
+    try {
+        await execAsync(`npm view ${packageName}@${version} version --json`);
+        return true;
+    } catch (error) {
+        const output = `${error?.stderr ?? ''} ${error?.message ?? ''}`;
+        // E404 means that the package or the exact version does not exist yet.
+        if (output.includes('E404')) {
+            return false;
+        }
+        devkit.logger.error(`❌ Could not check the npm registry for "${packageName}@${version}".`);
+        throw error;
     }
-    const published = stdout.trim();
-    return tag ? published : JSON.parse(published);
 }
 /**
- * Checks if a package with the given name is already published and returns its version.
+ * Checks if the project has commits after the commit that set the current version.
  *
- * @param {string} packageName The name of the package to check for.
- * @returns An object containing the published versions of the package and a flag indicating if it is the first version.
- */ async function checkPublishedVersion(packageName) {
-    let publishedVersion;
-    let isFirstVersion = false;
-    try {
-        publishedVersion = await getPublishedPackageVersion(packageName);
-    } catch (err) {
-        if (err?.message.includes('code E404')) {
-            isFirstVersion = true;
-            devkit.logger.info(`🏁 This is the first version of "${packageName}" package. \n`);
-        } else {
-            devkit.logger.error('❌ Error when checking the last published versions \n');
-            if (err.stderr) {
-                devkit.logger.error(err.stderr);
-            }
-            throw err;
-        }
+ * A published version with changes after its version bump means that there is
+ * unpublished work without a changeset.
+ *
+ * @param {string} workspaceRoot The workspace root.
+ * @param {string} projectRoot The project root, relative to the workspace root.
+ * @param {string} version The current package version.
+ * @returns {Promise<boolean>} True when the project changed after the version bump.
+ */ async function hasChangesSinceVersionWasSet(workspaceRoot, projectRoot, version) {
+    const packageJsonPath = `${projectRoot}/package.json`;
+    const versionNeedle = `"version": "${version}"`;
+    const { stdout: versionCommitOutput } = await execAsync(`git log -1 --format=%H -S${JSON.stringify(versionNeedle)} -- ${JSON.stringify(packageJsonPath)}`, {
+        cwd: workspaceRoot
+    });
+    const versionCommit = versionCommitOutput.trim();
+    if (!versionCommit) {
+        devkit.logger.warn(`⚠️ Could not find the commit that set "${packageJsonPath}" to version ${version}.`);
+        return false;
+    }
+    const { stdout: changesOutput } = await execAsync(`git rev-list --count ${versionCommit}..HEAD -- ${JSON.stringify(projectRoot)}`, {
+        cwd: workspaceRoot
+    });
+    return Number(changesOutput.trim()) > 0;
+}
+/**
+ * Decides what to do with a package version before publishing it.
+ *
+ * The decision keeps the publish step idempotent and blocks versions that can
+ * never be published as intended, for example a stable version that was already
+ * consumed by a prerelease tag.
+ *
+ * @param {PublishDecisionInput} input The publish state of the package.
+ * @returns {PublishDecision} The action to run and the reason for it.
+ */ function getPublishDecision({ packageName, packageVersion, tag, isVersionPublished, hasUnpublishedChanges }) {
+    const isPrerelease = semver.prerelease(packageVersion) !== null;
+    const packageId = `${packageName}@${packageVersion}`;
+    if (tag === 'latest' && isPrerelease) {
+        return {
+            action: 'error',
+            reason: `❌ Refusing to publish prerelease version ${packageId} with the "latest" tag. ` + 'Exit prerelease mode and run "changeset version" on main first.'
+        };
+    }
+    if (!isPrerelease && tag !== 'latest') {
+        return hasUnpublishedChanges ? {
+            action: 'error',
+            reason: `❌ "${packageName}" has unpublished changes, but version ${packageVersion} ` + `is stable and cannot be published with the "${tag}" tag. ` + 'Create a changeset with "pnpm cs" so prerelease mode bumps the version.'
+        } : {
+            action: 'skip',
+            reason: `⏭️ Skipping ${packageId}: the version is stable and has no prerelease suffix. ` + `The "${tag}" tag only accepts prerelease versions. Add a changeset for a new release.`
+        };
+    }
+    if (isVersionPublished) {
+        return hasUnpublishedChanges ? {
+            action: 'error',
+            reason: `❌ ${packageId} is already published on npm, but the project has commits ` + 'after that version. Create a changeset with "pnpm cs" to bump the version.'
+        } : {
+            action: 'skip',
+            reason: `⏭️ ${packageId} is already published on npm. Skipping.`
+        };
     }
     return {
-        publishedVersion,
-        isFirstVersion
+        action: 'publish',
+        reason: `🚀 Publishing ${packageId} with the "${tag}" tag.`
     };
 }
 
-exports.checkPublishedVersion = checkPublishedVersion;
-exports.getPublishedPackageVersion = getPublishedPackageVersion;
+exports.getPublishDecision = getPublishDecision;
+exports.hasChangesSinceVersionWasSet = hasChangesSinceVersionWasSet;
+exports.isVersionPublished = isVersionPublished;

package/dist/cjs/executors/publish/index.cjs

@@ -1,15 +1,19 @@
 'use strict';
 
 var devkit = require('@nx/devkit');
-var semver = require('semver');
 require('../../shared/logger.cjs');
 var utils$1 = require('../../shared/utils.cjs');
 var utils = require('../shared/utils.cjs');
 var helpers = require('./helpers.cjs');
 
 /**
- * This is a minimal script to publish package to "npm".
- * Need to authenticate with NPM before running this script.
+ * Publishes a package to npm.
+ *
+ * The executor is idempotent: it skips versions that are already published and
+ * skips stable versions that cannot use a prerelease tag. It fails when a
+ * project has unpublished changes without a new version.
+ *
+ * Need to authenticate with NPM before running this executor.
  */ async function runExecutor(opts, ctx) {
     try {
         const { tag, dryRun: isDryRun } = opts;
@@ -17,33 +21,30 @@ var helpers = require('./helpers.cjs');
         // Read the package.json file and extract the name and version.
         const packageJson = utils$1.getPkgJson(projectRoot);
         const { name: packageName, version: packageVersion } = packageJson;
-        // Check if the package has been previously published and get the published version.
-        const { publishedVersion, isFirstVersion } = await helpers.checkPublishedVersion(packageName);
-        let greaterThanTagVersion, greaterThanLatestVersion;
-        if (!isFirstVersion) {
-            // Check if the package version is greater than the latest published version for the specified tag.
-            greaterThanTagVersion = publishedVersion?.[tag] ? semver.gt(packageVersion, publishedVersion?.[tag]) : true;
-            // Check if the package version is greater than the latest published version.
-            greaterThanLatestVersion = semver.gt(packageVersion, publishedVersion.latest);
-            console.log(`🔎 package.json version: ${packageVersion}`);
-            console.log('🔺 published versions:');
-            Object.entries(publishedVersion).forEach(([k, v])=>console.log(`   * ${k}: ${v}`));
-            console.log('\n');
+        // Check the registry and the git history to decide if the version is publishable.
+        const versionPublished = await helpers.isVersionPublished(packageName, packageVersion);
+        const hasUnpublishedChanges = await helpers.hasChangesSinceVersionWasSet(ctx.root, projectRoot, packageVersion);
+        const { action, reason } = helpers.getPublishDecision({
+            packageName,
+            packageVersion,
+            tag,
+            isVersionPublished: versionPublished,
+            hasUnpublishedChanges
+        });
+        if (action === 'error') {
+            return utils.err(reason);
         }
-        // Publish the package if it's the first version or if it's a new version.
-        const needsPublish = isFirstVersion || greaterThanLatestVersion && greaterThanTagVersion;
-        if (needsPublish) {
-            const dryRun = isDryRun ? '--dry-run' : '';
-            const commandToPublish = `pnpm publish --access public --tag ${tag} --no-git-checks ${dryRun}`;
-            isDryRun && devkit.logger.info('👀 Skip publish (dry run) \n');
-            devkit.logger.info(`${commandToPublish} \n`);
-            // Execute the command to publish the package.
-            // process.chdir(projectRoot);
-            await utils.runCommand(commandToPublish, projectRoot);
-            devkit.logger.info(`\n🚀 Successfully published ${packageName}@${packageVersion}`);
-        } else {
-            devkit.logger.warn(`👻 Package version "${packageVersion}" is invalid.`);
+        if (action === 'skip') {
+            devkit.logger.warn(reason);
+            return utils.ok();
         }
+        const dryRun = isDryRun ? '--dry-run' : '';
+        const commandToPublish = `pnpm publish --access public --tag ${tag} --no-git-checks ${dryRun}`;
+        isDryRun && devkit.logger.info('👀 Skip publish (dry run) \n');
+        devkit.logger.info(`${reason}\n${commandToPublish} \n`);
+        // Execute the command to publish the package.
+        await utils.runCommand(commandToPublish, projectRoot);
+        devkit.logger.info(`\n🚀 Successfully published ${packageName}@${packageVersion}`);
         return utils.ok();
     } catch (error) {
         return utils.err(error, '❌ Error when publishing the package');

package/dist/cjs/executors/publish/schema.json

@@ -2,7 +2,7 @@
   "$schema": "http://json-schema.org/schema",
   "version": 2,
   "title": "Publish executor",
-  "description": "Automates the process of publishing a package to npm, requiring prior npm authentication. It checks if the current version is greater than both the latest published version and the specified tag version. Supports a dry run mode for testing without actual publication.",
+  "description": "Publishes a package to npm after authentication. Skips versions that are already published and versions that cannot use the requested tag. Fails when the project has unpublished changes without a new version. Supports a dry run mode for testing without actual publication.",
   "type": "object",
   "properties": {
     "tag": {

package/dist/esm/executors/deploy/helpers.mjs

@@ -8,7 +8,7 @@ async function cleanS3Bucket(s3BucketPath) {
 }
 async function copyAssetsToS3(s3BucketPath, projectRoot) {
     logger.info('📦 Copying assets to S3 bucket...');
-    await runCommand(`aws s3 cp ${projectRoot}/dist ${s3BucketPath} --recursive`);
+    await runCommand(`aws s3 cp ${projectRoot}/dist ${s3BucketPath} --recursive --exclude "*.map"`);
     logger.info('🚚 Assets files copied.');
 }
 async function copyTypingsToS3(s3BucketPath, projectRoot) {

package/dist/esm/executors/publish/helpers.mjs

@@ -1,50 +1,95 @@
 import { logger } from '@nx/devkit';
 import { exec } from 'child_process';
+import semver from 'semver';
 import { promisify } from 'util';
 
 const execAsync = promisify(exec);
 /**
- * Retrieves the version of a published package with a given name and tag.
+ * Checks if an exact package version is already available in the npm registry.
  *
- * @param {string} packageName The name of the package to retrieve the version for.
- * @param {string} tag The tag to retrieve the version for.
- * @returns The version of the package as a string or an object containing versions for each tag.
- */ async function getPublishedPackageVersion(packageName, tag) {
-    const withTag = tag ? `.${tag}` : ' --json';
-    const command = `npm view ${packageName} dist-tags${withTag}`;
-    const { stdout, stderr } = await execAsync(command);
-    if (stderr) {
-        logger.warn(stderr.trim());
+ * @param {string} packageName The name of the package to check.
+ * @param {string} version The exact version to look for.
+ * @returns {Promise<boolean>} True when the version exists in the registry.
+ */ async function isVersionPublished(packageName, version) {
+    try {
+        await execAsync(`npm view ${packageName}@${version} version --json`);
+        return true;
+    } catch (error) {
+        const output = `${error?.stderr ?? ''} ${error?.message ?? ''}`;
+        // E404 means that the package or the exact version does not exist yet.
+        if (output.includes('E404')) {
+            return false;
+        }
+        logger.error(`❌ Could not check the npm registry for "${packageName}@${version}".`);
+        throw error;
     }
-    const published = stdout.trim();
-    return tag ? published : JSON.parse(published);
 }
 /**
- * Checks if a package with the given name is already published and returns its version.
+ * Checks if the project has commits after the commit that set the current version.
  *
- * @param {string} packageName The name of the package to check for.
- * @returns An object containing the published versions of the package and a flag indicating if it is the first version.
- */ async function checkPublishedVersion(packageName) {
-    let publishedVersion;
-    let isFirstVersion = false;
-    try {
-        publishedVersion = await getPublishedPackageVersion(packageName);
-    } catch (err) {
-        if (err?.message.includes('code E404')) {
-            isFirstVersion = true;
-            logger.info(`🏁 This is the first version of "${packageName}" package. \n`);
-        } else {
-            logger.error('❌ Error when checking the last published versions \n');
-            if (err.stderr) {
-                logger.error(err.stderr);
-            }
-            throw err;
-        }
+ * A published version with changes after its version bump means that there is
+ * unpublished work without a changeset.
+ *
+ * @param {string} workspaceRoot The workspace root.
+ * @param {string} projectRoot The project root, relative to the workspace root.
+ * @param {string} version The current package version.
+ * @returns {Promise<boolean>} True when the project changed after the version bump.
+ */ async function hasChangesSinceVersionWasSet(workspaceRoot, projectRoot, version) {
+    const packageJsonPath = `${projectRoot}/package.json`;
+    const versionNeedle = `"version": "${version}"`;
+    const { stdout: versionCommitOutput } = await execAsync(`git log -1 --format=%H -S${JSON.stringify(versionNeedle)} -- ${JSON.stringify(packageJsonPath)}`, {
+        cwd: workspaceRoot
+    });
+    const versionCommit = versionCommitOutput.trim();
+    if (!versionCommit) {
+        logger.warn(`⚠️ Could not find the commit that set "${packageJsonPath}" to version ${version}.`);
+        return false;
+    }
+    const { stdout: changesOutput } = await execAsync(`git rev-list --count ${versionCommit}..HEAD -- ${JSON.stringify(projectRoot)}`, {
+        cwd: workspaceRoot
+    });
+    return Number(changesOutput.trim()) > 0;
+}
+/**
+ * Decides what to do with a package version before publishing it.
+ *
+ * The decision keeps the publish step idempotent and blocks versions that can
+ * never be published as intended, for example a stable version that was already
+ * consumed by a prerelease tag.
+ *
+ * @param {PublishDecisionInput} input The publish state of the package.
+ * @returns {PublishDecision} The action to run and the reason for it.
+ */ function getPublishDecision({ packageName, packageVersion, tag, isVersionPublished, hasUnpublishedChanges }) {
+    const isPrerelease = semver.prerelease(packageVersion) !== null;
+    const packageId = `${packageName}@${packageVersion}`;
+    if (tag === 'latest' && isPrerelease) {
+        return {
+            action: 'error',
+            reason: `❌ Refusing to publish prerelease version ${packageId} with the "latest" tag. ` + 'Exit prerelease mode and run "changeset version" on main first.'
+        };
+    }
+    if (!isPrerelease && tag !== 'latest') {
+        return hasUnpublishedChanges ? {
+            action: 'error',
+            reason: `❌ "${packageName}" has unpublished changes, but version ${packageVersion} ` + `is stable and cannot be published with the "${tag}" tag. ` + 'Create a changeset with "pnpm cs" so prerelease mode bumps the version.'
+        } : {
+            action: 'skip',
+            reason: `⏭️ Skipping ${packageId}: the version is stable and has no prerelease suffix. ` + `The "${tag}" tag only accepts prerelease versions. Add a changeset for a new release.`
+        };
+    }
+    if (isVersionPublished) {
+        return hasUnpublishedChanges ? {
+            action: 'error',
+            reason: `❌ ${packageId} is already published on npm, but the project has commits ` + 'after that version. Create a changeset with "pnpm cs" to bump the version.'
+        } : {
+            action: 'skip',
+            reason: `⏭️ ${packageId} is already published on npm. Skipping.`
+        };
     }
     return {
-        publishedVersion,
-        isFirstVersion
+        action: 'publish',
+        reason: `🚀 Publishing ${packageId} with the "${tag}" tag.`
     };
 }
 
-export { checkPublishedVersion, getPublishedPackageVersion };
+export { getPublishDecision, hasChangesSinceVersionWasSet, isVersionPublished };

package/dist/esm/executors/publish/index.mjs

@@ -1,13 +1,17 @@
 import { logger } from '@nx/devkit';
-import semver from 'semver';
 import '../../shared/logger.mjs';
 import { getPkgJson } from '../../shared/utils.mjs';
-import { getProjectConfig, runCommand, ok, err } from '../shared/utils.mjs';
-import { checkPublishedVersion } from './helpers.mjs';
+import { getProjectConfig, err, ok, runCommand } from '../shared/utils.mjs';
+import { isVersionPublished, hasChangesSinceVersionWasSet, getPublishDecision } from './helpers.mjs';
 
 /**
- * This is a minimal script to publish package to "npm".
- * Need to authenticate with NPM before running this script.
+ * Publishes a package to npm.
+ *
+ * The executor is idempotent: it skips versions that are already published and
+ * skips stable versions that cannot use a prerelease tag. It fails when a
+ * project has unpublished changes without a new version.
+ *
+ * Need to authenticate with NPM before running this executor.
  */ async function runExecutor(opts, ctx) {
     try {
         const { tag, dryRun: isDryRun } = opts;
@@ -15,33 +19,30 @@ import { checkPublishedVersion } from './helpers.mjs';
         // Read the package.json file and extract the name and version.
         const packageJson = getPkgJson(projectRoot);
         const { name: packageName, version: packageVersion } = packageJson;
-        // Check if the package has been previously published and get the published version.
-        const { publishedVersion, isFirstVersion } = await checkPublishedVersion(packageName);
-        let greaterThanTagVersion, greaterThanLatestVersion;
-        if (!isFirstVersion) {
-            // Check if the package version is greater than the latest published version for the specified tag.
-            greaterThanTagVersion = publishedVersion?.[tag] ? semver.gt(packageVersion, publishedVersion?.[tag]) : true;
-            // Check if the package version is greater than the latest published version.
-            greaterThanLatestVersion = semver.gt(packageVersion, publishedVersion.latest);
-            console.log(`🔎 package.json version: ${packageVersion}`);
-            console.log('🔺 published versions:');
-            Object.entries(publishedVersion).forEach(([k, v])=>console.log(`   * ${k}: ${v}`));
-            console.log('\n');
+        // Check the registry and the git history to decide if the version is publishable.
+        const versionPublished = await isVersionPublished(packageName, packageVersion);
+        const hasUnpublishedChanges = await hasChangesSinceVersionWasSet(ctx.root, projectRoot, packageVersion);
+        const { action, reason } = getPublishDecision({
+            packageName,
+            packageVersion,
+            tag,
+            isVersionPublished: versionPublished,
+            hasUnpublishedChanges
+        });
+        if (action === 'error') {
+            return err(reason);
         }
-        // Publish the package if it's the first version or if it's a new version.
-        const needsPublish = isFirstVersion || greaterThanLatestVersion && greaterThanTagVersion;
-        if (needsPublish) {
-            const dryRun = isDryRun ? '--dry-run' : '';
-            const commandToPublish = `pnpm publish --access public --tag ${tag} --no-git-checks ${dryRun}`;
-            isDryRun && logger.info('👀 Skip publish (dry run) \n');
-            logger.info(`${commandToPublish} \n`);
-            // Execute the command to publish the package.
-            // process.chdir(projectRoot);
-            await runCommand(commandToPublish, projectRoot);
-            logger.info(`\n🚀 Successfully published ${packageName}@${packageVersion}`);
-        } else {
-            logger.warn(`👻 Package version "${packageVersion}" is invalid.`);
+        if (action === 'skip') {
+            logger.warn(reason);
+            return ok();
         }
+        const dryRun = isDryRun ? '--dry-run' : '';
+        const commandToPublish = `pnpm publish --access public --tag ${tag} --no-git-checks ${dryRun}`;
+        isDryRun && logger.info('👀 Skip publish (dry run) \n');
+        logger.info(`${reason}\n${commandToPublish} \n`);
+        // Execute the command to publish the package.
+        await runCommand(commandToPublish, projectRoot);
+        logger.info(`\n🚀 Successfully published ${packageName}@${packageVersion}`);
         return ok();
     } catch (error) {
         return err(error, '❌ Error when publishing the package');

package/dist/esm/executors/publish/schema.json

@@ -2,7 +2,7 @@
   "$schema": "http://json-schema.org/schema",
   "version": 2,
   "title": "Publish executor",
-  "description": "Automates the process of publishing a package to npm, requiring prior npm authentication. It checks if the current version is greater than both the latest published version and the specified tag version. Supports a dry run mode for testing without actual publication.",
+  "description": "Publishes a package to npm after authentication. Skips versions that are already published and versions that cannot use the requested tag. Fails when the project has unpublished changes without a new version. Supports a dry run mode for testing without actual publication.",
   "type": "object",
   "properties": {
     "tag": {

package/executors.json

@@ -13,7 +13,7 @@
     "publish": {
       "implementation": "./dist/cjs/executors/publish/index.cjs",
       "schema": "./dist/cjs/executors/publish/schema.json",
-      "description": "Automates the process of publishing a package to npm, requiring prior npm authentication. It checks if the current version is greater than both the latest published version and the specified tag version. Supports a dry run mode for testing without actual publication"
+      "description": "Publishes a package to npm after authentication. Skips versions that are already published and versions that cannot use the requested tag. Fails when the project has unpublished changes without a new version. Supports a dry run mode for testing without actual publication"
     },
     "update-executors-file": {
       "implementation": "./dist/cjs/executors/update-executors-file/index.cjs",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nizza/devkit",
-  "version": "0.2.6",
+  "version": "0.2.8-beta.0",
   "type": "module",
   "main": "dist/cjs/index.cjs",
   "module": "dist/esm/index.mjs",

package/dist/index.d.ts

@@ -1,382 +0,0 @@
-// Generated by dts-bundle-generator v7.2.0
-
-import { ExecutorContext } from '@nx/devkit';
-import { PreRenderedChunk } from 'rollup';
-import { ConfigEnv, LibraryOptions, Plugin, PluginOption, UserConfig, UserConfig as ViteUserConfig, ViteDevServer } from 'vite';
-import { InlineConfig as VitestInlineConfig } from 'vitest/node';
-
-export type ExecutorResponse = {
-	success: boolean;
-};
-export interface ExecutorOptions {
-	s3Bucket: string;
-	cloudFrontId: string;
-	cloudFrontInvalidationPaths?: string[];
-	buildTarget: string;
-	assetsDir: string;
-	rootDir?: string;
-	skipBuild?: boolean;
-	typings?: boolean;
-	dryRun?: boolean;
-	ignoreConfigs?: string[];
-}
-export function deployExecutor(opts: ExecutorOptions, ctx: ExecutorContext): Promise<ExecutorResponse>;
-export interface ExecutorOptions {
-}
-declare function runExecutor(_opts: ExecutorOptions, ctx: ExecutorContext): Promise<ExecutorResponse>;
-export interface ExecutorOptions {
-	unlink?: boolean;
-}
-declare function runExecutor(opts: ExecutorOptions, context: 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>;
-declare function runExecutor(_opts: any, 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 type ViteConfig = ViteUserConfig & {
-	test?: VitestInlineConfig;
-};
-export declare enum ViteMode {
-	PROD = "production",
-	DEV = "development",
-	TEST = "test"
-}
-/**
- * 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",
-	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",
-	HTTPS = "https"
-}
-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 {ViteConfig} 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: ({ projectConfig }: Context) => 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 {};