@powerlines/nx 0.10.24 → 0.10.27

package/dist/src/types/plugin.d.ts

@@ -1,4 +1,13 @@
 interface NxPluginOptions {
+    /**
+     * Enable debug logging for the plugin
+     *
+     * @defaultValue false
+     */
+    debug?: boolean;
+    /**
+     * Configuration options for the clean target added by the Nx plugin
+     */
     clean?: false | {
         /**
          * The name of the clean target to use when cleaning the project
@@ -33,6 +42,9 @@ interface NxPluginOptions {
          */
         executor?: string;
     };
+    /**
+     * Configuration options for the prepare target added by the Nx plugin
+     */
     prepare?: false | {
         /**
          * The name of the prepare target to use when preparing the project
@@ -67,6 +79,9 @@ interface NxPluginOptions {
          */
         executor?: string;
     };
+    /**
+     * Configuration options for the lint target added by the Nx plugin
+     */
     lint?: false | {
         /**
          * The name of the lint target to use when linting the project
@@ -101,6 +116,9 @@ interface NxPluginOptions {
          */
         executor?: string;
     };
+    /**
+     * Configuration options for the build target added by the Nx plugin
+     */
     build?: false | {
         /**
          * The name of the build target to use when building the project
@@ -135,6 +153,9 @@ interface NxPluginOptions {
          */
         executor?: string;
     };
+    /**
+     * Configuration options for the docs target added by the Nx plugin
+     */
     docs?: false | {
         /**
          * The name of the docs target to use when generating documentation for the project
@@ -169,6 +190,9 @@ interface NxPluginOptions {
          */
         executor?: string;
     };
+    /**
+     * Configuration options for the deploy target added by the Nx plugin
+     */
     deploy?: false | {
         /**
          * The name of the deploy target to use when deploying the project

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@powerlines/nx",
-  "version": "0.10.24",
+  "version": "0.10.27",
   "description": "A Nx plugin to support Powerlines development in Nx monorepos.",
   "repository": {
     "type": "github",
@@ -182,12 +182,12 @@
   "typings": "dist/index.d.ts",
   "dependencies": {
     "@nx/devkit": "^22.1.0",
-    "@storm-software/build-tools": "^0.158.47",
-    "@storm-software/config": "^1.134.47",
-    "@storm-software/config-tools": "^1.188.47",
-    "@storm-software/esbuild": "^0.53.47",
-    "@storm-software/unbuild": "^0.57.47",
-    "@storm-software/workspace-tools": "^1.293.17",
+    "@storm-software/build-tools": "^0.158.48",
+    "@storm-software/config": "^1.134.48",
+    "@storm-software/config-tools": "^1.188.48",
+    "@storm-software/esbuild": "^0.53.48",
+    "@storm-software/unbuild": "^0.57.48",
+    "@storm-software/workspace-tools": "^1.293.18",
     "@stryke/fs": "^0.32.13",
     "@stryke/hash": "^0.12.3",
     "@stryke/path": "^0.19.2",
@@ -196,11 +196,11 @@
     "defu": "^6.1.4",
     "jiti": "^2.6.1",
     "nx": "^22.1.0",
-    "powerlines": "^0.23.7"
+    "powerlines": "^0.23.10"
   },
   "devDependencies": {
     "@nx/workspace": "^22.1.0",
-    "@storm-software/testing-tools": "^1.119.47",
+    "@storm-software/testing-tools": "^1.119.48",
     "@types/node": "^24.10.1",
     "eslint-flat-config-utils": "^2.1.4",
     "jsonc-eslint-parser": "^2.4.1",
@@ -210,5 +210,5 @@
   "publishConfig": { "access": "public" },
   "executors": "./executors.json",
   "generators": "./generators.json",
-  "gitHead": "76575e78b1db97f4786341913ad2ec42ec1de504"
+  "gitHead": "5a6b8349dc29bf9e496ed5dee32c6cfb8d9bff4e"
 }

package/dist/chunk-62CNXBCW.js

@@ -1,10 +0,0 @@
-'use strict';
-
-var chunk7N6FX55G_js = require('./chunk-7N6FX55G.js');
-
-// src/plugin/index.ts
-var createNodesV2 = chunk7N6FX55G_js.createNxPlugin({
-  framework: "powerlines"
-});
-
-exports.createNodesV2 = createNodesV2;

package/dist/chunk-7N6FX55G.js

@@ -1,347 +0,0 @@
-'use strict';
-
-var chunkLTCZN4I4_js = require('./chunk-LTCZN4I4.js');
-var chunkVIU4CXA3_js = require('./chunk-VIU4CXA3.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 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 chunkVIU4CXA3_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) {
-  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);
-  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);
-      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);
-          const cacheDir = joinPaths.joinPaths(envPaths.cache, "nx-plugin", murmurhash.murmurhash(contextV2.workspaceRoot, {
-            maxLength: chunkLTCZN4I4_js.PROJECT_ROOT_HASH_LENGTH
-          }));
-          const jiti$1 = jiti.createJiti(joinPaths.joinPaths(contextV2.workspaceRoot, projectRoot), {
-            interopDefault: true,
-            fsCache: joinPaths.joinPaths(cacheDir, "jiti"),
-            moduleCache: true
-          });
-          console.debug(`[${name}] - ${(/* @__PURE__ */ new Date()).toISOString()} - Loading ${framework} user configuration for project in root directory ${projectRoot}.`);
-          const userConfig = await chunkLTCZN4I4_js.loadUserConfigFile(joinPaths.joinPaths(contextV2.workspaceRoot, projectRoot), jiti$1, "build", "development", joinPaths.joinPaths(contextV2.workspaceRoot, configFile), framework);
-          if (!exists.existsSync(joinPaths.joinPaths(contextV2.workspaceRoot, projectRoot, "package.json"))) {
-            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) {
-            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) {
-            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) {
-            console.warn(`[${name}] - ${(/* @__PURE__ */ new Date()).toISOString()} - No project configuration found for project in root directory ${projectRoot}`);
-            return {};
-          }
-          const tsconfig = userConfig?.tsconfig || (exists.existsSync(joinPaths.joinPaths(projectRoot, "tsconfig.json")) ? joinPaths.joinPaths(projectRoot, "tsconfig.json") : void 0);
-          const targets = packageJson_js.readTargetsFromPackageJson(packageJson, nxJson$1, projectRoot, context.workspaceRoot);
-          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"] = {
-              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?.targetName || "clean"}`
-              ],
-              defaultConfiguration: options?.clean?.defaultConfiguration || "production",
-              options: {
-                outputPath: userConfig.output?.outputPath || "dist/{projectRoot}",
-                projectType: projectConfig.projectType || userConfig.type,
-                skipInstalls: userConfig.skipInstalls
-              },
-              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?.targetName || "prepare"}`,
-                "clean"
-              ],
-              defaultConfiguration: options?.prepare?.defaultConfiguration || "production",
-              options: {
-                entry: userConfig.entry || "{sourceRoot}/index.ts",
-                projectType: projectConfig.projectType || userConfig.type,
-                tsconfig,
-                skipInstalls: userConfig.skipInstalls,
-                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"] = {
-              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?.targetName || "build"}`,
-                options?.prepare !== false && `^${options?.prepare?.targetName || "prepare"}`
-              ].filter(Boolean),
-              defaultConfiguration: options?.build?.defaultConfiguration || "production",
-              options: {
-                entry: userConfig.entry || "{sourceRoot}/index.ts",
-                outputPath: userConfig.output?.outputPath || "dist/{projectRoot}",
-                projectType: projectConfig.projectType || userConfig.type,
-                tsconfig,
-                skipInstalls: userConfig.skipInstalls,
-                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"] = {
-              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?.targetName || "lint"}`,
-                options?.prepare !== false && `^${options?.prepare?.targetName || "prepare"}`
-              ].filter(Boolean),
-              defaultConfiguration: options?.lint?.defaultConfiguration || "production",
-              options: {
-                entry: userConfig.entry || "{sourceRoot}/index.ts",
-                projectType: projectConfig.projectType || userConfig.type,
-                tsconfig,
-                skipInstalls: userConfig.skipInstalls,
-                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"] = {
-              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?.targetName || "docs"}`,
-                options?.build !== false && `^${options?.build?.targetName || "build"}`
-              ].filter(Boolean),
-              defaultConfiguration: options?.docs?.defaultConfiguration || "production",
-              options: {
-                entry: userConfig.entry || "{sourceRoot}/index.ts",
-                projectType: projectConfig.projectType || userConfig.type,
-                tsconfig,
-                skipInstalls: userConfig.skipInstalls,
-                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?.targetName || "deploy"}`,
-                options?.build !== false && `^${options?.build?.targetName || "build"}`
-              ].filter(Boolean),
-              defaultConfiguration: options?.deploy?.defaultConfiguration || "production",
-              options: {
-                entry: userConfig.entry || "{sourceRoot}/index.ts",
-                projectType: projectConfig.projectType || userConfig.type,
-                tsconfig,
-                skipInstalls: userConfig.skipInstalls,
-                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.type || "library", {
-            overwrite: true
-          });
-          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.type || "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);
-    }
-  ];
-}
-chunkSHUYVCID_js.__name(createNxPlugin, "createNxPlugin");
-
-exports.createNxPlugin = createNxPlugin;
-exports.getNxPluginInputs = getNxPluginInputs;
-exports.getNxTargetInputs = getNxTargetInputs;

package/dist/chunk-SAVSMAFN.mjs

@@ -1,8 +0,0 @@
-import { createNxPlugin } from './chunk-4QIKRF4D.mjs';
-
-// src/plugin/index.ts
-var createNodesV2 = createNxPlugin({
-  framework: "powerlines"
-});
-
-export { createNodesV2 };