@storm-software/unbuild 0.22.0 → 0.23.1

package/dist/chunk-7G3WYTPJ.js

@@ -0,0 +1,6 @@
+"use strict";
+
+var _chunkRBSVNX4Wjs = require('./chunk-RBSVNX4W.js');
+
+// src/types.ts
+_chunkRBSVNX4Wjs.init_cjs_shims.call(void 0, );

package/dist/{chunk-OG2CKJQU.mjs → chunk-AQ2MDNLT.mjs}

@@ -1,11 +1,11 @@
 import {
-  writeError
-} from "./chunk-B5GGHMTB.mjs";
-import {
-  __name
-} from "./chunk-LPEX4YW6.mjs";
+  __name,
+  init_esm_shims
+} from "./chunk-3TNHGERR.mjs";
 
 // src/plugins/on-error.ts
+init_esm_shims();
+import { writeError } from "@storm-software/config-tools";
 var onErrorPlugin = /* @__PURE__ */ __name((options, resolvedOptions) => ({
   name: "storm:on-error",
   buildEnd(error) {

package/dist/{chunk-IIVTCNH5.mjs → chunk-K7L2WB3G.mjs}

@@ -1,12 +1,11 @@
 import {
-  getStopwatch,
-  writeDebug
-} from "./chunk-B5GGHMTB.mjs";
-import {
-  __name
-} from "./chunk-LPEX4YW6.mjs";
+  __name,
+  init_esm_shims
+} from "./chunk-3TNHGERR.mjs";
 
 // src/clean.ts
+init_esm_shims();
+import { getStopwatch, writeDebug } from "@storm-software/config-tools/logger/console";
 import { rm } from "node:fs/promises";
 async function clean(name = "Unbuild", directory, config) {
   writeDebug(` \u{1F9F9}  Cleaning ${name} output path: ${directory}`, config);

package/dist/{chunk-6KE6SIPQ.js → chunk-LYYHOUCS.js}

@@ -1,12 +1,12 @@
 "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/analyze.ts
-var formatBytes = /* @__PURE__ */ _chunk4WKFVYTIjs.__name.call(void 0, (bytes) => {
+_chunkRBSVNX4Wjs.init_cjs_shims.call(void 0, );
+var _configtools = require('@storm-software/config-tools');
+var formatBytes = /* @__PURE__ */ _chunkRBSVNX4Wjs.__name.call(void 0, (bytes) => {
   if (bytes === 0) return "0 Byte";
   const k = 1e3;
   const dm = 3;
@@ -19,13 +19,13 @@ var formatBytes = /* @__PURE__ */ _chunk4WKFVYTIjs.__name.call(void 0, (bytes) =
   const i = Math.floor(Math.log(bytes) / Math.log(k));
   return `${parseFloat((bytes / k ** i).toFixed(dm))} ${sizes[i]}`;
 }, "formatBytes");
-var analyzePlugin = /* @__PURE__ */ _chunk4WKFVYTIjs.__name.call(void 0, (options, resolvedOptions) => {
+var analyzePlugin = /* @__PURE__ */ _chunkRBSVNX4Wjs.__name.call(void 0, (options, resolvedOptions) => {
   return {
     name: "storm:analyzer",
     renderChunk(source, chunk) {
       const sourceBytes = formatBytes(source.length);
       const fileName = chunk.fileName;
-      _chunkUUI4UWA4js.writeInfo.call(void 0, ` - ${fileName} ${sourceBytes}`, resolvedOptions.config);
+      _configtools.writeInfo.call(void 0, ` - ${fileName} ${sourceBytes}`, resolvedOptions.config);
     }
   };
 }, "analyzePlugin");

package/dist/chunk-NA6OVNJI.js

@@ -0,0 +1,287 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } }
+
+var _chunkT5JY3PDFjs = require('./chunk-T5JY3PDF.js');
+
+
+var _chunk5A3XPRPOjs = require('./chunk-5A3XPRPO.js');
+
+
+var _chunkTAHELANGjs = require('./chunk-TAHELANG.js');
+
+
+
+var _chunkRBSVNX4Wjs = require('./chunk-RBSVNX4W.js');
+
+// src/build.ts
+_chunkRBSVNX4Wjs.init_cjs_shims.call(void 0, );
+var _devkit = require('@nx/devkit');
+var _js = require('@nx/js');
+var _buildablelibsutils = require('@nx/js/src/utils/buildable-libs-utils');
+var _buildtools = require('@storm-software/build-tools');
+var _createstormconfig = require('@storm-software/config-tools/create-storm-config');
+var _console = require('@storm-software/config-tools/logger/console');
+var _getloglevel = require('@storm-software/config-tools/logger/get-log-level');
+var _types = require('@storm-software/config-tools/types');
+var _correctpaths = require('@storm-software/config-tools/utilities/correct-paths');
+var _defu = require('defu'); var _defu2 = _interopRequireDefault(_defu);
+var _jiti = require('jiti');
+var _fs = require('fs');
+var _promises = require('fs/promises');
+var _path = require('path');
+var _findworkspaceroot = require('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 || _correctpaths.joinPaths.call(void 0, "dist", projectRoot);
+  const workspaceRoot = _findworkspaceroot.findWorkspaceRoot.call(void 0, projectRoot);
+  if (!workspaceRoot) {
+    throw new Error("Cannot find workspace root");
+  }
+  const config = await _createstormconfig.loadStormConfig.call(void 0, workspaceRoot.dir);
+  _console.writeDebug.call(void 0, "  \u2699\uFE0F   Resolving build options", config);
+  const stopwatch = _console.getStopwatch.call(void 0, "Build options resolution");
+  if (options.configPath) {
+    const configFile = await _chunkTAHELANGjs.loadConfig.call(void 0, options.configPath);
+    if (configFile) {
+      options = _defu2.default.call(void 0, options, configFile);
+    }
+  }
+  const projectGraph = _devkit.readCachedProjectGraph.call(void 0, );
+  const projectJsonPath = _correctpaths.joinPaths.call(void 0, config.workspaceRoot, projectRoot, "project.json");
+  if (!_fs.existsSync.call(void 0, projectJsonPath)) {
+    throw new Error("Cannot find project.json configuration");
+  }
+  const projectJsonContent = await _promises.readFile.call(void 0, projectJsonPath, "utf8");
+  const projectJson = JSON.parse(projectJsonContent);
+  const projectName = projectJson.name;
+  const packageJsonPath = _correctpaths.joinPaths.call(void 0, workspaceRoot.dir, projectRoot, "package.json");
+  if (!_fs.existsSync.call(void 0, packageJsonPath)) {
+    throw new Error("Cannot find package.json configuration");
+  }
+  const packageJsonContent = await _promises.readFile.call(void 0, packageJsonPath, "utf8");
+  const packageJson = JSON.parse(packageJsonContent);
+  let tsconfig = options.tsconfig;
+  if (!tsconfig) {
+    tsconfig = _correctpaths.joinPaths.call(void 0, workspaceRoot.dir, projectRoot, "tsconfig.json");
+  }
+  if (!_fs.existsSync.call(void 0, tsconfig)) {
+    throw new Error("Cannot find tsconfig.json configuration");
+  }
+  let sourceRoot = projectJson.sourceRoot;
+  if (!sourceRoot) {
+    sourceRoot = _correctpaths.joinPaths.call(void 0, projectRoot, "src");
+  }
+  if (!_fs.existsSync.call(void 0, sourceRoot)) {
+    throw new Error("Cannot find sourceRoot directory");
+  }
+  const result = _buildablelibsutils.calculateProjectBuildableDependencies.call(void 0, 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 = _js.getHelperDependency.call(void 0, _js.HelperDependency.tsc, tsconfig, dependencies, projectGraph, true);
+  if (tsLibDependency) {
+    dependencies = dependencies.filter((deps) => deps.name !== tsLibDependency.name);
+    dependencies.push(tsLibDependency);
+  }
+  const jiti = _jiti.createJiti.call(void 0, config.workspaceRoot, {
+    fsCache: config.skipCache ? false : _correctpaths.joinPaths.call(void 0, 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: _correctpaths.joinPaths.call(void 0, _path.relative.call(void 0, _correctpaths.joinPaths.call(void 0, config.workspaceRoot, projectRoot), config.workspaceRoot).replaceAll("\\", "/"), outputPath, "dist").replaceAll("\\", "/"),
+        declaration: options.emitTypes !== false,
+        format: "esm"
+      },
+      {
+        builder: "mkdist",
+        input: `.${sourceRoot.replace(projectRoot, "")}`,
+        outDir: _correctpaths.joinPaths.call(void 0, _path.relative.call(void 0, _correctpaths.joinPaths.call(void 0, 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: _nullishCoalesce(options.sourcemap, () => ( !!options.debug)),
+    outDir: outputPath,
+    parallel: true,
+    stub: false,
+    stubOptions: {
+      jiti: {}
+    },
+    externals: _nullishCoalesce(options.external, () => ( [])),
+    dependencies: [],
+    peerDependencies: [],
+    devDependencies: [],
+    hooks: {},
+    alias: {},
+    replace: {},
+    rollup: {
+      replace: {},
+      alias: {},
+      json: {},
+      commonjs: {
+        sourceMap: _nullishCoalesce(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 === _types.LogLevelLabel.FATAL ? _types.LogLevelLabel.ERROR : _getloglevel.isVerbose.call(void 0, ) ? "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 _chunkTAHELANGjs.loadConfig.call(void 0, options.rollup);
+      if (rollupFile) {
+        rollup = rollupFile;
+      }
+    } else {
+      rollup = options.rollup;
+    }
+    resolvedOptions.rollup = _defu2.default.call(void 0, _nullishCoalesce(resolvedOptions.rollup, () => ( {})), rollup);
+  }
+  resolvedOptions.hooks = {
+    "rollup:options": /* @__PURE__ */ _chunkRBSVNX4Wjs.__name.call(void 0, async (ctx, opts) => {
+      opts.plugins = await _asyncNullishCoalesce(options.plugins, async () => ( await _chunk5A3XPRPOjs.getDefaultBuildPlugins.call(void 0, options, resolvedOptions)));
+    }, "rollup:options")
+  };
+  stopwatch();
+  return resolvedOptions;
+}
+_chunkRBSVNX4Wjs.__name.call(void 0, resolveOptions, "resolveOptions");
+async function generatePackageJson(options) {
+  if (options.generatePackageJson !== false && _fs.existsSync.call(void 0, _correctpaths.joinPaths.call(void 0, options.projectRoot, "package.json"))) {
+    _console.writeDebug.call(void 0, "  \u270D\uFE0F   Writing package.json file", options.config);
+    const stopwatch = _console.getStopwatch.call(void 0, "Write package.json file");
+    const packageJsonPath = _correctpaths.joinPaths.call(void 0, options.projectRoot, "project.json");
+    if (!_fs.existsSync.call(void 0, packageJsonPath)) {
+      throw new Error("Cannot find package.json configuration");
+    }
+    let packageJsonContent = await _promises.readFile.call(void 0, _correctpaths.joinPaths.call(void 0, 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 _buildtools.addPackageDependencies.call(void 0, options.config.workspaceRoot, options.projectRoot, options.projectName, packageJson);
+    packageJson = await _buildtools.addWorkspacePackageJsonFields.call(void 0, options.config, options.projectRoot, options.sourceRoot, options.projectName, false, packageJson);
+    await _devkit.writeJsonFile.call(void 0, _correctpaths.joinPaths.call(void 0, options.outDir, "package.json"), await _buildtools.addPackageJsonExports.call(void 0, options.sourceRoot, packageJson));
+    stopwatch();
+  }
+  return options;
+}
+_chunkRBSVNX4Wjs.__name.call(void 0, generatePackageJson, "generatePackageJson");
+async function resolveUnbuild(options) {
+  _console.writeTrace.call(void 0, `Resolving Unbuild package with Jiti`, options.config);
+  try {
+    return options.jiti.import("unbuild");
+  } catch (error) {
+    _console.writeError.call(void 0, "  \u274C  An error occurred while resolving the Unbuild package", options.config);
+    throw new Error("An error occurred while resolving the Unbuild package", {
+      cause: error
+    });
+  }
+}
+_chunkRBSVNX4Wjs.__name.call(void 0, resolveUnbuild, "resolveUnbuild");
+async function executeUnbuild(options) {
+  _console.writeDebug.call(void 0, `  \u{1F680}  Running ${options.name} (${options.projectRoot}) build`, options.config);
+  const stopwatch = _console.getStopwatch.call(void 0, `${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;
+}
+_chunkRBSVNX4Wjs.__name.call(void 0, executeUnbuild, "executeUnbuild");
+async function copyBuildAssets(options) {
+  _console.writeDebug.call(void 0, `  \u{1F4CB}  Copying asset files to output directory: ${options.outDir}`, options.config);
+  const stopwatch = _console.getStopwatch.call(void 0, `${options.name} asset copy`);
+  await _buildtools.copyAssets.call(void 0, options.config, _nullishCoalesce(options.assets, () => ( [])), options.outDir, options.projectRoot, options.projectName, options.sourceRoot, options.generatePackageJson, options.includeSrc);
+  stopwatch();
+  return options;
+}
+_chunkRBSVNX4Wjs.__name.call(void 0, copyBuildAssets, "copyBuildAssets");
+async function cleanOutputPath(options) {
+  if (options.clean !== false && options.outDir) {
+    await _chunkT5JY3PDFjs.clean.call(void 0, options.name, options.outDir, options.config);
+  }
+  return options;
+}
+_chunkRBSVNX4Wjs.__name.call(void 0, cleanOutputPath, "cleanOutputPath");
+async function build(options) {
+  _console.writeDebug.call(void 0, ` \u26A1  Executing Storm Unbuild pipeline`);
+  const stopwatch = _console.getStopwatch.call(void 0, "Unbuild pipeline");
+  try {
+    const resolvedOptions = await resolveOptions(options);
+    await cleanOutputPath(resolvedOptions);
+    await generatePackageJson(resolvedOptions);
+    await executeUnbuild(resolvedOptions);
+    await copyBuildAssets(resolvedOptions);
+    _console.writeSuccess.call(void 0, `  \u{1F3C1}  The ${resolvedOptions.name} build completed successfully`, resolvedOptions.config);
+  } catch (error) {
+    _console.writeFatal.call(void 0, "  \u274C  Fatal errors occurred during the build that could not be recovered from. The build process has been terminated.");
+    throw error;
+  } finally {
+    stopwatch();
+  }
+}
+_chunkRBSVNX4Wjs.__name.call(void 0, build, "build");
+
+
+
+exports.build = build;

package/dist/chunk-NOVWJHZD.mjs

@@ -0,0 +1,6 @@
+import {
+  init_esm_shims
+} from "./chunk-3TNHGERR.mjs";
+
+// src/types.ts
+init_esm_shims();

package/dist/{chunk-FDF3FMZP.mjs → chunk-OUDNDBMR.mjs}

@@ -1,11 +1,11 @@
 import {
-  writeInfo
-} from "./chunk-B5GGHMTB.mjs";
-import {
-  __name
-} from "./chunk-LPEX4YW6.mjs";
+  __name,
+  init_esm_shims
+} from "./chunk-3TNHGERR.mjs";
 
 // src/plugins/analyze.ts
+init_esm_shims();
+import { writeInfo } from "@storm-software/config-tools";
 var formatBytes = /* @__PURE__ */ __name((bytes) => {
   if (bytes === 0) return "0 Byte";
   const k = 1e3;

package/dist/{chunk-RUNO4F6F.js → chunk-P6LWSWAQ.js}

@@ -1,8 +1,10 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunk4WKFVYTIjs = require('./chunk-4WKFVYTI.js');
+
+var _chunkRBSVNX4Wjs = require('./chunk-RBSVNX4W.js');
 
 // src/plugins/type-definitions.ts
+_chunkRBSVNX4Wjs.init_cjs_shims.call(void 0, );
 var _path = require('path');
 function typeDefinitions(projectRoot) {
   return {
@@ -31,7 +33,7 @@ export { default } from ${relativeSourceDtsName};
     }
   };
 }
-_chunk4WKFVYTIjs.__name.call(void 0, typeDefinitions, "typeDefinitions");
+_chunkRBSVNX4Wjs.__name.call(void 0, typeDefinitions, "typeDefinitions");