@powerlines/nx 0.11.218 → 0.11.219

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 # Changelog for Powerlines - Nx
 
+## [0.11.218](https://github.com/storm-software/powerlines/releases/tag/nx%400.11.218) (02/27/2026)
+
+### Features
+
+- **powerlines:** Update package structure for better single responsibility ([6c69d6846](https://github.com/storm-software/powerlines/commit/6c69d6846))
+
+### Updated Dependencies
+
+- Updated **powerlines** to **v0.39.0**
+
 ## [0.11.217](https://github.com/storm-software/powerlines/releases/tag/nx%400.11.217) (02/26/2026)
 
 ### Updated Dependencies

package/dist/{chunk-5NHMBXXZ.mjs → chunk-4KF5AUPD.mjs}

@@ -1,4 +1,4 @@
-import { withExecutor } from './chunk-EFG2AWKX.mjs';
+import { withExecutor } from './chunk-7EWOPOET.mjs';
 import { __name } from './chunk-O6YSETKJ.mjs';
 import defu from 'defu';
 

package/dist/{chunk-EFG2AWKX.mjs → chunk-7EWOPOET.mjs}

@@ -74,7 +74,7 @@ import 'unplugin';
 
 // ../powerlines/package.json
 var package_default = {
-  version: "0.38.57"};
+  version: "0.39.0"};
 var VirtualFileSystemHost = class extends InMemoryFileSystemHost {
   static {
     __name(this, "VirtualFileSystemHost");

package/dist/{chunk-XX6ZLY4D.mjs → chunk-FIOTA3DI.mjs}

@@ -1,4 +1,4 @@
-import { withExecutor } from './chunk-EFG2AWKX.mjs';
+import { withExecutor } from './chunk-7EWOPOET.mjs';
 import { __name } from './chunk-O6YSETKJ.mjs';
 
 // src/executors/lint/executor.ts

package/dist/{chunk-CINC3R52.mjs → chunk-GB6SETBZ.mjs}

@@ -1,4 +1,4 @@
-import { withExecutor } from './chunk-EFG2AWKX.mjs';
+import { withExecutor } from './chunk-7EWOPOET.mjs';
 import { __name } from './chunk-O6YSETKJ.mjs';
 
 // src/executors/clean/executor.ts

package/dist/{chunk-MDVQOPYK.js → chunk-GJ62I4AV.js}

@@ -1,9 +1,9 @@
 'use strict';
 
-var chunkEQMUIUSF_js = require('./chunk-EQMUIUSF.js');
+var chunkHNRM52ID_js = require('./chunk-HNRM52ID.js');
 
 // src/plugin/index.ts
-var createNodesV2 = chunkEQMUIUSF_js.createNxPlugin({
+var createNodesV2 = chunkHNRM52ID_js.createNxPlugin({
   framework: "powerlines"
 });
 

package/dist/chunk-HNRM52ID.js

@@ -0,0 +1,374 @@
+'use strict';
+
+var chunkFSGRYCTL_js = require('./chunk-FSGRYCTL.js');
+var chunkIQVSZEQ6_js = require('./chunk-IQVSZEQ6.js');
+var chunkSHUYVCID_js = require('./chunk-SHUYVCID.js');
+var devkit = require('@nx/devkit');
+var nxJson = require('@storm-software/workspace-tools/utils/nx-json');
+var pluginHelpers = require('@storm-software/workspace-tools/utils/plugin-helpers');
+var projectTags = require('@storm-software/workspace-tools/utils/project-tags');
+var getEnvPaths = require('@stryke/env/get-env-paths');
+var exists = require('@stryke/fs/exists');
+var murmurhash = require('@stryke/hash/murmurhash');
+var joinPaths = require('@stryke/path/join-paths');
+var kebabCase = require('@stryke/string-format/kebab-case');
+var titleCase = require('@stryke/string-format/title-case');
+var isError = require('@stryke/type-checks/is-error');
+var isSetObject = require('@stryke/type-checks/is-set-object');
+var defu = require('defu');
+var jiti = require('jiti');
+var promises = require('fs/promises');
+var nxJson_js = require('nx/src/config/nx-json.js');
+var packageJson_js = require('nx/src/utils/package-json.js');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var defu__default = /*#__PURE__*/_interopDefault(defu);
+
+function getNxTargetInputs(framework) {
+  return chunkIQVSZEQ6_js.CONFIG_INPUTS.map((input) => input.replace("{framework}", framework));
+}
+chunkSHUYVCID_js.__name(getNxTargetInputs, "getNxTargetInputs");
+function getNxPluginInputs(framework) {
+  return `**/{${getNxTargetInputs(framework).map((input) => input.replace("{projectRoot}/", "")).join(",")}}`;
+}
+chunkSHUYVCID_js.__name(getNxPluginInputs, "getNxPluginInputs");
+function createNxPlugin(opts) {
+  try {
+    const framework = opts?.framework || "powerlines";
+    const name = opts?.name || `${framework}/nx/plugin`;
+    const artifactsFolder = opts?.artifactsFolder || `{projectRoot}/.${framework}`;
+    const targetInputs = getNxTargetInputs(framework);
+    const pluginInputs = getNxPluginInputs(framework);
+    if (opts?.verboseOutput) {
+      console.debug(`[${name}] - ${(/* @__PURE__ */ new Date()).toISOString()} - Initializing the ${titleCase.titleCase(framework)} Nx plugin for the following inputs: ${pluginInputs}`);
+    }
+    return [
+      pluginInputs,
+      async (configFiles, options, contextV2) => {
+        const envPaths = getEnvPaths.getEnvPaths({
+          orgId: "storm-software",
+          appId: framework,
+          workspaceRoot: contextV2.workspaceRoot
+        });
+        if (!envPaths.cache) {
+          throw new Error("The cache directory could not be determined.");
+        }
+        const nxJson$1 = nxJson_js.readNxJson(contextV2.workspaceRoot);
+        const resolver = jiti.createJiti(contextV2.workspaceRoot, {
+          debug: !!options?.debug,
+          interopDefault: true,
+          fsCache: joinPaths.joinPaths(envPaths.cache, "nx-plugin", murmurhash.murmurhash(contextV2.workspaceRoot, {
+            maxLength: chunkFSGRYCTL_js.ROOT_HASH_LENGTH
+          }), "jiti"),
+          moduleCache: true
+        });
+        return devkit.createNodesFromFiles(async (configFile, _, context) => {
+          try {
+            const projectRoot = pluginHelpers.getProjectRoot(configFile, contextV2.workspaceRoot);
+            if (!projectRoot) {
+              console.error(`[${name}] - ${(/* @__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 = pluginHelpers.getRoot(projectRoot, context);
+            if (opts?.verboseOutput) {
+              console.debug(`[${name}] - ${(/* @__PURE__ */ new Date()).toISOString()} - Loading ${framework} user configuration for project in root directory ${projectRoot}.`);
+            }
+            const userConfig = await chunkFSGRYCTL_js.loadUserConfigFile(projectRoot, contextV2.workspaceRoot, resolver, "build", "development", configFile, framework);
+            if (!exists.existsSync(joinPaths.joinPaths(contextV2.workspaceRoot, projectRoot, "package.json"))) {
+              if (opts?.verboseOutput) {
+                console.warn(`[${name}] - ${(/* @__PURE__ */ new Date()).toISOString()} - Cannot find \`package.json\` file in the project's root directory (path: "${joinPaths.joinPaths(contextV2.workspaceRoot, projectRoot)}"). Skipping project configuration.`);
+              }
+              return {};
+            }
+            const packageJsonContent = await promises.readFile(joinPaths.joinPaths(contextV2.workspaceRoot, projectRoot, "package.json"), "utf8");
+            if (!packageJsonContent) {
+              if (opts?.verboseOutput) {
+                console.warn(`[${name}] - ${(/* @__PURE__ */ new Date()).toISOString()} - No package.json file found for project in root directory ${projectRoot}`);
+              }
+              return {};
+            }
+            const packageJson = JSON.parse(packageJsonContent);
+            if (!userConfig.configFile && !packageJson?.storm) {
+              if (opts?.verboseOutput) {
+                console.debug(`[${name}] - ${(/* @__PURE__ */ new Date()).toISOString()} - Skipping ${projectRoot} - no ${framework} configuration found for project in root directory.`);
+              }
+              return {};
+            }
+            const projectConfig = pluginHelpers.getProjectConfigFromProjectRoot(projectRoot, packageJson);
+            if (!projectConfig) {
+              if (opts?.verboseOutput) {
+                console.warn(`[${name}] - ${(/* @__PURE__ */ new Date()).toISOString()} - No project configuration found for project in root directory ${projectRoot}`);
+              }
+              return {};
+            }
+            const targets = packageJson_js.readTargetsFromPackageJson(packageJson, nxJson$1, projectRoot, context.workspaceRoot);
+            if (opts?.verboseOutput) {
+              console.debug(`[${name}] - ${(/* @__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: true,
+                inputs: Array.isArray(options?.clean?.inputs) ? options.clean.inputs : nxJson.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: {
+                  outputPath: userConfig.output?.outputPath || "dist/{projectRoot}",
+                  projectType: projectConfig.projectType || userConfig.projectType,
+                  autoInstall: userConfig.autoInstall
+                },
+                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: true,
+                inputs: Array.isArray(options?.prepare?.inputs) ? options.prepare.inputs : nxJson.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"}`,
+                  options?.clean !== false && `${options?.clean?.targetName || "clean"}`
+                ].filter(Boolean),
+                defaultConfiguration: options?.prepare?.defaultConfiguration || "production",
+                options: {
+                  input: userConfig.input,
+                  projectType: projectConfig.projectType || userConfig.projectType,
+                  autoInstall: userConfig.autoInstall,
+                  skipCache: userConfig.skipCache
+                },
+                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: true,
+                inputs: Array.isArray(options?.build?.inputs) ? options.build.inputs : nxJson.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"}`,
+                  userConfig.skipCache ? void 0 : isSetObject.isSetObject(options?.prepare) && options?.prepare?.targetName ? options?.prepare?.targetName : "prepare"
+                ].filter(Boolean),
+                defaultConfiguration: options?.build?.defaultConfiguration || "production",
+                options: {
+                  input: userConfig.input,
+                  outputPath: userConfig.output?.outputPath || "dist/{projectRoot}",
+                  projectType: projectConfig.projectType || userConfig.projectType,
+                  autoInstall: userConfig.autoInstall,
+                  skipCache: userConfig.skipCache
+                },
+                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: true,
+                inputs: Array.isArray(options?.lint?.inputs) ? options.lint.inputs : nxJson.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"}`,
+                  userConfig.skipCache ? void 0 : isSetObject.isSetObject(options?.prepare) && options?.prepare?.targetName ? options?.prepare?.targetName : "prepare"
+                ].filter(Boolean),
+                defaultConfiguration: options?.lint?.defaultConfiguration || "production",
+                options: {
+                  input: userConfig.input,
+                  projectType: projectConfig.projectType || userConfig.projectType,
+                  autoInstall: userConfig.autoInstall,
+                  skipCache: userConfig.skipCache
+                },
+                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: true,
+                inputs: Array.isArray(options?.docs?.inputs) ? options.docs.inputs : nxJson.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"}`,
+                  userConfig.skipCache ? void 0 : isSetObject.isSetObject(options?.prepare) && options?.prepare?.targetName ? options?.prepare?.targetName : "prepare"
+                ].filter(Boolean),
+                defaultConfiguration: options?.docs?.defaultConfiguration || "production",
+                options: {
+                  input: userConfig.input,
+                  projectType: projectConfig.projectType || userConfig.projectType,
+                  autoInstall: userConfig.autoInstall,
+                  skipCache: userConfig.skipCache
+                },
+                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"] = {
+                inputs: Array.isArray(options?.deploy?.inputs) ? options.deploy.inputs : nxJson.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"}`,
+                  userConfig.skipCache ? void 0 : isSetObject.isSetObject(options?.prepare) && options?.prepare?.targetName ? options?.prepare?.targetName : "prepare"
+                ].filter(Boolean),
+                defaultConfiguration: options?.deploy?.defaultConfiguration || "production",
+                options: {
+                  input: userConfig.input,
+                  projectType: projectConfig.projectType || userConfig.projectType,
+                  autoInstall: userConfig.autoInstall,
+                  skipCache: userConfig.skipCache
+                },
+                configurations: {
+                  production: {
+                    mode: "production"
+                  },
+                  test: {
+                    mode: "test"
+                  },
+                  development: {
+                    mode: "development",
+                    skipCache: true
+                  }
+                }
+              };
+            }
+            projectTags.setDefaultProjectTags(projectConfig, name);
+            projectTags.addProjectTag(projectConfig, framework, projectConfig.projectType || userConfig.projectType || "library", {
+              overwrite: true
+            });
+            if (opts?.verboseOutput) {
+              console.debug(`[${name}] - ${(/* @__PURE__ */ new Date()).toISOString()} - Completed preparing Nx configuration for project in root directory ${projectRoot}.`);
+            }
+            return {
+              projects: {
+                [root]: defu__default.default(projectConfig, {
+                  name: kebabCase.kebabCase(userConfig.name),
+                  projectType: userConfig.projectType || "library",
+                  root,
+                  sourceRoot: joinPaths.joinPaths(root, "src"),
+                  targets
+                })
+              }
+            };
+          } catch (error) {
+            console.error(`[${name}] - ${(/* @__PURE__ */ new Date()).toISOString()} - ${isError.isError(error) ? error.message : "Unknown fatal error"}`);
+            return {};
+          }
+        }, configFiles, options, contextV2);
+      }
+    ];
+  } catch (error) {
+    console.error(`[${opts?.name || "powerlines/plugin/nx"}] - ${(/* @__PURE__ */ new Date()).toISOString()} - ${isError.isError(error) ? error.message : "Unknown fatal error during plugin initialization"}`);
+    return [
+      `**/{${getNxTargetInputs(opts?.framework || "powerlines").map((input) => input.replace("{projectRoot}/", "")).join(",")}}`,
+      async () => {
+        return [];
+      }
+    ];
+  }
+}
+chunkSHUYVCID_js.__name(createNxPlugin, "createNxPlugin");
+
+exports.createNxPlugin = createNxPlugin;
+exports.getNxPluginInputs = getNxPluginInputs;
+exports.getNxTargetInputs = getNxTargetInputs;