@storm-software/workspace-tools 1.295.65 → 1.295.66

package/dist/chunk-KBIJQTKM.js

@@ -1,105 +0,0 @@
-"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 _chunkGSGT2T27js = require('./chunk-GSGT2T27.js');
-
-
-var _chunkAGR3NCGAjs = require('./chunk-AGR3NCGA.js');
-
-
-var _chunkCQDBLKPFjs = require('./chunk-CQDBLKPF.js');
-
-// src/executors/unbuild/executor.ts
-var _defu = require('defu');
-var _jiti = require('jiti');
-async function unbuildExecutorFn(options, context, config) {
-  _chunkAGR3NCGAjs.writeInfo.call(void 0, "\u{1F4E6}  Running Storm Unbuild executor on the workspace", config);
-  if (!_optionalChain([context, 'access', _ => _.projectsConfigurations, 'optionalAccess', _2 => _2.projects]) || !context.projectName || !context.projectsConfigurations.projects[context.projectName]) {
-    throw new Error(
-      "The Build process failed because the context is not valid. Please run this command from a workspace root directory."
-    );
-  }
-  if (!context.projectsConfigurations.projects[context.projectName].root) {
-    throw new Error(
-      "The Build process failed because the project root is not valid. Please run this command from a workspace root directory."
-    );
-  }
-  if (!context.projectsConfigurations.projects[context.projectName].sourceRoot) {
-    throw new Error(
-      "The Build process failed because the project's source root is not valid. Please run this command from a workspace root directory."
-    );
-  }
-  const jiti = _jiti.createJiti.call(void 0, config.workspaceRoot, {
-    fsCache: config.skipCache ? false : _chunkCQDBLKPFjs.joinPaths.call(void 0, 
-      config.workspaceRoot,
-      config.directories.cache || "node_modules/.cache/storm",
-      "jiti"
-    ),
-    interopDefault: true
-  });
-  const stormUnbuild = await jiti.import(
-    jiti.esmResolve("@storm-software/unbuild/build")
-  );
-  await stormUnbuild.build(
-    _defu.defu.call(void 0, 
-      {
-        ...options,
-        projectRoot: context.projectsConfigurations.projects[context.projectName].root,
-        projectName: context.projectName,
-        sourceRoot: context.projectsConfigurations.projects[context.projectName].sourceRoot,
-        platform: options.platform
-      },
-      {
-        stubOptions: {
-          jiti: {
-            fsCache: config.skipCache ? false : _chunkCQDBLKPFjs.joinPaths.call(void 0, 
-              config.workspaceRoot,
-              config.directories.cache || "node_modules/.cache/storm",
-              "jiti"
-            )
-          }
-        },
-        rollup: {
-          emitCJS: true,
-          watch: false,
-          dts: {
-            respectExternal: true
-          },
-          esbuild: {
-            target: options.target,
-            format: "esm",
-            platform: options.platform,
-            minify: _nullishCoalesce(options.minify, () => ( !options.debug)),
-            sourcemap: _nullishCoalesce(options.sourcemap, () => ( options.debug)),
-            treeShaking: options.treeShaking
-          }
-        }
-      }
-    )
-  );
-  return {
-    success: true
-  };
-}
-var executor_default = _chunkGSGT2T27js.withRunExecutor.call(void 0, 
-  "TypeScript Unbuild build",
-  unbuildExecutorFn,
-  {
-    skipReadingConfig: false,
-    hooks: {
-      applyDefaultOptions: async (options, config) => {
-        options.debug ??= false;
-        options.treeShaking ??= true;
-        options.buildOnly ??= false;
-        options.platform ??= "neutral";
-        options.entry ??= ["{sourceRoot}"];
-        options.tsconfig ??= "{projectRoot}/tsconfig.json";
-        return options;
-      }
-    }
-  }
-);
-
-
-
-
-exports.unbuildExecutorFn = unbuildExecutorFn; exports.executor_default = executor_default;

package/dist/chunk-KBJ7IEXI.js

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

package/dist/chunk-KR72GKIT.mjs

@@ -1,7 +0,0 @@
-// src/utils/typia-transform.ts
-import transform from "typia/lib/transform";
-var getTypiaTransform = (program, diagnostics) => transform(program, {}, { addDiagnostic: (input) => diagnostics.push(input) });
-
-export {
-  getTypiaTransform
-};

package/dist/chunk-LMYTVXGX.js

@@ -1,100 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
-
-var _chunkCQDBLKPFjs = require('./chunk-CQDBLKPF.js');
-
-// ../config-tools/src/utilities/find-up.ts
-var _fs = require('fs');
-var _path = require('path');
-var MAX_PATH_SEARCH_DEPTH = 30;
-var depth = 0;
-function findFolderUp(startPath, endFileNames = [], endDirectoryNames = []) {
-  const _startPath = _nullishCoalesce(startPath, () => ( process.cwd()));
-  if (endDirectoryNames.some(
-    (endDirName) => _fs.existsSync.call(void 0, _path.join.call(void 0, _startPath, endDirName))
-  )) {
-    return _startPath;
-  }
-  if (endFileNames.some((endFileName) => _fs.existsSync.call(void 0, _path.join.call(void 0, _startPath, endFileName)))) {
-    return _startPath;
-  }
-  if (_startPath !== "/" && depth++ < MAX_PATH_SEARCH_DEPTH) {
-    const parent = _path.join.call(void 0, _startPath, "..");
-    return findFolderUp(parent, endFileNames, endDirectoryNames);
-  }
-  return void 0;
-}
-
-// ../config-tools/src/utilities/find-workspace-root.ts
-var rootFiles = [
-  "storm-workspace.json",
-  "storm-workspace.yaml",
-  "storm-workspace.yml",
-  "storm-workspace.js",
-  "storm-workspace.ts",
-  ".storm-workspace.json",
-  ".storm-workspace.yaml",
-  ".storm-workspace.yml",
-  ".storm-workspace.js",
-  ".storm-workspace.ts",
-  "lerna.json",
-  "nx.json",
-  "turbo.json",
-  "npm-workspace.json",
-  "yarn-workspace.json",
-  "pnpm-workspace.json",
-  "npm-workspace.yaml",
-  "yarn-workspace.yaml",
-  "pnpm-workspace.yaml",
-  "npm-workspace.yml",
-  "yarn-workspace.yml",
-  "pnpm-workspace.yml",
-  "npm-lock.json",
-  "yarn-lock.json",
-  "pnpm-lock.json",
-  "npm-lock.yaml",
-  "yarn-lock.yaml",
-  "pnpm-lock.yaml",
-  "npm-lock.yml",
-  "yarn-lock.yml",
-  "pnpm-lock.yml",
-  "bun.lockb"
-];
-var rootDirectories = [
-  ".storm-workspace",
-  ".nx",
-  ".git",
-  ".github",
-  ".vscode",
-  ".verdaccio"
-];
-function findWorkspaceRootSafe(pathInsideMonorepo) {
-  if (process.env.STORM_WORKSPACE_ROOT || process.env.NX_WORKSPACE_ROOT_PATH) {
-    return _chunkCQDBLKPFjs.correctPaths.call(void 0, 
-      _nullishCoalesce(process.env.STORM_WORKSPACE_ROOT, () => ( process.env.NX_WORKSPACE_ROOT_PATH))
-    );
-  }
-  return _chunkCQDBLKPFjs.correctPaths.call(void 0, 
-    findFolderUp(
-      _nullishCoalesce(pathInsideMonorepo, () => ( process.cwd())),
-      rootFiles,
-      rootDirectories
-    )
-  );
-}
-function findWorkspaceRoot(pathInsideMonorepo) {
-  const result = findWorkspaceRootSafe(pathInsideMonorepo);
-  if (!result) {
-    throw new Error(
-      `Cannot find workspace root upwards from known path. Files search list includes: 
-${rootFiles.join(
-        "\n"
-      )}
-Path: ${pathInsideMonorepo ? pathInsideMonorepo : process.cwd()}`
-    );
-  }
-  return result;
-}
-
-
-
-exports.findWorkspaceRoot = findWorkspaceRoot;

package/dist/chunk-LOIAWLLD.mjs

@@ -1,128 +0,0 @@
-import {
-  cargoMetadata
-} from "./chunk-GKLFEOKK.mjs";
-import {
-  withRunExecutor
-} from "./chunk-SEZ726NO.mjs";
-import {
-  writeDebug
-} from "./chunk-T55IDP24.mjs";
-import {
-  correctPaths,
-  isAbsolute,
-  joinPaths,
-  relative
-} from "./chunk-TBW5MCN6.mjs";
-
-// src/executors/napi/executor.ts
-import { createJiti } from "jiti";
-import { fileExists } from "nx/src/utils/fileutils";
-async function napiExecutor(options, context, config) {
-  const jiti = createJiti(config.workspaceRoot, {
-    fsCache: config.skipCache ? false : joinPaths(
-      config.workspaceRoot,
-      config.directories.cache || "node_modules/.cache/storm",
-      "jiti"
-    ),
-    interopDefault: true
-  });
-  const { NapiCli } = await jiti.import(
-    jiti.esmResolve("@napi-rs/cli")
-  );
-  if (!context.projectGraph?.nodes[context.projectName ?? ""]) {
-    throw new Error(
-      "The Napi Build process failed because the project could not be found in the project graph. Please run this command from a workspace root directory."
-    );
-  }
-  const projectRoot = context.projectGraph?.nodes[context.projectName ?? ""]?.data.root;
-  const packageJson = joinPaths(projectRoot ?? ".", "package.json");
-  if (!fileExists(packageJson)) {
-    throw new Error(`Could not find package.json at ${packageJson}`);
-  }
-  const napi = new NapiCli();
-  const normalizedOptions = { ...options };
-  const metadata = cargoMetadata();
-  normalizedOptions.targetDir = options.targetDir || metadata?.target_directory || joinPaths(config.workspaceRoot, "dist", "target");
-  normalizedOptions.outputDir = options.outputPath;
-  normalizedOptions.packageJsonPath ??= packageJson;
-  if (options.cwd) {
-    normalizedOptions.cwd = correctPaths(options.cwd);
-  } else {
-    const absoluteProjectRoot = correctPaths(
-      joinPaths(config.workspaceRoot, projectRoot || ".")
-    );
-    normalizedOptions.cwd = absoluteProjectRoot;
-    if (normalizedOptions.outputDir) {
-      normalizedOptions.outputDir = relative(
-        normalizedOptions.cwd,
-        correctPaths(
-          isAbsolute(normalizedOptions.outputDir) ? normalizedOptions.outputDir : joinPaths(config.workspaceRoot, normalizedOptions.outputDir)
-        )
-      );
-    }
-    if (normalizedOptions.packageJsonPath) {
-      normalizedOptions.packageJsonPath = relative(
-        normalizedOptions.cwd,
-        correctPaths(
-          isAbsolute(normalizedOptions.packageJsonPath) ? normalizedOptions.packageJsonPath : joinPaths(config.workspaceRoot, normalizedOptions.packageJsonPath)
-        )
-      );
-    }
-    if (normalizedOptions.configPath) {
-      normalizedOptions.configPath = relative(
-        normalizedOptions.cwd,
-        correctPaths(
-          isAbsolute(normalizedOptions.configPath) ? normalizedOptions.configPath : joinPaths(config.workspaceRoot, normalizedOptions.configPath)
-        )
-      );
-    }
-    if (normalizedOptions.manifestPath) {
-      normalizedOptions.manifestPath = relative(
-        normalizedOptions.cwd,
-        correctPaths(
-          isAbsolute(normalizedOptions.manifestPath) ? normalizedOptions.manifestPath : joinPaths(config.workspaceRoot, normalizedOptions.manifestPath)
-        )
-      );
-    }
-  }
-  if (process.env.VERCEL) {
-    return { success: true };
-  }
-  writeDebug(
-    `Normalized Napi Options: 
-packageJsonPath: ${normalizedOptions.packageJsonPath} 
-outputDir: ${normalizedOptions.outputDir} 
-targetDir: ${normalizedOptions.targetDir} 
-manifestPath: ${normalizedOptions.manifestPath} 
-configPath: ${normalizedOptions.configPath} 
-cwd: ${normalizedOptions.cwd}`,
-    config
-  );
-  const { task } = await napi.build(normalizedOptions);
-  return { success: true, terminalOutput: await task };
-}
-var executor_default = withRunExecutor(
-  "Napi - Build Bindings",
-  napiExecutor,
-  {
-    skipReadingConfig: false,
-    hooks: {
-      applyDefaultOptions: (options) => {
-        options.outputPath ??= "{sourceRoot}";
-        options.toolchain ??= "stable";
-        options.dtsCache ??= true;
-        options.platform ??= true;
-        options.constEnum ??= false;
-        options.verbose ??= false;
-        options.jsBinding ??= "binding.js";
-        options.dts ??= "binding.d.ts";
-        return options;
-      }
-    }
-  }
-);
-
-export {
-  napiExecutor,
-  executor_default
-};

package/dist/chunk-LQHVZMFV.js

@@ -1,79 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-var _chunk7JRL2LE3js = require('./chunk-7JRL2LE3.js');
-
-// src/base/cargo-base-executor.untyped.ts
-var _untyped = require('untyped');
-var cargo_base_executor_untyped_default = _untyped.defineUntypedSchema.call(void 0, {
-  ..._chunk7JRL2LE3js.base_executor_untyped_default,
-  $schema: {
-    id: "cargoBaseExecutor",
-    title: "Cargo Base Executor",
-    description: "A base type definition for a Cargo/rust related executor schema"
-  },
-  package: {
-    $schema: {
-      title: "Cargo.toml Path",
-      type: "string",
-      format: "path",
-      description: "The path to the Cargo.toml file"
-    },
-    $default: "{projectRoot}/Cargo.toml"
-  },
-  toolchain: {
-    $schema: {
-      title: "Toolchain",
-      description: "The type of toolchain to use for the build",
-      enum: ["stable", "beta", "nightly"],
-      default: "stable"
-    },
-    $default: "stable"
-  },
-  target: {
-    $schema: {
-      title: "Target",
-      type: "string",
-      description: "The target to build"
-    }
-  },
-  allTargets: {
-    $schema: {
-      title: "All Targets",
-      type: "boolean",
-      description: "Build all targets"
-    }
-  },
-  profile: {
-    $schema: {
-      title: "Profile",
-      type: "string",
-      description: "The profile to build"
-    }
-  },
-  release: {
-    $schema: {
-      title: "Release",
-      type: "boolean",
-      description: "Build in release mode"
-    }
-  },
-  features: {
-    $schema: {
-      title: "Features",
-      type: "string",
-      description: "The features to build",
-      oneOf: [{ type: "string" }, { type: "array", items: { type: "string" } }]
-    }
-  },
-  allFeatures: {
-    $schema: {
-      title: "All Features",
-      type: "boolean",
-      description: "Build all features"
-    }
-  }
-});
-
-
-
-exports.cargo_base_executor_untyped_default = cargo_base_executor_untyped_default;

package/dist/chunk-LZ3H2OH5.mjs

@@ -1,158 +0,0 @@
-import {
-  base_executor_untyped_default
-} from "./chunk-ZCTECGQS.mjs";
-
-// src/base/typescript-build-executor.untyped.ts
-import { defineUntypedSchema } from "untyped";
-var typescript_build_executor_untyped_default = defineUntypedSchema({
-  ...base_executor_untyped_default,
-  $schema: {
-    id: "TypeScriptBuildExecutorSchema",
-    title: "TypeScript Build Executor",
-    description: "A type definition for the base TypeScript build executor schema",
-    required: ["entry", "tsconfig"]
-  },
-  entry: {
-    $schema: {
-      title: "Entry File(s)",
-      format: "path",
-      type: "array",
-      description: "The entry file or files to build",
-      items: { type: "string" }
-    },
-    $default: ["{sourceRoot}/index.ts"]
-  },
-  tsconfig: {
-    $schema: {
-      title: "TSConfig Path",
-      type: "string",
-      format: "path",
-      description: "The path to the tsconfig file"
-    },
-    $default: "{projectRoot}/tsconfig.json"
-  },
-  bundle: {
-    $schema: {
-      title: "Bundle",
-      type: "boolean",
-      description: "Bundle the output"
-    }
-  },
-  minify: {
-    $schema: {
-      title: "Minify",
-      type: "boolean",
-      description: "Minify the output"
-    }
-  },
-  debug: {
-    $schema: {
-      title: "Debug",
-      type: "boolean",
-      description: "Debug the output"
-    }
-  },
-  sourcemap: {
-    $schema: {
-      title: "Sourcemap",
-      type: "boolean",
-      description: "Generate a sourcemap"
-    }
-  },
-  silent: {
-    $schema: {
-      title: "Silent",
-      type: "boolean",
-      description: "Should the build run silently - only report errors back to the user"
-    },
-    $default: false
-  },
-  target: {
-    $schema: {
-      title: "Target",
-      type: "string",
-      description: "The target to build",
-      enum: [
-        "es3",
-        "es5",
-        "es6",
-        "es2015",
-        "es2016",
-        "es2017",
-        "es2018",
-        "es2019",
-        "es2020",
-        "es2021",
-        "es2022",
-        "es2023",
-        "es2024",
-        "esnext",
-        "node12",
-        "node14",
-        "node16",
-        "node18",
-        "node20",
-        "node22",
-        "browser",
-        "chrome58",
-        "chrome59",
-        "chrome60"
-      ]
-    },
-    $default: "esnext",
-    $resolve: (val = "esnext") => typeof val === "string" ? val.toLowerCase() : val
-  },
-  format: {
-    $schema: {
-      title: "Format",
-      type: "array",
-      description: "The format to build",
-      items: {
-        type: "string",
-        enum: ["cjs", "esm", "iife"]
-      }
-    },
-    $resolve: (val = ["cjs", "esm"]) => [].concat(val)
-  },
-  platform: {
-    $schema: {
-      title: "Platform",
-      type: "string",
-      description: "The platform to build",
-      enum: ["neutral", "node", "browser"]
-    },
-    $default: "neutral"
-  },
-  external: {
-    $schema: {
-      title: "External",
-      type: "array",
-      description: "The external dependencies"
-    },
-    $resolve: (val = []) => [].concat(val)
-  },
-  define: {
-    $schema: {
-      title: "Define",
-      type: "object",
-      tsType: "Record<string, string>",
-      description: "The define values"
-    },
-    $resolve: (val = {}) => val,
-    $default: {}
-  },
-  env: {
-    $schema: {
-      title: "Environment Variables",
-      type: "object",
-      tsType: "Record<string, string>",
-      description: "The environment variable values"
-    },
-    $resolve: (val = {}) => val,
-    $default: {}
-  }
-});
-
-export {
-  typescript_build_executor_untyped_default
-};