@storm-software/workspace-tools 1.233.0 → 1.233.1

package/dist/chunk-TSTK2BD6.mjs

@@ -1,507 +0,0 @@
-import {
-  addPackageDependencies,
-  addPackageJsonExports,
-  addWorkspacePackageJsonFields,
-  copyAssets
-} from "./chunk-OCXXIUSC.mjs";
-import {
-  withRunExecutor
-} from "./chunk-GVBCN2FA.mjs";
-import {
-  LogLevelLabel,
-  getStopwatch,
-  isVerbose,
-  loadStormConfig,
-  writeDebug,
-  writeError,
-  writeFatal,
-  writeInfo,
-  writeSuccess,
-  writeTrace
-} from "./chunk-DM2FMT3G.mjs";
-import {
-  joinPaths
-} from "./chunk-PVTEDLBL.mjs";
-import {
-  __name
-} from "./chunk-XUV4U54K.mjs";
-
-// ../unbuild/src/build.ts
-import { readCachedProjectGraph as readCachedProjectGraph2, writeJsonFile } from "@nx/devkit";
-import { getHelperDependency as getHelperDependency2, HelperDependency as HelperDependency2 } from "@nx/js";
-import { calculateProjectBuildableDependencies as calculateProjectBuildableDependencies2 } from "@nx/js/src/utils/buildable-libs-utils";
-import defu from "defu";
-import { createJiti } from "jiti";
-import { existsSync } from "node:fs";
-import { readFile } from "node:fs/promises";
-import { relative as relative2 } from "node:path";
-import { findWorkspaceRoot } from "nx/src/utils/find-workspace-root";
-
-// ../unbuild/src/clean.ts
-import { rm } from "node:fs/promises";
-async function clean(name = "Unbuild", directory, config) {
-  writeDebug(` \u{1F9F9}  Cleaning ${name} output path: ${directory}`, config);
-  const stopwatch = getStopwatch(`${name} output clean`);
-  await rm(directory, {
-    recursive: true,
-    force: true
-  });
-  stopwatch();
-}
-__name(clean, "clean");
-
-// ../unbuild/src/plugins/analyze.ts
-var formatBytes = /* @__PURE__ */ __name((bytes) => {
-  if (bytes === 0) return "0 Byte";
-  const k = 1e3;
-  const dm = 3;
-  const sizes = [
-    "Bytes",
-    "KB",
-    "MB",
-    "GB"
-  ];
-  const i = Math.floor(Math.log(bytes) / Math.log(k));
-  return `${parseFloat((bytes / k ** i).toFixed(dm))} ${sizes[i]}`;
-}, "formatBytes");
-var analyzePlugin = /* @__PURE__ */ __name((options, resolvedOptions) => {
-  return {
-    name: "storm:analyzer",
-    renderChunk(source, chunk) {
-      const sourceBytes = formatBytes(source.length);
-      const fileName = chunk.fileName;
-      writeInfo(` - ${fileName} ${sourceBytes}`, resolvedOptions.config);
-    }
-  };
-}, "analyzePlugin");
-
-// ../unbuild/src/plugins/on-error.ts
-var onErrorPlugin = /* @__PURE__ */ __name((options, resolvedOptions) => ({
-  name: "storm:on-error",
-  buildEnd(error) {
-    if (error) {
-      writeError(`The following errors occurred during the build:
-${error ? error.message : "Unknown build error"}
-
-    `, resolvedOptions.config);
-      throw new Error("Storm unbuild process failed with errors.");
-    }
-  },
-  renderError(error) {
-    writeError(`The following errors occurred during the build:
-${error ? error.message : "Unknown build error"}
-
-  `, resolvedOptions.config);
-    throw new Error("Storm unbuild process failed with errors.");
-  }
-}), "onErrorPlugin");
-
-// ../unbuild/src/plugins/tsc.ts
-import { readCachedProjectGraph } from "@nx/devkit";
-import { calculateProjectBuildableDependencies } from "@nx/js/src/utils/buildable-libs-utils";
-import { getHelperDependency, HelperDependency } from "@nx/js/src/utils/compiler-helper-dependency";
-import ts2Plugin from "rollup-plugin-typescript2";
-
-// ../unbuild/src/utilities/helpers.ts
-import { joinPathFragments } from "@nx/devkit";
-import { computeCompilerOptionsPaths } from "@nx/js/src/utils/buildable-libs-utils";
-import { dirname, extname } from "node:path";
-import { pathToFileURL } from "node:url";
-import ts from "typescript";
-async function loadConfig(configPath) {
-  if (!/\.(js|mjs)$/.test(extname(configPath))) {
-    throw new Error("Unsupported config file format");
-  }
-  return import(pathToFileURL(configPath).toString()).then((config) => config.default);
-}
-__name(loadConfig, "loadConfig");
-async function createTsCompilerOptions(config, tsConfigPath, projectRoot, dependencies) {
-  const tsConfigFile = ts.readConfigFile(joinPathFragments(config.workspaceRoot, projectRoot, tsConfigPath), ts.sys.readFile);
-  const tsConfig = ts.parseJsonConfigFileContent(tsConfigFile.config, ts.sys, dirname(joinPathFragments(config.workspaceRoot, projectRoot, tsConfigPath)));
-  const compilerOptions = {
-    rootDir: projectRoot,
-    declaration: true,
-    paths: computeCompilerOptionsPaths(tsConfig, dependencies ?? [])
-  };
-  writeTrace(compilerOptions, config);
-  return compilerOptions;
-}
-__name(createTsCompilerOptions, "createTsCompilerOptions");
-
-// ../unbuild/src/plugins/tsc.ts
-var tscPlugin = /* @__PURE__ */ __name(async (options, resolvedOptions) => {
-  const projectGraph = readCachedProjectGraph();
-  const result = calculateProjectBuildableDependencies(void 0, projectGraph, resolvedOptions.config.workspaceRoot, resolvedOptions.projectName, process.env.NX_TASK_TARGET_TARGET || "build", process.env.NX_TASK_TARGET_CONFIGURATION || "production", true);
-  let dependencies = result.dependencies;
-  const tsLibDependency = getHelperDependency(HelperDependency.tsc, resolvedOptions.tsconfig, dependencies, projectGraph, true);
-  if (tsLibDependency) {
-    dependencies = dependencies.filter((deps) => deps.name !== tsLibDependency.name);
-    dependencies.push(tsLibDependency);
-  }
-  return ts2Plugin({
-    check: options.emitTypes !== false,
-    tsconfig: resolvedOptions.tsconfig,
-    tsconfigOverride: {
-      compilerOptions: await createTsCompilerOptions(resolvedOptions.config, resolvedOptions.tsconfig, resolvedOptions.projectRoot, dependencies)
-    }
-  });
-}, "tscPlugin");
-
-// ../unbuild/src/plugins/type-definitions.ts
-import { relative } from "node:path";
-function typeDefinitions(projectRoot) {
-  return {
-    name: "storm:dts-bundle",
-    async generateBundle(_opts, bundle) {
-      for (const file of Object.values(bundle)) {
-        if (file.type === "asset" || !file.isEntry || file.facadeModuleId == null) {
-          continue;
-        }
-        const hasDefaultExport = file.exports.includes("default");
-        const entrySourceFileName = relative(projectRoot, file.facadeModuleId);
-        const entrySourceDtsName = entrySourceFileName.replace(/\.[cm]?[jt]sx?$/, "");
-        const dtsFileName = file.fileName.replace(/\.[cm]?js$/, ".d.ts");
-        const relativeSourceDtsName = JSON.stringify("./" + entrySourceDtsName);
-        const dtsFileSource = hasDefaultExport ? `
-export * from ${relativeSourceDtsName};
-export { default } from ${relativeSourceDtsName};
-            ` : `export * from ${relativeSourceDtsName};
-`;
-        this.emitFile({
-          type: "asset",
-          fileName: dtsFileName,
-          source: dtsFileSource
-        });
-      }
-    }
-  };
-}
-__name(typeDefinitions, "typeDefinitions");
-
-// ../unbuild/src/config.ts
-var getDefaultBuildPlugins = /* @__PURE__ */ __name(async (options, resolvedOptions) => Promise.all([
-  analyzePlugin(options, resolvedOptions),
-  typeDefinitions(resolvedOptions.projectRoot),
-  tscPlugin(options, resolvedOptions),
-  onErrorPlugin(options, resolvedOptions)
-].map((plugin) => Promise.resolve(plugin))), "getDefaultBuildPlugins");
-
-// ../unbuild/src/build.ts
-async function resolveOptions(options) {
-  const projectRoot = options.projectRoot;
-  if (!projectRoot) {
-    throw new Error("Cannot find project root");
-  }
-  const outputPath = options.outputPath || joinPaths("dist", projectRoot);
-  const workspaceRoot = findWorkspaceRoot(projectRoot);
-  if (!workspaceRoot) {
-    throw new Error("Cannot find workspace root");
-  }
-  const config = await loadStormConfig(workspaceRoot.dir);
-  writeDebug("  \u2699\uFE0F   Resolving build options", config);
-  const stopwatch = getStopwatch("Build options resolution");
-  if (options.configPath) {
-    const configFile = await loadConfig(options.configPath);
-    if (configFile) {
-      options = defu(options, configFile);
-    }
-  }
-  const projectGraph = readCachedProjectGraph2();
-  const projectJsonPath = joinPaths(config.workspaceRoot, projectRoot, "project.json");
-  if (!existsSync(projectJsonPath)) {
-    throw new Error("Cannot find project.json configuration");
-  }
-  const projectJsonContent = await readFile(projectJsonPath, "utf8");
-  const projectJson = JSON.parse(projectJsonContent);
-  const projectName = projectJson.name;
-  const packageJsonPath = joinPaths(workspaceRoot.dir, projectRoot, "package.json");
-  if (!existsSync(packageJsonPath)) {
-    throw new Error("Cannot find package.json configuration");
-  }
-  const packageJsonContent = await readFile(packageJsonPath, "utf8");
-  const packageJson = JSON.parse(packageJsonContent);
-  let tsconfig = options.tsconfig;
-  if (!tsconfig) {
-    tsconfig = joinPaths(workspaceRoot.dir, projectRoot, "tsconfig.json");
-  }
-  if (!existsSync(tsconfig)) {
-    throw new Error("Cannot find tsconfig.json configuration");
-  }
-  let sourceRoot = projectJson.sourceRoot;
-  if (!sourceRoot) {
-    sourceRoot = joinPaths(projectRoot, "src");
-  }
-  if (!existsSync(sourceRoot)) {
-    throw new Error("Cannot find sourceRoot directory");
-  }
-  const result = calculateProjectBuildableDependencies2(void 0, projectGraph, workspaceRoot.dir, projectName, process.env.NX_TASK_TARGET_TARGET || "build", process.env.NX_TASK_TARGET_CONFIGURATION || "production", true);
-  let dependencies = result.dependencies;
-  const tsLibDependency = getHelperDependency2(HelperDependency2.tsc, tsconfig, dependencies, projectGraph, true);
-  if (tsLibDependency) {
-    dependencies = dependencies.filter((deps) => deps.name !== tsLibDependency.name);
-    dependencies.push(tsLibDependency);
-  }
-  const jiti = createJiti(config.workspaceRoot, {
-    cache: true,
-    fsCache: config.skipCache ? false : joinPaths(config.directories.cache || "node_modules/.cache/storm", "jiti"),
-    interopDefault: true
-  });
-  const resolvedOptions = {
-    name: projectName,
-    config,
-    projectRoot,
-    sourceRoot,
-    projectName,
-    tsconfig,
-    jiti,
-    clean: false,
-    entries: [
-      {
-        builder: "mkdist",
-        input: `.${sourceRoot.replace(projectRoot, "")}`,
-        outDir: joinPaths(relative2(joinPaths(config.workspaceRoot, projectRoot), config.workspaceRoot).replaceAll("\\", "/"), outputPath, "dist").replaceAll("\\", "/"),
-        declaration: options.emitTypes !== false,
-        format: "esm"
-      },
-      {
-        builder: "mkdist",
-        input: `.${sourceRoot.replace(projectRoot, "")}`,
-        outDir: joinPaths(relative2(joinPaths(config.workspaceRoot, projectRoot), config.workspaceRoot).replaceAll("\\", "/"), outputPath, "dist").replaceAll("\\", "/"),
-        declaration: options.emitTypes !== false,
-        format: "cjs",
-        ext: "cjs"
-      }
-    ],
-    declaration: options.emitTypes !== false ? "compatible" : false,
-    failOnWarn: false,
-    sourcemap: options.sourcemap ?? !!options.debug,
-    outDir: outputPath,
-    parallel: true,
-    stub: false,
-    stubOptions: {
-      jiti: {}
-    },
-    externals: options.external ?? [],
-    dependencies: [],
-    peerDependencies: [],
-    devDependencies: [],
-    hooks: {},
-    alias: {},
-    replace: {},
-    rollup: {
-      replace: {},
-      alias: {},
-      json: {},
-      commonjs: {
-        sourceMap: options.sourcemap ?? true
-      },
-      emitCJS: true,
-      cjsBridge: true,
-      dts: {
-        respectExternal: true,
-        tsconfig
-      },
-      output: {
-        banner: options.banner || `
-//      \u26A1 Built by Storm Software
-  `,
-        footer: options.footer
-      },
-      resolve: {
-        preferBuiltins: true,
-        extensions: [
-          ".cjs",
-          ".mjs",
-          ".js",
-          ".jsx",
-          ".ts",
-          ".tsx",
-          ".json"
-        ]
-      },
-      esbuild: {
-        minify: options.minify !== false,
-        splitting: options.splitting !== false,
-        treeShaking: options.treeShaking !== false,
-        color: true,
-        logLevel: config.logLevel === LogLevelLabel.FATAL ? LogLevelLabel.ERROR : isVerbose() ? "verbose" : config.logLevel
-      }
-    }
-  };
-  dependencies = dependencies.filter((dep) => dep.node.type === "npm" || dep.node.type === "lib" || dep.node.type === "app");
-  if (dependencies.length > 0) {
-    resolvedOptions.dependencies = dependencies.map((dep) => dep.name);
-  }
-  if (packageJson.devDependencies) {
-    resolvedOptions.devDependencies = Object.keys(packageJson.devDependencies);
-  }
-  if (packageJson.peerDependencies) {
-    resolvedOptions.peerDependencies = Object.keys(packageJson.peerDependencies);
-  }
-  if (options.rollup) {
-    let rollup = {};
-    if (typeof options.rollup === "string") {
-      const rollupFile = await loadConfig(options.rollup);
-      if (rollupFile) {
-        rollup = rollupFile;
-      }
-    } else {
-      rollup = options.rollup;
-    }
-    resolvedOptions.rollup = defu(resolvedOptions.rollup ?? {}, rollup);
-  }
-  resolvedOptions.hooks = {
-    "rollup:options": /* @__PURE__ */ __name(async (ctx, opts) => {
-      opts.plugins = options.plugins ?? await getDefaultBuildPlugins(options, resolvedOptions);
-    }, "rollup:options")
-  };
-  stopwatch();
-  return resolvedOptions;
-}
-__name(resolveOptions, "resolveOptions");
-async function generatePackageJson(options) {
-  if (options.generatePackageJson !== false && existsSync(joinPaths(options.projectRoot, "package.json"))) {
-    writeDebug("  \u270D\uFE0F   Writing package.json file", options.config);
-    const stopwatch = getStopwatch("Write package.json file");
-    const packageJsonPath = joinPaths(options.projectRoot, "project.json");
-    if (!existsSync(packageJsonPath)) {
-      throw new Error("Cannot find package.json configuration");
-    }
-    let packageJsonContent = await readFile(joinPaths(options.config.workspaceRoot, options.projectRoot, "package.json"), "utf8");
-    if (!packageJsonContent) {
-      throw new Error("Cannot find package.json configuration file");
-    }
-    let packageJson = JSON.parse(packageJsonContent);
-    packageJson = await addPackageDependencies(options.config.workspaceRoot, options.projectRoot, options.projectName, packageJson);
-    packageJson = await addWorkspacePackageJsonFields(options.config, options.projectRoot, options.sourceRoot, options.projectName, false, packageJson);
-    await writeJsonFile(joinPaths(options.outDir, "package.json"), await addPackageJsonExports(options.sourceRoot, packageJson));
-    stopwatch();
-  }
-  return options;
-}
-__name(generatePackageJson, "generatePackageJson");
-async function resolveUnbuild(options) {
-  writeTrace(`Resolving Unbuild package with Jiti`, options.config);
-  try {
-    return options.jiti.import("unbuild");
-  } catch (error) {
-    writeError("  \u274C  An error occurred while resolving the Unbuild package", options.config);
-    throw new Error("An error occurred while resolving the Unbuild package", {
-      cause: error
-    });
-  }
-}
-__name(resolveUnbuild, "resolveUnbuild");
-async function executeUnbuild(options) {
-  writeDebug(`  \u{1F680}  Running ${options.name} (${options.projectRoot}) build`, options.config);
-  const stopwatch = getStopwatch(`${options.name} (${options.projectRoot}) build`);
-  try {
-    const unbuild = await resolveUnbuild(options);
-    await unbuild.build(options.projectRoot, false, {
-      ...options,
-      rootDir: options.projectRoot
-    });
-  } finally {
-    stopwatch();
-  }
-  return options;
-}
-__name(executeUnbuild, "executeUnbuild");
-async function copyBuildAssets(options) {
-  writeDebug(`  \u{1F4CB}  Copying asset files to output directory: ${options.outDir}`, options.config);
-  const stopwatch = getStopwatch(`${options.name} asset copy`);
-  await copyAssets(options.config, options.assets ?? [], options.outDir, options.projectRoot, options.projectName, options.sourceRoot, options.generatePackageJson, options.includeSrc);
-  stopwatch();
-  return options;
-}
-__name(copyBuildAssets, "copyBuildAssets");
-async function cleanOutputPath(options) {
-  if (options.clean !== false && options.outDir) {
-    await clean(options.name, options.outDir, options.config);
-  }
-  return options;
-}
-__name(cleanOutputPath, "cleanOutputPath");
-async function build(options) {
-  writeDebug(` \u26A1  Executing Storm Unbuild pipeline`);
-  const stopwatch = getStopwatch("Unbuild pipeline");
-  try {
-    const resolvedOptions = await resolveOptions(options);
-    await cleanOutputPath(resolvedOptions);
-    await generatePackageJson(resolvedOptions);
-    await executeUnbuild(resolvedOptions);
-    await copyBuildAssets(resolvedOptions);
-    writeSuccess(`  \u{1F3C1}  The ${resolvedOptions.name} build completed successfully`, resolvedOptions.config);
-  } catch (error) {
-    writeFatal("  \u274C  Fatal errors occurred during the build that could not be recovered from. The build process has been terminated.");
-    throw error;
-  } finally {
-    stopwatch();
-  }
-}
-__name(build, "build");
-
-// src/executors/unbuild/executor.ts
-import { defu as defu2 } from "defu";
-async function unbuildExecutorFn(options, context, config) {
-  writeInfo("\u{1F4E6}  Running Storm Unbuild executor on the workspace", config);
-  if (!context.projectsConfigurations?.projects || !context.projectName || !context.projectsConfigurations.projects[context.projectName] || !context.projectsConfigurations.projects[context.projectName]?.root) {
-    throw new Error("The Build process failed because the context is not valid. Please run this command from a workspace.");
-  }
-  await build(defu2({
-    ...options,
-    projectRoot: context.projectsConfigurations.projects?.[context.projectName].root,
-    projectName: context.projectName,
-    sourceRoot: context.projectsConfigurations.projects?.[context.projectName]?.sourceRoot,
-    platform: options.platform,
-    name: context.projectName
-  }, {
-    stubOptions: {
-      jiti: {
-        cache: "node_modules/.cache/storm"
-      }
-    },
-    rollup: {
-      emitCJS: true,
-      watch: false,
-      cjsBridge: false,
-      dts: {
-        respectExternal: true
-      },
-      replace: {},
-      alias: {},
-      resolve: {},
-      json: {},
-      commonjs: {},
-      esbuild: {
-        target: options.target,
-        format: "esm",
-        platform: options.platform,
-        minify: options.minify,
-        treeShaking: options.treeShaking
-      }
-    }
-  }));
-  return {
-    success: true
-  };
-}
-__name(unbuildExecutorFn, "unbuildExecutorFn");
-var executor_default = withRunExecutor("TypeScript Unbuild build", unbuildExecutorFn, {
-  skipReadingConfig: false,
-  hooks: {
-    applyDefaultOptions: /* @__PURE__ */ __name(async (options, config) => {
-      options.entry ??= [
-        "{sourceRoot}"
-      ];
-      options.outputPath ??= "dist/{projectRoot}";
-      options.tsconfig ??= "{projectRoot}/tsconfig.json";
-      return options;
-    }, "applyDefaultOptions")
-  }
-});
-
-export {
-  unbuildExecutorFn,
-  executor_default
-};