@powerlines/nx 0.1.0

package/dist/chunk-OOERKIVS.js

@@ -0,0 +1,312 @@
+'use strict';
+
+var chunkHHPODCTP_js = require('./chunk-HHPODCTP.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 json = require('@stryke/fs/json');
+var murmurhash = require('@stryke/hash/murmurhash');
+var joinPaths = require('@stryke/path/join-paths');
+var kebabCase = require('@stryke/string-format/kebab-case');
+var isError = require('@stryke/type-checks/is-error');
+var defu = require('defu');
+var jiti = require('jiti');
+var path = require('path');
+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);
+
+// 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.getEnvPaths({
+      orgId: "storm-software",
+      appId: "powerlines",
+      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, options, context) => {
+      try {
+        const projectRoot = pluginHelpers.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 = pluginHelpers.getRoot(projectRoot, context);
+        const cacheDir = joinPaths.joinPaths(envPaths.cache, "projects", murmurhash.murmurhash(joinPaths.joinPaths(contextV2.workspaceRoot, projectRoot), {
+          maxLength: chunkHHPODCTP_js.PROJECT_ROOT_HASH_LENGTH
+        }));
+        const jiti$1 = jiti.createJiti(joinPaths.joinPaths(contextV2.workspaceRoot, projectRoot), {
+          interopDefault: true,
+          fsCache: joinPaths.joinPaths(cacheDir, "jiti"),
+          moduleCache: true
+        });
+        const userConfig = await chunkHHPODCTP_js.loadUserConfigFile(projectRoot, jiti$1);
+        const packageJson = json.readJsonFileSync(joinPaths.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 = pluginHelpers.getProjectConfigFromProjectRoot(projectRoot, packageJson);
+        if (!projectConfig) {
+          console.warn(`[${name}]: 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);
+        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: nxJson.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 || path.join(projectConfig.root, "tsconfig.json")}`
+          }
+        };
+        targets.build = {
+          cache: true,
+          inputs: nxJson.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: nxJson.withNamedInputs([
+            ...CONFIG_INPUTS,
+            "{projectRoot}/.storm"
+          ], [
+            "linting",
+            "typescript"
+          ]),
+          outputs: nxJson.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: nxJson.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
+            }
+          }
+        };
+        projectTags.setDefaultProjectTags(projectConfig, name);
+        projectTags.addProjectTag(projectConfig, "powerlines", projectConfig.projectType || userConfig.type || "library", {
+          overwrite: true
+        });
+        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}]: ${isError.isError(error) ? error.message : "Unknown fatal error"}`);
+        return {};
+      }
+    }, configFiles, optionsV2, contextV2);
+  }
+];
+
+exports.createNodesV2 = createNodesV2;
+exports.name = name;