@shell-shock/nx 0.0.83 → 0.0.84

package/dist/plugin/index.js

@@ -1,8 +1,501 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-let _powerlines_nx_helpers_plugin_utilities = require("@powerlines/nx/helpers/plugin-utilities");
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
 
+//#endregion
+let _stryke_string_format_kebab_case = require("@stryke/string-format/kebab-case");
+let _stryke_string_format_title_case = require("@stryke/string-format/title-case");
+let _stryke_type_checks_is_error = require("@stryke/type-checks/is-error");
+let _stryke_type_checks_is_set_object = require("@stryke/type-checks/is-set-object");
+let defu = require("defu");
+defu = __toESM(defu, 1);
+let _nx_devkit = require("@nx/devkit");
+let _storm_software_workspace_tools_utils_nx_json = require("@storm-software/workspace-tools/utils/nx-json");
+let _storm_software_workspace_tools_utils_plugin_helpers = require("@storm-software/workspace-tools/utils/plugin-helpers");
+let _storm_software_workspace_tools_utils_project_tags = require("@storm-software/workspace-tools/utils/project-tags");
+let _stryke_path_join_paths = require("@stryke/path/join-paths");
+let node_os = require("node:os");
+node_os = __toESM(node_os, 1);
+let node_path = require("node:path");
+node_path = __toESM(node_path, 1);
+let node_fs = require("node:fs");
+let node_fs_promises = require("node:fs/promises");
+let _stryke_type_checks_is_set_string = require("@stryke/type-checks/is-set-string");
+let nx_src_config_nx_json_js = require("nx/src/config/nx-json.js");
+let nx_src_utils_package_json_js = require("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 = node_os.default.homedir();
+const tmpdir = node_os.default.tmpdir();
+const macos = (orgId) => {
+	const library = (0, _stryke_path_join_paths.joinPaths)(homedir, "Library");
+	return {
+		data: (0, _stryke_path_join_paths.joinPaths)(library, "Application Support", orgId),
+		config: (0, _stryke_path_join_paths.joinPaths)(library, "Preferences", orgId),
+		cache: (0, _stryke_path_join_paths.joinPaths)(library, "Caches", orgId),
+		log: (0, _stryke_path_join_paths.joinPaths)(library, "Logs", orgId),
+		temp: (0, _stryke_path_join_paths.joinPaths)(tmpdir, orgId)
+	};
+};
+const windows = (orgId) => {
+	const appData = process.env.APPDATA || (0, _stryke_path_join_paths.joinPaths)(homedir, "AppData", "Roaming");
+	const localAppData = process.env.LOCALAPPDATA || (0, _stryke_path_join_paths.joinPaths)(homedir, "AppData", "Local");
+	const windowsFormattedOrgId = (0, _stryke_string_format_title_case.titleCase)(orgId).trim().replace(/\s+/g, "");
+	return {
+		data: (0, _stryke_path_join_paths.joinPaths)(localAppData, windowsFormattedOrgId, "Data"),
+		config: (0, _stryke_path_join_paths.joinPaths)(appData, windowsFormattedOrgId, "Config"),
+		cache: (0, _stryke_path_join_paths.joinPaths)(localAppData, "Cache", orgId),
+		log: (0, _stryke_path_join_paths.joinPaths)(localAppData, windowsFormattedOrgId, "Log"),
+		temp: (0, _stryke_path_join_paths.joinPaths)(tmpdir, orgId)
+	};
+};
+const linux = (orgId) => {
+	const username = node_path.default.basename(homedir);
+	return {
+		data: (0, _stryke_path_join_paths.joinPaths)(process.env.XDG_DATA_HOME || (0, _stryke_path_join_paths.joinPaths)(homedir, ".local", "share"), orgId),
+		config: (0, _stryke_path_join_paths.joinPaths)(process.env.XDG_CONFIG_HOME || (0, _stryke_path_join_paths.joinPaths)(homedir, ".config"), orgId),
+		cache: (0, _stryke_path_join_paths.joinPaths)(process.env.XDG_CACHE_HOME || (0, _stryke_path_join_paths.joinPaths)(homedir, ".cache"), orgId),
+		log: (0, _stryke_path_join_paths.joinPaths)(process.env.XDG_STATE_HOME || (0, _stryke_path_join_paths.joinPaths)(homedir, ".local", "state"), orgId),
+		temp: process.env.DEVENV_RUNTIME || process.env.XDG_RUNTIME_DIR ? (0, _stryke_path_join_paths.joinPaths)(process.env.DEVENV_RUNTIME || process.env.XDG_RUNTIME_DIR, orgId) : (0, _stryke_path_join_paths.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 ??= (0, _stryke_path_join_paths.joinPaths)(options.workspaceRoot, "node_modules", ".cache", orgId);
+		result.temp ??= (0, _stryke_path_join_paths.joinPaths)(options.workspaceRoot, "tmp", orgId);
+		result.log ??= (0, _stryke_path_join_paths.joinPaths)(result.temp, "logs");
+		result.config ??= (0, _stryke_path_join_paths.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 ? (0, _stryke_path_join_paths.joinPaths)(filePath, options.appId) : filePath;
+			if (options.nestedDir && options.nestedDir !== options.orgId && options.nestedDir !== options.appId) ret[key] = (0, _stryke_path_join_paths.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(filePath) {
+	return (0, node_fs.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 = (0, _stryke_string_format_kebab_case.kebabCase)(opts?.framework) || "powerlines";
+	const title = `${(0, _stryke_string_format_title_case.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 = (0, nx_src_config_nx_json_js.readNxJson)(contextV2.workspaceRoot);
+			return (0, _nx_devkit.createNodesFromFiles)(async (configFile, _, context) => {
+				try {
+					const projectRoot = (0, _storm_software_workspace_tools_utils_plugin_helpers.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 = (0, _storm_software_workspace_tools_utils_plugin_helpers.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((0, _stryke_path_join_paths.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: "${(0, _stryke_path_join_paths.joinPaths)(contextV2.workspaceRoot, projectRoot)}"). Skipping project configuration.`);
+						return {};
+					}
+					const packageJsonContent = await (0, node_fs_promises.readFile)((0, _stryke_path_join_paths.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 = (0, _storm_software_workspace_tools_utils_plugin_helpers.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 = (0, nx_src_utils_package_json_js.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 : (0, _storm_software_workspace_tools_utils_nx_json.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 : (0, _storm_software_workspace_tools_utils_nx_json.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 : (0, _storm_software_workspace_tools_utils_nx_json.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 : (0, _stryke_type_checks_is_set_object.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 : (0, _storm_software_workspace_tools_utils_nx_json.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 : (0, _stryke_type_checks_is_set_object.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 : (0, _storm_software_workspace_tools_utils_nx_json.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 : (0, _stryke_type_checks_is_set_object.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 : (0, _storm_software_workspace_tools_utils_nx_json.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 : (0, _stryke_type_checks_is_set_object.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
+							}
+						}
+					};
+					(0, _storm_software_workspace_tools_utils_project_tags.setDefaultProjectTags)(projectConfig, name);
+					(0, _storm_software_workspace_tools_utils_project_tags.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]: (0, defu.default)(projectConfig, {
+						projectType: projectConfig.projectType || "library",
+						root,
+						sourceRoot: (0, _stryke_path_join_paths.joinPaths)(root, "src"),
+						targets
+					}) } };
+				} catch (error) {
+					console.error(`[${title}] - ${(/* @__PURE__ */ new Date()).toISOString()} - Failed to process the project configuration for file "${configFile}" - ${(0, _stryke_type_checks_is_error.isError)(error) ? error.message : (0, _stryke_type_checks_is_set_string.isSetString)(error) ? error : "Unknown fatal error"}`);
+					return {};
+				}
+			}, configFiles, options, contextV2);
+		}];
+	} catch (error) {
+		console.error(`[${title}] - ${(/* @__PURE__ */ new Date()).toISOString()} - ${(0, _stryke_type_checks_is_error.isError)(error) ? error.message : (0, _stryke_type_checks_is_set_string.isSetString)(error) ? error : "Unknown fatal error during plugin initialization"}`);
+		throw new Error(`Failed to initialize the ${title} - ${(0, _stryke_type_checks_is_error.isError)(error) ? error.message : (0, _stryke_type_checks_is_set_string.isSetString)(error) ? error : "See previous logs for more details"}`, { cause: error instanceof Error ? error : void 0 });
+	}
+}
+
+//#endregion
 //#region src/plugin/index.ts
-const createNodesV2 = (0, _powerlines_nx_helpers_plugin_utilities.createNxPlugin)({ framework: "shell-shock" });
+const createNodesV2 = createNxPlugin({ framework: "shell-shock" });
 
 //#endregion
 exports.createNodesV2 = createNodesV2;