@shell-shock/nx 0.0.83 → 0.0.84

package/dist/plugin/index.mjs

@@ -1,5 +1,468 @@
-import { createNxPlugin } from "@powerlines/nx/helpers/plugin-utilities";
+import { kebabCase } from "@stryke/string-format/kebab-case";
+import { titleCase } from "@stryke/string-format/title-case";
+import { isError } from "@stryke/type-checks/is-error";
+import { isSetObject } from "@stryke/type-checks/is-set-object";
+import defu from "defu";
+import { createNodesFromFiles } from "@nx/devkit";
+import { withNamedInputs } from "@storm-software/workspace-tools/utils/nx-json";
+import { getProjectConfigFromProjectRoot, getProjectRoot, getRoot } from "@storm-software/workspace-tools/utils/plugin-helpers";
+import { addProjectTag, setDefaultProjectTags } from "@storm-software/workspace-tools/utils/project-tags";
+import { joinPaths } from "@stryke/path/join-paths";
+import os from "node:os";
+import path from "node:path";
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { isSetString } from "@stryke/type-checks/is-set-string";
+import { readNxJson } from "nx/src/config/nx-json.js";
+import { readTargetsFromPackageJson } from "nx/src/utils/package-json.js";
 
+//#region ../../node_modules/.pnpm/@powerlines+nx@0.13.163_9456f17d791dfffcdb67c022b29fb589/node_modules/@powerlines/nx/dist/src/helpers/constants.mjs
+/**
+* A list of Nx input strings that describe the Powerlines configuration file
+*/
+const CONFIG_INPUTS = [
+	"{projectRoot}/{framework}.json",
+	"{projectRoot}/{framework}.*.json",
+	"{projectRoot}/{framework}.jsonc",
+	"{projectRoot}/{framework}.*.jsonc",
+	"{projectRoot}/{framework}.json5",
+	"{projectRoot}/{framework}.*.json5",
+	"{projectRoot}/{framework}.yaml",
+	"{projectRoot}/{framework}.*.yaml",
+	"{projectRoot}/{framework}.yml",
+	"{projectRoot}/{framework}.*.yml",
+	"{projectRoot}/{framework}.toml",
+	"{projectRoot}/{framework}.*.toml",
+	"{projectRoot}/{framework}.config.js",
+	"{projectRoot}/{framework}.*.config.js",
+	"{projectRoot}/{framework}.config.cjs",
+	"{projectRoot}/{framework}.*.config.cjs",
+	"{projectRoot}/{framework}.config.mjs",
+	"{projectRoot}/{framework}.*.config.mjs",
+	"{projectRoot}/{framework}.config.ts",
+	"{projectRoot}/{framework}.*.config.ts",
+	"{projectRoot}/{framework}.config.cts",
+	"{projectRoot}/{framework}.*.config.cts",
+	"{projectRoot}/{framework}.config.mts",
+	"{projectRoot}/{framework}.*.config.mts"
+];
+
+//#endregion
+//#region ../../node_modules/.pnpm/@stryke+env@0.20.102_@nx+jest@22.7.5_@babel+traverse@7.29.7_@swc-node+register@1.11.1_@_506406da618bb04e125369d0dfadeb01/node_modules/@stryke/env/dist/ci-checks.mjs
+/**
+*  Returns true if the current environment is a CI environment.
+*
+* @returns True if the current environment is a CI environment.
+*/
+const isCI = (env = process.env) => {
+	return Boolean(env.STORM_CI || env.CI || env.CONTINUOUS_INTEGRATION || env.BUILD_NUMBER || env.RUN_ID || env.AGOLA_GIT_REF || env.AC_APPCIRCLE || env.APPVEYOR || env.CODEBUILD || env.TF_BUILD || env.bamboo_planKey || env.BITBUCKET_COMMIT || env.BITRISE_IO || env.BUDDY_WORKSPACE_ID || env.BUILDKITE || env.CIRCLECI || env.CIRRUS_CI || env.CF_BUILD_ID || env.CM_BUILD_ID || env.CI_NAME || env.DRONE || env.DSARI || env.EARTHLY_CI || env.EAS_BUILD || env.GERRIT_PROJECT || env.GITEA_ACTIONS || env.GITHUB_ACTIONS || env.GITLAB_CI || env.GOCD || env.BUILDER_OUTPUT || env.HARNESS_BUILD_ID || env.JENKINS_URL || env.BUILD_ID || env.LAYERCI || env.MAGNUM || env.NETLIFY || env.NEVERCODE || env.PROW_JOB_ID || env.RELEASE_BUILD_ID || env.RENDER || env.SAILCI || env.HUDSON || env.JENKINS_URL || env.BUILD_ID || env.SCREWDRIVER || env.SEMAPHORE || env.SOURCEHUT || env.STRIDER || env.TASK_ID || env.RUN_ID || env.TEAMCITY_VERSION || env.TRAVIS || env.VELA || env.NOW_BUILDER || env.APPCENTER_BUILD_ID || env.CI_XCODE_PROJECT || env.XCS || false);
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/@stryke+env@0.20.102_@nx+jest@22.7.5_@babel+traverse@7.29.7_@swc-node+register@1.11.1_@_506406da618bb04e125369d0dfadeb01/node_modules/@stryke/env/dist/environment-checks.mjs
+/** Value of process.platform */
+const platform = process?.platform || "";
+/** Detect if stdout.TTY is available */
+const hasTTY = Boolean(process?.stdout && process?.stdout.isTTY);
+/** Detect if `DEBUG` environment variable is set */
+const isDebug = Boolean(process.env.DEBUG);
+/** Detect the `NODE_ENV` environment variable */
+const mode = process.env.STORM_MODE || process.env.NEXT_PUBLIC_VERCEL_ENV || process.env.NODE_ENV || "production";
+/** Detect if the application is running in a staging environment */
+const isStaging = [
+	"stg",
+	"stage",
+	"staging"
+].includes(mode?.toLowerCase());
+/**
+* Check if the current environment is production.
+*
+* @param mode - The mode string to check.
+* @returns Whether the environment is production
+*/
+function isProductionMode(mode) {
+	return [
+		"prd",
+		"prod",
+		"production",
+		"preprod",
+		"preproduction",
+		"uat"
+	].includes(mode?.toLowerCase()?.replace(/[\s\-_]/g, ""));
+}
+/** Detect if `NODE_ENV` environment variable is `production` */
+const isProduction = isProductionMode(mode);
+/**
+* Check if the current environment is test.
+*
+* @param mode - The mode string to check.
+* @returns Whether the environment is test
+*/
+function isTestMode(mode) {
+	return [
+		"tst",
+		"test",
+		"testing",
+		"stg",
+		"stage",
+		"staging",
+		"qa",
+		"qualityassurance"
+	].includes(mode?.toLowerCase()?.replace(/[\s\-_]/g, ""));
+}
+/** Detect if `NODE_ENV` environment variable is `test` */
+const isTest = isTestMode(mode) || isStaging || Boolean(process.env.TEST);
+/**
+* Check if the current environment is development.
+*
+* @param mode - The mode string to check.
+* @returns Whether the environment is development
+*/
+function isDevelopmentMode(mode) {
+	return [
+		"dev",
+		"development",
+		"int",
+		"integration"
+	].includes(mode?.toLowerCase()?.replace(/[\s\-_]/g, ""));
+}
+/** Detect if `NODE_ENV` environment variable is `dev` or `development` */
+const isDevelopment = isDevelopmentMode(mode) || isDebug;
+/** Detect if MINIMAL environment variable is set, running in CI or test or TTY is unavailable */
+const isMinimal = Boolean(process.env.MINIMAL) || isCI() || isTest || !hasTTY;
+/** Detect if process.platform is Windows */
+const isWindows = /^win/i.test(platform);
+/** Detect if process.platform is Linux */
+const isLinux = /^linux/i.test(platform);
+/** Detect if process.platform is macOS (darwin kernel) */
+const isMacOS = /^darwin/i.test(platform);
+/** Color Support */
+const isColorSupported = !process.env.NO_COLOR && (Boolean(process.env.FORCE_COLOR) || (hasTTY || isWindows) && process.env.TERM !== "dumb" || isCI());
+/** Node.js versions */
+const nodeVersion = (process?.versions?.node || "").replace(/^v/, "") || null;
+const nodeMajorVersion = Number(nodeVersion?.split(".")[0]) || null;
+
+//#endregion
+//#region ../../node_modules/.pnpm/@stryke+env@0.20.102_@nx+jest@22.7.5_@babel+traverse@7.29.7_@swc-node+register@1.11.1_@_506406da618bb04e125369d0dfadeb01/node_modules/@stryke/env/dist/get-env-paths.mjs
+const homedir = os.homedir();
+const tmpdir = os.tmpdir();
+const macos = (orgId) => {
+	const library = joinPaths(homedir, "Library");
+	return {
+		data: joinPaths(library, "Application Support", orgId),
+		config: joinPaths(library, "Preferences", orgId),
+		cache: joinPaths(library, "Caches", orgId),
+		log: joinPaths(library, "Logs", orgId),
+		temp: joinPaths(tmpdir, orgId)
+	};
+};
+const windows = (orgId) => {
+	const appData = process.env.APPDATA || joinPaths(homedir, "AppData", "Roaming");
+	const localAppData = process.env.LOCALAPPDATA || joinPaths(homedir, "AppData", "Local");
+	const windowsFormattedOrgId = titleCase(orgId).trim().replace(/\s+/g, "");
+	return {
+		data: joinPaths(localAppData, windowsFormattedOrgId, "Data"),
+		config: joinPaths(appData, windowsFormattedOrgId, "Config"),
+		cache: joinPaths(localAppData, "Cache", orgId),
+		log: joinPaths(localAppData, windowsFormattedOrgId, "Log"),
+		temp: joinPaths(tmpdir, orgId)
+	};
+};
+const linux = (orgId) => {
+	const username = path.basename(homedir);
+	return {
+		data: joinPaths(process.env.XDG_DATA_HOME || joinPaths(homedir, ".local", "share"), orgId),
+		config: joinPaths(process.env.XDG_CONFIG_HOME || joinPaths(homedir, ".config"), orgId),
+		cache: joinPaths(process.env.XDG_CACHE_HOME || joinPaths(homedir, ".cache"), orgId),
+		log: joinPaths(process.env.XDG_STATE_HOME || joinPaths(homedir, ".local", "state"), orgId),
+		temp: process.env.DEVENV_RUNTIME || process.env.XDG_RUNTIME_DIR ? joinPaths(process.env.DEVENV_RUNTIME || process.env.XDG_RUNTIME_DIR, orgId) : joinPaths(tmpdir, username, orgId)
+	};
+};
+/**
+* Get paths for storing things like data, config, logs, and cache in the current runtime environment.
+*
+* @remarks
+* On macOS, directories are generally created in `~/Library/Application Support/<name>`.
+* On Windows, directories are generally created in `%AppData%/<name>`.
+* On Linux, directories are generally created in `~/.config/<name>` - this is determined via the [XDG Base Directory spec](https://specifications.freedesktop.org/basedir-spec/latest/).
+*
+* If the `STORM_DATA_DIR`, `STORM_CONFIG_DIR`, `STORM_CACHE_DIR`, `STORM_LOG_DIR`, or `STORM_TEMP_DIR` environment variables are set, they will be used instead of the default paths.
+*
+* @param options - Parameters used to determine the specific paths for the current project/runtime environment
+* @returns An object containing the various paths for the runtime environment
+*/
+function getEnvPaths(options = {}) {
+	let orgId = options.orgId || "storm-software";
+	if (!orgId) throw new Error("You need to provide an orgId to the `getEnvPaths` function");
+	if (options.suffix) orgId += `-${typeof options.suffix === "string" ? options.suffix : "nodejs"}`;
+	let result = {};
+	if (process.platform === "darwin") result = macos(orgId);
+	else if (process.platform === "win32") result = windows(orgId);
+	else result = linux(orgId);
+	if (process.env.STORM_DATA_DIR) result.data = process.env.STORM_DATA_DIR;
+	else if (process.env.STORM_CONFIG_DIR) result.config = process.env.STORM_CONFIG_DIR;
+	else if (process.env.STORM_CACHE_DIR) result.cache = process.env.STORM_CACHE_DIR;
+	else if (process.env.STORM_LOG_DIR) result.log = process.env.STORM_LOG_DIR;
+	else if (process.env.STORM_TEMP_DIR) result.temp = process.env.STORM_TEMP_DIR;
+	if (options.workspaceRoot) {
+		result.cache ??= joinPaths(options.workspaceRoot, "node_modules", ".cache", orgId);
+		result.temp ??= joinPaths(options.workspaceRoot, "tmp", orgId);
+		result.log ??= joinPaths(result.temp, "logs");
+		result.config ??= joinPaths(options.workspaceRoot, ".config", orgId);
+	}
+	return Object.keys(result).reduce((ret, key) => {
+		if (result[key]) {
+			const filePath = result[key];
+			ret[key] = options.appId && options.appId !== options.orgId && options.appId !== options.nestedDir ? joinPaths(filePath, options.appId) : filePath;
+			if (options.nestedDir && options.nestedDir !== options.orgId && options.nestedDir !== options.appId) ret[key] = joinPaths(ret[key], options.nestedDir);
+		}
+		return ret;
+	}, {});
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@stryke+fs@0.33.85_@nx+jest@22.7.5_@babel+traverse@7.29.7_@swc-node+register@1.11.1_@sw_877f1a6d15b15de58e6bb8cae69ca90b/node_modules/@stryke/fs/dist/exists.mjs
+/**
+* Check if a file exists
+*
+* @param filePath - The file path to check
+* @returns An indicator specifying if the file exists
+*/
+function existsSync$1(filePath) {
+	return existsSync(filePath);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@powerlines+nx@0.13.163_9456f17d791dfffcdb67c022b29fb589/node_modules/@powerlines/nx/dist/src/helpers/plugin-utilities.mjs
+/**
+* Generates Nx input strings for the Powerlines configuration file, replacing the `{framework}` placeholder with the specified framework name.
+*
+* @param framework - The framework name to use in the input strings
+* @returns An array of Nx input strings for the configuration file
+*/
+function getNxTargetInputs(framework) {
+	return CONFIG_INPUTS.map((input) => input.replace("{framework}", framework));
+}
+/**
+* Generates Nx input strings for the Powerlines configuration file, replacing the `{framework}` placeholder with the specified framework name.
+*
+* @param framework - The framework name to use in the input strings
+* @returns An array of Nx input strings for the configuration file
+*/
+function getNxPluginInputs(framework) {
+	return `**/{${getNxTargetInputs(framework).map((input) => input.replace("{projectRoot}/", "")).join(",")}}`;
+}
+/**
+* Creates an Nx plugin that integrates Powerlines into the Nx build process.
+*
+* @param opts - Options for creating the Nx plugin
+* @returns A CreateNodesV2 function that can be used as an Nx plugin
+*/
+function createNxPlugin(opts) {
+	const framework = kebabCase(opts?.framework) || "powerlines";
+	const title = `${titleCase(framework)} Nx Plugin`;
+	try {
+		const name = opts?.name || `${framework}/nx/plugin`;
+		const artifactsFolder = opts?.artifactsFolder || `{projectRoot}/.${framework}`;
+		const targetInputs = getNxTargetInputs(framework);
+		const pluginInputs = getNxPluginInputs(framework);
+		return [pluginInputs, async (configFiles, options, contextV2) => {
+			if (options?.verboseOutput) console.debug(`[${title}] - ${(/* @__PURE__ */ new Date()).toISOString()} - Initializing the ${title} for the following inputs: ${pluginInputs}`);
+			if (!getEnvPaths({
+				orgId: "storm-software",
+				appId: framework,
+				workspaceRoot: contextV2.workspaceRoot
+			}).cache) throw new Error("The cache directory could not be determined.");
+			const nxJson = readNxJson(contextV2.workspaceRoot);
+			return createNodesFromFiles(async (configFile, _, context) => {
+				try {
+					const projectRoot = getProjectRoot(configFile, contextV2.workspaceRoot);
+					if (!projectRoot) {
+						console.error(`[${title}] - ${(/* @__PURE__ */ new Date()).toISOString()} - package.json and ${framework} configuration files (i.e. ${framework}.config.ts) must be located in the project root directory: ${configFile}`);
+						return {};
+					}
+					const root = getRoot(projectRoot, context);
+					if (options?.verboseOutput) console.debug(`[${title}] - ${(/* @__PURE__ */ new Date()).toISOString()} - Loading ${framework} user configuration for project in root directory ${projectRoot}.`);
+					if (!existsSync$1(joinPaths(contextV2.workspaceRoot, projectRoot, "package.json"))) {
+						if (options?.verboseOutput) console.warn(`[${title}] - ${(/* @__PURE__ */ new Date()).toISOString()} - Cannot find \`package.json\` file in the project's root directory (path: "${joinPaths(contextV2.workspaceRoot, projectRoot)}"). Skipping project configuration.`);
+						return {};
+					}
+					const packageJsonContent = await readFile(joinPaths(contextV2.workspaceRoot, projectRoot, "package.json"), "utf8");
+					if (!packageJsonContent) {
+						if (options?.verboseOutput) console.warn(`[${title}] - ${(/* @__PURE__ */ new Date()).toISOString()} - No package.json file found for project in root directory ${projectRoot}`);
+						return {};
+					}
+					const packageJson = JSON.parse(packageJsonContent);
+					const projectConfig = getProjectConfigFromProjectRoot(projectRoot, packageJson);
+					if (!projectConfig) {
+						if (options?.verboseOutput) console.warn(`[${title}] - ${(/* @__PURE__ */ new Date()).toISOString()} - No project configuration found for project in root directory ${projectRoot}`);
+						return {};
+					}
+					const targets = readTargetsFromPackageJson(packageJson, nxJson, projectRoot, context.workspaceRoot);
+					if (options?.verboseOutput) console.debug(`[${title}] - ${(/* @__PURE__ */ new Date()).toISOString()} - Preparing Nx targets for project in root directory ${projectRoot}.`);
+					if (options?.clean !== false && !targets[options?.clean?.targetName || "clean"]) targets[options?.clean?.targetName || "clean"] = {
+						cache: options?.clean?.cache ?? options?.cache ?? true,
+						inputs: Array.isArray(options?.clean?.inputs) ? options.clean.inputs : withNamedInputs(targetInputs, [options?.clean?.inputs || "typescript"]),
+						outputs: options?.clean?.outputs,
+						executor: options?.clean?.executor || `@${framework}/nx:${options?.clean?.targetName || "clean"}`,
+						dependsOn: options?.clean?.dependsOn ?? [`^${options?.clean?.targetName || "clean"}`],
+						defaultConfiguration: options?.clean?.defaultConfiguration || "production",
+						options: {
+							root: projectRoot,
+							configFile,
+							projectType: projectConfig.projectType,
+							outputPath: `{workspaceRoot}/${projectRoot}/dist`,
+							copyPath: `{workspaceRoot}/dist/${projectRoot}`
+						},
+						configurations: {
+							production: { mode: "production" },
+							test: { mode: "test" },
+							development: {
+								mode: "development",
+								skipCache: true
+							}
+						}
+					};
+					if (options?.prepare !== false && !targets[options?.prepare?.targetName || "prepare"]) targets[options?.prepare?.targetName || "prepare"] = {
+						cache: options?.prepare?.cache ?? options?.cache ?? true,
+						inputs: Array.isArray(options?.prepare?.inputs) ? options.prepare.inputs : withNamedInputs(targetInputs, [options?.prepare?.inputs || "typescript"]),
+						outputs: options?.prepare?.outputs ?? [artifactsFolder],
+						executor: options?.prepare?.executor || `@${framework}/nx:${options?.prepare?.targetName || "prepare"}`,
+						dependsOn: options?.prepare?.dependsOn ?? [`^${options?.prepare?.targetName || "build"}`].filter(Boolean),
+						defaultConfiguration: options?.prepare?.defaultConfiguration || "production",
+						options: {
+							projectType: projectConfig.projectType,
+							configFile,
+							outputPath: `{workspaceRoot}/${projectRoot}/dist`,
+							copyPath: `{workspaceRoot}/dist/${projectRoot}`
+						},
+						configurations: {
+							production: { mode: "production" },
+							test: { mode: "test" },
+							development: {
+								mode: "development",
+								skipCache: true
+							}
+						}
+					};
+					if (options?.build !== false && !targets[options?.build?.targetName || "build"]) targets[options?.build?.targetName || "build"] = {
+						cache: options?.build?.cache ?? options?.cache ?? true,
+						inputs: Array.isArray(options?.build?.inputs) ? options.build.inputs : withNamedInputs(targetInputs, [options?.build?.inputs || "typescript"]),
+						outputs: options?.build?.outputs ?? ["{options.outputPath}"],
+						executor: options?.build?.executor || `@${framework}/nx:${options?.build?.targetName || "build"}`,
+						dependsOn: options?.build?.dependsOn ?? [`^${options?.build?.targetName || "build"}`, isDevelopment ? void 0 : isSetObject(options?.prepare) && options?.prepare?.targetName ? options?.prepare?.targetName : "prepare"].filter(Boolean),
+						defaultConfiguration: options?.build?.defaultConfiguration || "production",
+						options: {
+							projectType: projectConfig.projectType,
+							configFile,
+							outputPath: `{workspaceRoot}/${projectRoot}/dist`,
+							copyPath: `{workspaceRoot}/dist/${projectRoot}`
+						},
+						configurations: {
+							production: { mode: "production" },
+							test: { mode: "test" },
+							development: {
+								mode: "development",
+								skipCache: true
+							}
+						}
+					};
+					if (options?.lint !== false && !targets[options?.lint?.targetName || "lint"]) targets[options?.lint?.targetName || "lint"] = {
+						cache: options?.lint?.cache ?? options?.cache ?? true,
+						inputs: Array.isArray(options?.lint?.inputs) ? options.lint.inputs : withNamedInputs([...targetInputs, artifactsFolder], options?.lint?.inputs ? [options.lint.inputs] : ["linting", "typescript"]),
+						outputs: options?.lint?.outputs ?? ["{options.outputPath}"],
+						executor: options?.lint?.executor || `@${framework}/nx:${options?.lint?.targetName || "lint"}`,
+						dependsOn: options?.lint?.dependsOn ?? [`^${options?.lint?.targetName || "lint"}`, isDevelopment ? void 0 : isSetObject(options?.prepare) && options?.prepare?.targetName ? options?.prepare?.targetName : "prepare"].filter(Boolean),
+						defaultConfiguration: options?.lint?.defaultConfiguration || "production",
+						options: {
+							projectType: projectConfig.projectType,
+							configFile,
+							outputPath: `{workspaceRoot}/${projectRoot}/dist`,
+							copyPath: `{workspaceRoot}/dist/${projectRoot}`
+						},
+						configurations: {
+							production: { mode: "production" },
+							test: { mode: "test" },
+							development: {
+								mode: "development",
+								skipCache: true
+							}
+						}
+					};
+					if (options?.docs !== false && !targets[options?.docs?.targetName || "docs"]) targets[options?.docs?.targetName || "docs"] = {
+						cache: options?.docs?.cache ?? options?.cache ?? true,
+						inputs: Array.isArray(options?.docs?.inputs) ? options.docs.inputs : withNamedInputs([...targetInputs, artifactsFolder], options?.docs?.inputs ? [options.docs.inputs] : ["documentation", "typescript"]),
+						outputs: options?.docs?.outputs ?? ["{options.outputPath}"],
+						executor: options?.docs?.executor || `@${framework}/nx:${options?.docs?.targetName || "docs"}`,
+						dependsOn: options?.docs?.dependsOn ?? [
+							`^${options?.docs?.targetName || "docs"}`,
+							options?.build !== false && `${options?.build?.targetName || "build"}`,
+							isDevelopment ? void 0 : isSetObject(options?.prepare) && options?.prepare?.targetName ? options?.prepare?.targetName : "prepare"
+						].filter(Boolean),
+						defaultConfiguration: options?.docs?.defaultConfiguration || "production",
+						options: {
+							projectType: projectConfig.projectType,
+							configFile,
+							outputPath: `{workspaceRoot}/${projectRoot}/dist`,
+							copyPath: `{workspaceRoot}/dist/${projectRoot}`
+						},
+						configurations: {
+							production: { mode: "production" },
+							test: { mode: "test" },
+							development: {
+								mode: "development",
+								skipCache: true
+							}
+						}
+					};
+					if (options?.deploy !== false && !targets[options?.deploy?.targetName || "deploy"]) targets[options?.deploy?.targetName || "deploy"] = {
+						cache: options?.deploy?.cache ?? false,
+						inputs: Array.isArray(options?.deploy?.inputs) ? options.deploy.inputs : withNamedInputs([...targetInputs, artifactsFolder], options?.deploy?.inputs ? [options.deploy.inputs] : ["documentation", "typescript"]),
+						outputs: options?.deploy?.outputs ?? ["{options.outputPath}"],
+						executor: options?.deploy?.executor || `@${framework}/nx:${options?.deploy?.targetName || "deploy"}`,
+						dependsOn: options?.deploy?.dependsOn ?? [
+							`^${options?.deploy?.targetName || "deploy"}`,
+							options?.build !== false && `${options?.build?.targetName || "build"}`,
+							isDevelopment ? void 0 : isSetObject(options?.prepare) && options?.prepare?.targetName ? options?.prepare?.targetName : "prepare"
+						].filter(Boolean),
+						defaultConfiguration: options?.deploy?.defaultConfiguration || "production",
+						options: {
+							projectType: projectConfig.projectType,
+							configFile,
+							outputPath: `{workspaceRoot}/${projectRoot}/dist`,
+							copyPath: `{workspaceRoot}/dist/${projectRoot}`
+						},
+						configurations: {
+							production: { mode: "production" },
+							test: { mode: "test" },
+							development: {
+								mode: "development",
+								skipCache: true
+							}
+						}
+					};
+					setDefaultProjectTags(projectConfig, name);
+					addProjectTag(projectConfig, framework, projectConfig.projectType || "library", { overwrite: true });
+					if (options?.verboseOutput) console.debug(`[${title}] - ${(/* @__PURE__ */ new Date()).toISOString()} - Completed preparing Nx configuration for project in root directory ${projectRoot}.`);
+					return { projects: { [root]: defu(projectConfig, {
+						projectType: projectConfig.projectType || "library",
+						root,
+						sourceRoot: joinPaths(root, "src"),
+						targets
+					}) } };
+				} catch (error) {
+					console.error(`[${title}] - ${(/* @__PURE__ */ new Date()).toISOString()} - Failed to process the project configuration for file "${configFile}" - ${isError(error) ? error.message : isSetString(error) ? error : "Unknown fatal error"}`);
+					return {};
+				}
+			}, configFiles, options, contextV2);
+		}];
+	} catch (error) {
+		console.error(`[${title}] - ${(/* @__PURE__ */ new Date()).toISOString()} - ${isError(error) ? error.message : isSetString(error) ? error : "Unknown fatal error during plugin initialization"}`);
+		throw new Error(`Failed to initialize the ${title} - ${isError(error) ? error.message : isSetString(error) ? error : "See previous logs for more details"}`, { cause: error instanceof Error ? error : void 0 });
+	}
+}
+
+//#endregion
 //#region src/plugin/index.ts
 const createNodesV2 = createNxPlugin({ framework: "shell-shock" });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shell-shock/nx",
-  "version": "0.0.83",
+  "version": "0.0.84",
   "description": "A Nx plugin to support Shell Shock development in Nx monorepos.",
   "repository": {
     "type": "github",
@@ -104,5 +104,5 @@
   "peerDependencies": { "nx": ">=22.7.0" },
   "publishConfig": { "access": "public" },
   "executors": "./executors.json",
-  "gitHead": "9401c1de122d800040306fc89ad1835930c1a826"
+  "gitHead": "75ec717085aa5dd47d8840c84dee8aa953fb0f41"
 }