@storm-software/unbuild 0.22.0 → 0.23.1

package/dist/chunk-Q6WN55YR.mjs

@@ -0,0 +1,287 @@
+import {
+  clean
+} from "./chunk-K7L2WB3G.mjs";
+import {
+  getDefaultBuildPlugins
+} from "./chunk-XPX5NQ4D.mjs";
+import {
+  loadConfig
+} from "./chunk-67M6JMGM.mjs";
+import {
+  __name,
+  init_esm_shims
+} from "./chunk-3TNHGERR.mjs";
+
+// src/build.ts
+init_esm_shims();
+import { readCachedProjectGraph, writeJsonFile } from "@nx/devkit";
+import { getHelperDependency, HelperDependency } from "@nx/js";
+import { calculateProjectBuildableDependencies } from "@nx/js/src/utils/buildable-libs-utils";
+import { addPackageDependencies, addPackageJsonExports, addWorkspacePackageJsonFields, copyAssets } from "@storm-software/build-tools";
+import { loadStormConfig } from "@storm-software/config-tools/create-storm-config";
+import { getStopwatch, writeDebug, writeError, writeFatal, writeSuccess, writeTrace } from "@storm-software/config-tools/logger/console";
+import { isVerbose } from "@storm-software/config-tools/logger/get-log-level";
+import { LogLevelLabel } from "@storm-software/config-tools/types";
+import { joinPaths } from "@storm-software/config-tools/utilities/correct-paths";
+import defu from "defu";
+import { createJiti } from "jiti";
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { relative } from "node:path";
+import { findWorkspaceRoot } from "nx/src/utils/find-workspace-root";
+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 = readCachedProjectGraph();
+  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 = calculateProjectBuildableDependencies(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 = getHelperDependency(HelperDependency.tsc, tsconfig, dependencies, projectGraph, true);
+  if (tsLibDependency) {
+    dependencies = dependencies.filter((deps) => deps.name !== tsLibDependency.name);
+    dependencies.push(tsLibDependency);
+  }
+  const jiti = createJiti(config.workspaceRoot, {
+    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(relative(joinPaths(config.workspaceRoot, projectRoot), config.workspaceRoot).replaceAll("\\", "/"), outputPath, "dist").replaceAll("\\", "/"),
+        declaration: options.emitTypes !== false,
+        format: "esm"
+      },
+      {
+        builder: "mkdist",
+        input: `.${sourceRoot.replace(projectRoot, "")}`,
+        outDir: joinPaths(relative(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");
+
+export {
+  build
+};

package/dist/chunk-RBSVNX4W.js

@@ -0,0 +1,49 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/.pnpm/tsup@8.3.5_@microsoft+api-extractor@7.49.1_@types+node@22.10.7__@swc+core@1.7.26_@swc+helpers_ekim6y52mwpq6ssxiprcp44dam/node_modules/tsup/assets/cjs_shims.js
+var init_cjs_shims = __esm({
+  "../../node_modules/.pnpm/tsup@8.3.5_@microsoft+api-extractor@7.49.1_@types+node@22.10.7__@swc+core@1.7.26_@swc+helpers_ekim6y52mwpq6ssxiprcp44dam/node_modules/tsup/assets/cjs_shims.js"() {
+  }
+});
+
+
+
+
+
+
+
+exports.__name = __name; exports.__require = __require; exports.__commonJS = __commonJS; exports.__toESM = __toESM; exports.init_cjs_shims = init_cjs_shims;

package/dist/{chunk-BMAXMHJB.js → chunk-SLC5BBLC.js}

@@ -1,16 +1,16 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunkUUI4UWA4js = require('./chunk-UUI4UWA4.js');
 
-
-var _chunk4WKFVYTIjs = require('./chunk-4WKFVYTI.js');
+var _chunkRBSVNX4Wjs = require('./chunk-RBSVNX4W.js');
 
 // src/plugins/on-error.ts
-var onErrorPlugin = /* @__PURE__ */ _chunk4WKFVYTIjs.__name.call(void 0, (options, resolvedOptions) => ({
+_chunkRBSVNX4Wjs.init_cjs_shims.call(void 0, );
+var _configtools = require('@storm-software/config-tools');
+var onErrorPlugin = /* @__PURE__ */ _chunkRBSVNX4Wjs.__name.call(void 0, (options, resolvedOptions) => ({
   name: "storm:on-error",
   buildEnd(error) {
     if (error) {
-      _chunkUUI4UWA4js.writeError.call(void 0, `The following errors occurred during the build:
+      _configtools.writeError.call(void 0, `The following errors occurred during the build:
 ${error ? error.message : "Unknown build error"}
 
     `, resolvedOptions.config);
@@ -18,7 +18,7 @@ ${error ? error.message : "Unknown build error"}
     }
   },
   renderError(error) {
-    _chunkUUI4UWA4js.writeError.call(void 0, `The following errors occurred during the build:
+    _configtools.writeError.call(void 0, `The following errors occurred during the build:
 ${error ? error.message : "Unknown build error"}
 
   `, resolvedOptions.config);

package/dist/chunk-T5JY3PDF.js

@@ -0,0 +1,23 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunkRBSVNX4Wjs = require('./chunk-RBSVNX4W.js');
+
+// src/clean.ts
+_chunkRBSVNX4Wjs.init_cjs_shims.call(void 0, );
+var _console = require('@storm-software/config-tools/logger/console');
+var _promises = require('fs/promises');
+async function clean(name = "Unbuild", directory, config) {
+  _console.writeDebug.call(void 0, ` \u{1F9F9}  Cleaning ${name} output path: ${directory}`, config);
+  const stopwatch = _console.getStopwatch.call(void 0, `${name} output clean`);
+  await _promises.rm.call(void 0, directory, {
+    recursive: true,
+    force: true
+  });
+  stopwatch();
+}
+_chunkRBSVNX4Wjs.__name.call(void 0, clean, "clean");
+
+
+
+exports.clean = clean;