@storm-software/workspace-tools 1.228.0 → 1.229.0

package/dist/chunk-7YRW5HNX.js

@@ -0,0 +1,102 @@
+"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 _chunk3GQAWCBQjs = require('./chunk-3GQAWCBQ.js');
+
+// src/utils/project-tags.ts
+var ProjectTagConstants = {
+  Language: {
+    TAG_ID: "language",
+    TYPESCRIPT: "typescript",
+    RUST: "rust"
+  },
+  ProjectType: {
+    TAG_ID: "type",
+    LIBRARY: "library",
+    APPLICATION: "application"
+  },
+  DistStyle: {
+    TAG_ID: "dist-style",
+    NORMAL: "normal",
+    CLEAN: "clean"
+  },
+  Provider: {
+    TAG_ID: "provider"
+  },
+  Platform: {
+    TAG_ID: "platform",
+    NODE: "node",
+    BROWSER: "browser",
+    NEUTRAL: "neutral",
+    WORKER: "worker"
+  },
+  Registry: {
+    TAG_ID: "registry",
+    CARGO: "cargo",
+    NPM: "npm",
+    CONTAINER: "container",
+    CYCLONE: "cyclone"
+  },
+  Plugin: {
+    TAG_ID: "plugin"
+  }
+};
+var formatProjectTag = /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, (variant, value) => {
+  return `${variant}:${value}`;
+}, "formatProjectTag");
+var hasProjectTag = /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, (project, variant) => {
+  project.tags = _nullishCoalesce(project.tags, () => ( []));
+  const prefix = formatProjectTag(variant, "");
+  return project.tags.some((tag) => tag.startsWith(prefix) && tag.length > prefix.length);
+}, "hasProjectTag");
+var getProjectTag = /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, (project, variant) => {
+  if (!hasProjectTag(project, variant)) {
+    return void 0;
+  }
+  project.tags = _nullishCoalesce(project.tags, () => ( []));
+  const prefix = formatProjectTag(variant, "");
+  const tag = project.tags.find((tag2) => tag2.startsWith(prefix));
+  return _optionalChain([tag, 'optionalAccess', _ => _.replace, 'call', _2 => _2(prefix, "")]);
+}, "getProjectTag");
+var isEqualProjectTag = /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, (project, variant, value) => {
+  const tag = getProjectTag(project, variant);
+  return !!(tag && _optionalChain([tag, 'optionalAccess', _3 => _3.toUpperCase, 'call', _4 => _4()]) === value.toUpperCase());
+}, "isEqualProjectTag");
+var addProjectTag = /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, (project, variant, value, options = {
+  overwrite: false
+}) => {
+  project.tags = _nullishCoalesce(project.tags, () => ( []));
+  if (options.overwrite || !hasProjectTag(project, variant)) {
+    project.tags = project.tags.filter((tag) => !tag.startsWith(formatProjectTag(variant, "")));
+    project.tags.push(formatProjectTag(variant, value));
+  }
+}, "addProjectTag");
+var addPluginProjectTag = /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, (project, plugin) => {
+  project.tags = _nullishCoalesce(project.tags, () => ( []));
+  project.tags.push(formatProjectTag(ProjectTagConstants.Plugin.TAG_ID, plugin));
+}, "addPluginProjectTag");
+var setDefaultProjectTags = /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, (project, plugin) => {
+  project.tags = _nullishCoalesce(project.tags, () => ( []));
+  addProjectTag(project, ProjectTagConstants.ProjectType.TAG_ID, project.projectType === "application" ? ProjectTagConstants.ProjectType.APPLICATION : ProjectTagConstants.ProjectType.LIBRARY, {
+    overwrite: true
+  });
+  addProjectTag(project, ProjectTagConstants.DistStyle.TAG_ID, project.targets && Object.keys(project.targets).includes("clean-package") ? ProjectTagConstants.DistStyle.CLEAN : ProjectTagConstants.DistStyle.NORMAL, {
+    overwrite: true
+  });
+  addProjectTag(project, ProjectTagConstants.Platform.TAG_ID, _optionalChain([project, 'access', _5 => _5.targets, 'optionalAccess', _6 => _6.build, 'optionalAccess', _7 => _7.options, 'access', _8 => _8.platform]) === "node" ? ProjectTagConstants.Platform.NODE : _optionalChain([project, 'access', _9 => _9.targets, 'optionalAccess', _10 => _10.build, 'optionalAccess', _11 => _11.options, 'access', _12 => _12.platform]) === "worker" ? ProjectTagConstants.Platform.WORKER : _optionalChain([project, 'access', _13 => _13.targets, 'optionalAccess', _14 => _14.build, 'optionalAccess', _15 => _15.options, 'access', _16 => _16.platform]) === "browser" ? ProjectTagConstants.Platform.BROWSER : ProjectTagConstants.Platform.NEUTRAL, {
+    overwrite: false
+  });
+  if (plugin) {
+    addPluginProjectTag(project, plugin);
+  }
+}, "setDefaultProjectTags");
+
+
+
+
+
+
+
+
+
+
+exports.ProjectTagConstants = ProjectTagConstants; exports.formatProjectTag = formatProjectTag; exports.hasProjectTag = hasProjectTag; exports.getProjectTag = getProjectTag; exports.isEqualProjectTag = isEqualProjectTag; exports.addProjectTag = addProjectTag; exports.addPluginProjectTag = addPluginProjectTag; exports.setDefaultProjectTags = setDefaultProjectTags;

package/dist/chunk-B3KIYNGT.mjs

@@ -0,0 +1,88 @@
+import {
+  applyWorkspaceBaseTokens,
+  applyWorkspaceTokens
+} from "./chunk-NDDXQD7R.mjs";
+import {
+  getStopwatch,
+  loadStormConfig,
+  writeDebug,
+  writeError,
+  writeFatal,
+  writeInfo,
+  writeSuccess,
+  writeTrace
+} from "./chunk-WJ5TU6JU.mjs";
+import {
+  findWorkspaceRoot
+} from "./chunk-DMUTOQCB.mjs";
+import {
+  __name
+} from "./chunk-XUV4U54K.mjs";
+
+// src/base/base-generator.ts
+var withRunGenerator = /* @__PURE__ */ __name((name, generatorFn, generatorOptions = {
+  skipReadingConfig: false
+}) => async (tree, _options) => {
+  const stopwatch = getStopwatch(name);
+  let options = _options;
+  let config;
+  try {
+    writeInfo(`\u26A1 Running the ${name} generator...
+
+`, config);
+    const workspaceRoot = findWorkspaceRoot();
+    if (!generatorOptions.skipReadingConfig) {
+      writeDebug(`Loading the Storm Config from environment variables and storm.config.js file...
+ - workspaceRoot: ${workspaceRoot}`, config);
+      config = await loadStormConfig(workspaceRoot);
+    }
+    if (generatorOptions?.hooks?.applyDefaultOptions) {
+      writeDebug("Running the applyDefaultOptions hook...", config);
+      options = await Promise.resolve(generatorOptions.hooks.applyDefaultOptions(options, config));
+      writeDebug("Completed the applyDefaultOptions hook", config);
+    }
+    writeTrace(`Generator schema options \u2699\uFE0F 
+${Object.keys(options ?? {}).map((key) => ` - ${key}=${JSON.stringify(options[key])}`).join("\n")}`, config);
+    const tokenized = await applyWorkspaceTokens(options, {
+      workspaceRoot: tree.root,
+      config
+    }, applyWorkspaceBaseTokens);
+    if (generatorOptions?.hooks?.preProcess) {
+      writeDebug("Running the preProcess hook...", config);
+      await Promise.resolve(generatorOptions.hooks.preProcess(tokenized, config));
+      writeDebug("Completed the preProcess hook", config);
+    }
+    const result = await Promise.resolve(generatorFn(tree, tokenized, config));
+    if (result) {
+      if (result.success === false || result.error && result?.error?.message && typeof result?.error?.message === "string" && result?.error?.name && typeof result?.error?.name === "string") {
+        throw new Error(`The ${name} generator failed to run`, {
+          cause: result?.error
+        });
+      } else if (result.success && result.data) {
+        return result;
+      }
+    }
+    if (generatorOptions?.hooks?.postProcess) {
+      writeDebug("Running the postProcess hook...", config);
+      await Promise.resolve(generatorOptions.hooks.postProcess(config));
+      writeDebug("Completed the postProcess hook", config);
+    }
+    return () => {
+      writeSuccess(`Completed running the ${name} generator!
+`, config);
+    };
+  } catch (error) {
+    return () => {
+      writeFatal("A fatal error occurred while running the generator - the process was forced to terminate", config);
+      writeError(`An exception was thrown in the generator's process 
+ - Details: ${error.message}
+ - Stacktrace: ${error.stack}`, config);
+    };
+  } finally {
+    stopwatch();
+  }
+}, "withRunGenerator");
+
+export {
+  withRunGenerator
+};

package/dist/chunk-B7LWGAUI.js

@@ -0,0 +1,50 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkMSENNRAYjs = require('./chunk-MSENNRAY.js');
+
+
+var _chunk36FMHXUDjs = require('./chunk-36FMHXUD.js');
+
+
+var _chunk3GQAWCBQjs = require('./chunk-3GQAWCBQ.js');
+
+// src/executors/typia/executor.ts
+var _fsextra = require('fs-extra');
+var _TypiaProgrammerjs = require('typia/lib/programmers/TypiaProgrammer.js');
+async function typiaExecutorFn(options, _, config) {
+  if (options.clean !== false) {
+    _chunk36FMHXUDjs.writeInfo.call(void 0, `\u{1F9F9} Cleaning output path: ${options.outputPath}`, config);
+    _fsextra.removeSync.call(void 0, options.outputPath);
+  }
+  await Promise.all(options.entry.map((entry) => {
+    _chunk36FMHXUDjs.writeInfo.call(void 0, `\u{1F680} Running Typia on entry: ${entry}`, config);
+    return _TypiaProgrammerjs.TypiaProgrammer.build({
+      input: entry,
+      output: options.outputPath,
+      project: options.tsconfig
+    });
+  }));
+  return {
+    success: true
+  };
+}
+_chunk3GQAWCBQjs.__name.call(void 0, typiaExecutorFn, "typiaExecutorFn");
+var executor_default = _chunkMSENNRAYjs.withRunExecutor.call(void 0, "Typia runtime validation generator", typiaExecutorFn, {
+  skipReadingConfig: false,
+  hooks: {
+    applyDefaultOptions: /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, (options) => {
+      options.entry ??= [
+        "{sourceRoot}/index.ts"
+      ];
+      options.outputPath ??= "{sourceRoot}/__generated__/typia";
+      options.tsconfig ??= "{projectRoot}/tsconfig.json";
+      options.clean ??= true;
+      return options;
+    }, "applyDefaultOptions")
+  }
+});
+
+
+
+
+exports.typiaExecutorFn = typiaExecutorFn; exports.executor_default = executor_default;

package/dist/chunk-BO44O7D2.mjs

@@ -0,0 +1,43 @@
+// src/types.ts
+var ProjectTagVariant = {
+  LANGUAGE: "language",
+  TYPE: "type",
+  DIST_STYLE: "dist-style",
+  PROVIDER: "provider",
+  PLATFORM: "platform",
+  REGISTRY: "registry",
+  PLUGIN: "plugin"
+};
+var ProjectTagLanguageValue = {
+  TYPESCRIPT: "typescript",
+  RUST: "rust"
+};
+var ProjectTagTypeValue = {
+  LIBRARY: "library",
+  APPLICATION: "application"
+};
+var ProjectTagDistStyleValue = {
+  NORMAL: "normal",
+  CLEAN: "clean"
+};
+var ProjectTagPlatformValue = {
+  NODE: "node",
+  BROWSER: "browser",
+  NEUTRAL: "neutral",
+  WORKER: "worker"
+};
+var ProjectTagRegistryValue = {
+  CARGO: "cargo",
+  NPM: "npm",
+  CONTAINER: "container",
+  CYCLONE: "cyclone"
+};
+
+export {
+  ProjectTagVariant,
+  ProjectTagLanguageValue,
+  ProjectTagTypeValue,
+  ProjectTagDistStyleValue,
+  ProjectTagPlatformValue,
+  ProjectTagRegistryValue
+};

package/dist/chunk-BWFTYFWM.js

@@ -0,0 +1,59 @@
+"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 _chunk5MKQX2FEjs = require('./chunk-5MKQX2FE.js');
+
+
+var _chunk3GQAWCBQjs = require('./chunk-3GQAWCBQ.js');
+
+// src/utils/apply-workspace-tokens.ts
+var applyWorkspaceExecutorTokens = /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, async (option, tokenizerOptions) => {
+  let result = option;
+  if (!result) {
+    return result;
+  }
+  let projectName;
+  let projectRoot;
+  let sourceRoot;
+  if (_optionalChain([tokenizerOptions, 'optionalAccess', _ => _.projectName])) {
+    const context = tokenizerOptions;
+    projectName = context.projectName;
+    projectRoot = context.root;
+    sourceRoot = context.sourceRoot;
+  } else {
+    const projectConfig = tokenizerOptions;
+    projectRoot = projectConfig.root;
+    if (projectConfig.name) {
+      projectName = projectConfig.name;
+    }
+    if (projectConfig.sourceRoot) {
+      sourceRoot = projectConfig.sourceRoot;
+    }
+  }
+  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("{projectName}")) {
+    result = result.replaceAll("{projectName}", projectName);
+  }
+  if (result.includes("{projectRoot}")) {
+    result = result.replaceAll("{projectRoot}", projectRoot);
+  }
+  if (result.includes("{sourceRoot}")) {
+    result = result.replaceAll("{sourceRoot}", sourceRoot);
+  }
+  if (result.includes("{workspaceRoot}")) {
+    result = result.replaceAll("{workspaceRoot}", _nullishCoalesce(tokenizerOptions.workspaceRoot, () => ( _chunk5MKQX2FEjs.findWorkspaceRoot.call(void 0, ))));
+  }
+  return result;
+}, "applyWorkspaceExecutorTokens");
+
+
+
+exports.applyWorkspaceExecutorTokens = applyWorkspaceExecutorTokens;