@storm-software/k8s-tools 0.18.0 → 0.19.0

package/dist/chunk-7BCSLKT3.js

@@ -0,0 +1,98 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunk2QNNUD5Mjs = require('./chunk-2QNNUD5M.js');
+
+
+var _chunkGDXB64KGjs = require('./chunk-GDXB64KG.js');
+
+
+var _chunk3GQAWCBQjs = require('./chunk-3GQAWCBQ.js');
+
+// src/generators/helm-dependency/generator.ts
+var _devkit = require('@nx/devkit');
+var _jsyaml = require('js-yaml'); var _jsyaml2 = _interopRequireDefault(_jsyaml);
+async function helmDependencyGeneratorFn(tree, options, config) {
+  _chunkGDXB64KGjs.writeDebug.call(void 0, "\u{1F4DD}  Preparing to add Helm Dependency", config);
+  const project = _devkit.readProjectConfiguration.call(void 0, tree, options.project);
+  if (!_optionalChain([project, 'access', _ => _.targets, 'optionalAccess', _2 => _2["helm-package"]])) {
+    throw new Error(`Project ${options.project} does not have a helm target. Please run the chart generator first.`);
+  }
+  _devkit.updateProjectConfiguration.call(void 0, tree, options.project, addDependencyToConfig(project, options.repositoryName, options.repository));
+  updateChartYaml(tree, project, options.chartName, options.chartVersion, options.repository);
+  if (options.format) {
+    await _devkit.formatFiles.call(void 0, tree);
+  }
+  return {
+    success: true
+  };
+}
+_chunk3GQAWCBQjs.__name.call(void 0, helmDependencyGeneratorFn, "helmDependencyGeneratorFn");
+var generator_default = _chunk2QNNUD5Mjs.withRunGenerator.call(void 0, "Helm Dependency", helmDependencyGeneratorFn);
+function addDependencyToConfig(project, name, url) {
+  return {
+    ...project,
+    targets: {
+      ...project.targets,
+      helm: {
+        ..._optionalChain([project, 'access', _3 => _3.targets, 'optionalAccess', _4 => _4["helm-package"]]),
+        options: {
+          ..._optionalChain([project, 'access', _5 => _5.targets, 'optionalAccess', _6 => _6["helm-package"], 'optionalAccess', _7 => _7.options]),
+          dependencies: {
+            ..._optionalChain([project, 'access', _8 => _8.targets, 'optionalAccess', _9 => _9["helm-package"], 'optionalAccess', _10 => _10.options, 'access', _11 => _11.dependencies]),
+            repositories: _optionalChain([project, 'access', _12 => _12.targets, 'optionalAccess', _13 => _13["helm-package"], 'optionalAccess', _14 => _14.options, 'access', _15 => _15.dependencies, 'access', _16 => _16.repositories]) ? [
+              ...project.targets["helm-package"].options.dependencies.repositories,
+              {
+                name,
+                url
+              }
+            ] : [
+              {
+                name,
+                url
+              }
+            ]
+          }
+        }
+      }
+    }
+  };
+}
+_chunk3GQAWCBQjs.__name.call(void 0, addDependencyToConfig, "addDependencyToConfig");
+function updateChartYaml(tree, project, name, version, repository) {
+  const chartFolder = _optionalChain([project, 'access', _17 => _17.targets, 'optionalAccess', _18 => _18["helm-package"], 'optionalAccess', _19 => _19.options, 'access', _20 => _20.chartFolder]);
+  const chartPath = `${chartFolder}/Chart.yaml`;
+  if (!tree.exists(chartPath)) {
+    throw new Error("Chart.yaml not found");
+  }
+  try {
+    const result = _optionalChain([tree, 'access', _21 => _21.read, 'call', _22 => _22(chartPath, "utf8"), 'optionalAccess', _23 => _23.toString, 'call', _24 => _24()]);
+    if (!result) {
+      throw new Error("Failed to read Chart.yaml");
+    }
+    const chartContents = _jsyaml2.default.load(result);
+    if (!chartContents.dependencies) {
+      chartContents.dependencies = [];
+    }
+    const existingDependency = chartContents.dependencies.find((dep) => dep.name === name);
+    if (existingDependency) {
+      existingDependency.version = version;
+      existingDependency.repository = repository;
+    } else {
+      chartContents.dependencies.push({
+        name,
+        version,
+        repository
+      });
+      tree.write(chartPath, _jsyaml2.default.dump(chartContents));
+    }
+  } catch (error) {
+    console.error(error);
+    throw new Error("Failed to parse Chart.yaml");
+  }
+}
+_chunk3GQAWCBQjs.__name.call(void 0, updateChartYaml, "updateChartYaml");
+
+
+
+
+exports.helmDependencyGeneratorFn = helmDependencyGeneratorFn; exports.generator_default = generator_default;

package/dist/chunk-7IJP4RLN.mjs

@@ -0,0 +1,63 @@
+import {
+  __name,
+  __require
+} from "./chunk-XUV4U54K.mjs";
+
+// src/utils/prettier.ts
+async function resolveUserExistingPrettierConfig() {
+  let prettier;
+  try {
+    prettier = __require("prettier");
+  } catch {
+    return void 0;
+  }
+  if (!prettier) {
+    return void 0;
+  }
+  try {
+    const filepath = await prettier.resolveConfigFile();
+    if (!filepath) {
+      return void 0;
+    }
+    const config = await prettier.resolveConfig(process.cwd(), {
+      useCache: false,
+      config: filepath
+    });
+    if (!config) {
+      return void 0;
+    }
+    return {
+      sourceFilepath: filepath,
+      config
+    };
+  } catch {
+    return void 0;
+  }
+}
+__name(resolveUserExistingPrettierConfig, "resolveUserExistingPrettierConfig");
+function addToPrettierIgnore(tree, ignore) {
+  const ignorePath = `${tree.root}/.prettierignore`;
+  if (!tree.exists(ignorePath)) {
+    tree.write(ignorePath, ignore.join("\n"));
+    return;
+  }
+  try {
+    const content = tree.read(ignorePath, "utf8") || "";
+    const lines = content.split("\n");
+    const newContent = [
+      .../* @__PURE__ */ new Set([
+        ...lines,
+        ...ignore
+      ])
+    ].join("\n");
+    tree.write(ignorePath, newContent);
+  } catch (error) {
+    throw new Error(`Failed to update .prettierignore file: ${String(error)}`);
+  }
+}
+__name(addToPrettierIgnore, "addToPrettierIgnore");
+
+export {
+  resolveUserExistingPrettierConfig,
+  addToPrettierIgnore
+};

package/dist/chunk-AFPEYAYK.js

@@ -0,0 +1,61 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkGDXB64KGjs = require('./chunk-GDXB64KG.js');
+
+
+var _chunk3GQAWCBQjs = require('./chunk-3GQAWCBQ.js');
+
+// ../config-tools/src/utilities/apply-workspace-tokens.ts
+var applyWorkspaceBaseTokens = /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, async (option, tokenizerOptions) => {
+  let result = option;
+  if (!result) {
+    return result;
+  }
+  if (tokenizerOptions) {
+    const optionKeys = Object.keys(tokenizerOptions);
+    if (optionKeys.some((optionKey) => result.includes(`{${optionKey}}`))) {
+      for (const optionKey of optionKeys) {
+        if (result.includes(`{${optionKey}}`)) {
+          result = result.replaceAll(`{${optionKey}}`, _nullishCoalesce(_optionalChain([tokenizerOptions, 'access', _ => _.config, 'optionalAccess', _2 => _2[optionKey]]), () => ( "")));
+        }
+      }
+    }
+  }
+  if (tokenizerOptions.config) {
+    const configKeys = Object.keys(tokenizerOptions.config);
+    if (configKeys.some((configKey) => result.includes(`{${configKey}}`))) {
+      for (const configKey of configKeys) {
+        if (result.includes(`{${configKey}}`)) {
+          result = result.replaceAll(`{${configKey}}`, tokenizerOptions.config[configKey]);
+        }
+      }
+    }
+  }
+  if (result.includes("{workspaceRoot}")) {
+    result = result.replaceAll("{workspaceRoot}", _nullishCoalesce(_nullishCoalesce(tokenizerOptions.workspaceRoot, () => ( _optionalChain([tokenizerOptions, 'access', _3 => _3.config, 'optionalAccess', _4 => _4.workspaceRoot]))), () => ( _chunkGDXB64KGjs.findWorkspaceRoot.call(void 0, ))));
+  }
+  return result;
+}, "applyWorkspaceBaseTokens");
+var applyWorkspaceTokens = /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, async (options, config, tokenizerFn) => {
+  if (!options) {
+    return {};
+  }
+  const result = {};
+  for (const option of Object.keys(options)) {
+    if (typeof options[option] === "string") {
+      result[option] = await Promise.resolve(tokenizerFn(options[option], config));
+    } else if (Array.isArray(options[option])) {
+      result[option] = await Promise.all(options[option].map(async (item) => typeof item === "string" ? await Promise.resolve(tokenizerFn(item, config)) : item));
+    } else if (typeof options[option] === "object") {
+      result[option] = await applyWorkspaceTokens(options[option], config, tokenizerFn);
+    } else {
+      result[option] = options[option];
+    }
+  }
+  return result;
+}, "applyWorkspaceTokens");
+
+
+
+
+exports.applyWorkspaceBaseTokens = applyWorkspaceBaseTokens; exports.applyWorkspaceTokens = applyWorkspaceTokens;

package/dist/chunk-DHBG5ASJ.js

@@ -0,0 +1 @@
+"use strict";