@powerlines/nx 0.1.0

package/dist/chunk-2IKNOV7W.mjs

@@ -0,0 +1,305 @@
+import { PROJECT_ROOT_HASH_LENGTH, loadUserConfigFile } from './chunk-CYWOTYVX.mjs';
+import { createNodesFromFiles } from '@nx/devkit';
+import { withNamedInputs } from '@storm-software/workspace-tools/utils/nx-json';
+import { getProjectRoot, getRoot, getProjectConfigFromProjectRoot } from '@storm-software/workspace-tools/utils/plugin-helpers';
+import { setDefaultProjectTags, addProjectTag } from '@storm-software/workspace-tools/utils/project-tags';
+import { getEnvPaths } from '@stryke/env/get-env-paths';
+import { existsSync } from '@stryke/fs/exists';
+import { readJsonFileSync } from '@stryke/fs/json';
+import { murmurhash } from '@stryke/hash/murmurhash';
+import { joinPaths } from '@stryke/path/join-paths';
+import { kebabCase } from '@stryke/string-format/kebab-case';
+import { isError } from '@stryke/type-checks/is-error';
+import defu from 'defu';
+import { createJiti } from 'jiti';
+import { join } from 'node:path';
+import { readNxJson } from 'nx/src/config/nx-json.js';
+import { readTargetsFromPackageJson } from 'nx/src/utils/package-json.js';
+
+// src/helpers/constants.ts
+var CONFIG_INPUTS = [
+  "{projectRoot}/.storm",
+  "{projectRoot}/storm.json",
+  "{projectRoot}/storm.*.json",
+  "{projectRoot}/storm.jsonc",
+  "{projectRoot}/storm.*.jsonc",
+  "{projectRoot}/storm.json5",
+  "{projectRoot}/storm.*.json5",
+  "{projectRoot}/storm.yaml",
+  "{projectRoot}/storm.*.yaml",
+  "{projectRoot}/storm.yml",
+  "{projectRoot}/storm.*.yml",
+  "{projectRoot}/storm.toml",
+  "{projectRoot}/storm.*.toml",
+  "{projectRoot}/storm.js",
+  "{projectRoot}/storm.*.js",
+  "{projectRoot}/storm.cjs",
+  "{projectRoot}/storm.*.cjs",
+  "{projectRoot}/storm.mjs",
+  "{projectRoot}/storm.*.mjs",
+  "{projectRoot}/storm.ts",
+  "{projectRoot}/storm.*.ts",
+  "{projectRoot}/storm.cts",
+  "{projectRoot}/storm.*.cts",
+  "{projectRoot}/storm.mts",
+  "{projectRoot}/storm.*.mts"
+];
+
+// src/plugin/index.ts
+var name = "powerlines/nx/plugin";
+var stormConfigGlob = "**/{package.json,storm.json,storm.*.json,storm.jsonc,storm.*.jsonc,storm.json5,storm.*.json5,storm.yaml,storm.*.yaml,storm.yml,storm.*.yml,storm.toml,storm.*.toml,storm.js,storm.*.js,storm.ts,storm.*.ts,storm.mjs,storm.*.mjs,storm.cjs,storm.*.cjs,storm.mts,storm.*.mts,storm.cts,storm.*.cts}";
+var createNodesV2 = [
+  stormConfigGlob,
+  async (configFiles, optionsV2, contextV2) => {
+    const envPaths = getEnvPaths({
+      orgId: "storm-software",
+      appId: "powerlines",
+      workspaceRoot: contextV2.workspaceRoot
+    });
+    if (!envPaths.cache) {
+      throw new Error("The cache directory could not be determined.");
+    }
+    const nxJson = readNxJson(contextV2.workspaceRoot);
+    return createNodesFromFiles(async (configFile, options, context) => {
+      try {
+        const projectRoot = getProjectRoot(configFile, contextV2.workspaceRoot);
+        if (!projectRoot) {
+          console.error(`[${name}]: package.json and Powerlines configuration files (i.e. powerlines.config.ts) must be located in the project root directory: ${configFile}`);
+          return {};
+        }
+        const root = getRoot(projectRoot, context);
+        const cacheDir = joinPaths(envPaths.cache, "projects", murmurhash(joinPaths(contextV2.workspaceRoot, projectRoot), {
+          maxLength: PROJECT_ROOT_HASH_LENGTH
+        }));
+        const jiti = createJiti(joinPaths(contextV2.workspaceRoot, projectRoot), {
+          interopDefault: true,
+          fsCache: joinPaths(cacheDir, "jiti"),
+          moduleCache: true
+        });
+        const userConfig = await loadUserConfigFile(projectRoot, jiti);
+        const packageJson = readJsonFileSync(joinPaths(projectRoot, "package.json"));
+        if (!userConfig.configFile && !packageJson.storm) {
+          console.debug(`[${name}]: Skipping ${projectRoot} - no Powerlines configuration found for project in root directory.`);
+          return {};
+        }
+        const projectConfig = getProjectConfigFromProjectRoot(projectRoot, packageJson);
+        if (!projectConfig) {
+          console.warn(`[${name}]: No project configuration found for project in root directory ${projectRoot}`);
+          return {};
+        }
+        const tsconfig = userConfig?.tsconfig || (existsSync(joinPaths(projectRoot, "tsconfig.json")) ? joinPaths(projectRoot, "tsconfig.json") : void 0);
+        const targets = readTargetsFromPackageJson(packageJson, nxJson, projectRoot, context.workspaceRoot);
+        targets.clean = {
+          dependsOn: [
+            "^clean"
+          ],
+          executor: "@powerlines/nx: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
+            }
+          }
+        };
+        targets.prepare = {
+          cache: true,
+          inputs: withNamedInputs(CONFIG_INPUTS, [
+            "typescript"
+          ]),
+          outputs: [
+            "{projectRoot}/.storm"
+          ],
+          dependsOn: [
+            "clean",
+            "^prepare"
+          ],
+          executor: "@powerlines/nx: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
+            }
+          }
+        };
+        targets["type-check"] ??= {
+          cache: true,
+          inputs: [
+            "typescript",
+            "^production"
+          ],
+          outputs: [
+            "{workspaceRoot}/dist/{projectRoot}"
+          ],
+          executor: "nx:run-commands",
+          dependsOn: [
+            "^type-check",
+            "^build"
+          ],
+          options: {
+            command: `pnpm exec tsc --noEmit --pretty --project ${userConfig.tsconfig || join(projectConfig.root, "tsconfig.json")}`
+          }
+        };
+        targets.build = {
+          cache: true,
+          inputs: withNamedInputs(CONFIG_INPUTS, [
+            "typescript"
+          ]),
+          outputs: [
+            "{options.outputPath}"
+          ],
+          dependsOn: [
+            "prepare",
+            "^build"
+          ],
+          executor: "@powerlines/nx: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
+            }
+          }
+        };
+        targets.lint = {
+          cache: true,
+          inputs: withNamedInputs([
+            ...CONFIG_INPUTS,
+            "{projectRoot}/.storm"
+          ], [
+            "linting",
+            "typescript"
+          ]),
+          outputs: withNamedInputs([
+            "{projectRoot}/.storm"
+          ], [
+            "typescript"
+          ]),
+          dependsOn: [
+            "prepare",
+            "^lint"
+          ],
+          executor: "@powerlines/nx: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
+            }
+          }
+        };
+        targets.docs = {
+          cache: true,
+          inputs: withNamedInputs([
+            ...CONFIG_INPUTS,
+            "{projectRoot}/.storm"
+          ], [
+            "documentation",
+            "typescript"
+          ]),
+          outputs: [
+            "{projectRoot}/docs/generated"
+          ],
+          dependsOn: [
+            "prepare",
+            "build",
+            "^docs"
+          ],
+          executor: "@powerlines/nx: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
+            }
+          }
+        };
+        setDefaultProjectTags(projectConfig, name);
+        addProjectTag(projectConfig, "powerlines", projectConfig.projectType || userConfig.type || "library", {
+          overwrite: true
+        });
+        return {
+          projects: {
+            [root]: defu(projectConfig, {
+              name: kebabCase(userConfig.name),
+              projectType: userConfig.type || "library",
+              root,
+              sourceRoot: joinPaths(root, "src"),
+              targets
+            })
+          }
+        };
+      } catch (error) {
+        console.error(`[${name}]: ${isError(error) ? error.message : "Unknown fatal error"}`);
+        return {};
+      }
+    }, configFiles, optionsV2, contextV2);
+  }
+];
+
+export { createNodesV2, name };

package/dist/chunk-326QB2VK.mjs

@@ -0,0 +1,14 @@
+import { __name } from './chunk-O6YSETKJ.mjs';
+import { readNxJson } from '@nx/devkit';
+
+async function generatorFn(tree) {
+  const nxJson = readNxJson(tree);
+  const userOptions = nxJson?.sync?.generatorOptions?.["@powerlines/nx:sync"];
+  return {
+    outOfSyncMessage: userOptions?.outOfSyncMessage || "The legal-message.txt file needs to be created"
+  };
+}
+__name(generatorFn, "generatorFn");
+var generator_default = generatorFn;
+
+export { generatorFn, generator_default };

package/dist/chunk-3QPPK4K2.js

@@ -0,0 +1,18 @@
+'use strict';
+
+var chunk6UG6SXHV_js = require('./chunk-6UG6SXHV.js');
+var chunkSHUYVCID_js = require('./chunk-SHUYVCID.js');
+
+// src/executors/lint/executor.ts
+async function executorFn(context, api) {
+  await api.lint(context.inlineConfig);
+  return {
+    success: true
+  };
+}
+chunkSHUYVCID_js.__name(executorFn, "executorFn");
+var executor = chunk6UG6SXHV_js.withExecutor("lint", executorFn);
+var executor_default = executor;
+
+exports.executorFn = executorFn;
+exports.executor_default = executor_default;

package/dist/chunk-5K7DMFAV.mjs

@@ -0,0 +1,15 @@
+import { withExecutor } from './chunk-OZMYXUES.mjs';
+import { __name } from './chunk-O6YSETKJ.mjs';
+
+// src/executors/clean/executor.ts
+async function executorFn(context, api) {
+  await api.clean(context.inlineConfig);
+  return {
+    success: true
+  };
+}
+__name(executorFn, "executorFn");
+var executor = withExecutor("clean", executorFn);
+var executor_default = executor;
+
+export { executorFn, executor_default };