@storm-software/workspace-tools 1.43.5 → 1.43.6

package/src/executors/tsup-node/executor.js

@@ -47246,8 +47246,8 @@ var require_dist2 = __commonJS({
       loadTsConfig: () => loadTsConfig2
     });
     module2.exports = __toCommonJS2(src_exports);
-    var import_path4 = __toESM2(require("path"), 1);
-    var import_fs4 = __toESM2(require("fs"), 1);
+    var import_path2 = __toESM2(require("path"), 1);
+    var import_fs2 = __toESM2(require("fs"), 1);
     var singleComment = Symbol("singleComment");
     var multiComment = Symbol("multiComment");
     var stripWithoutWhitespace = () => "";
@@ -47342,29 +47342,29 @@ var require_dist2 = __commonJS({
       }
     }
     var req = false ? createRequire(import_meta.url) : require;
-    var findUp = (name, startDir, stopDir = import_path4.default.parse(startDir).root) => {
+    var findUp = (name, startDir, stopDir = import_path2.default.parse(startDir).root) => {
       let dir = startDir;
       while (dir !== stopDir) {
-        const file = import_path4.default.join(dir, name);
-        if (import_fs4.default.existsSync(file))
+        const file = import_path2.default.join(dir, name);
+        if (import_fs2.default.existsSync(file))
           return file;
         if (!file.endsWith(".json")) {
           const fileWithExt = file + ".json";
-          if (import_fs4.default.existsSync(fileWithExt))
+          if (import_fs2.default.existsSync(fileWithExt))
             return fileWithExt;
         }
-        dir = import_path4.default.dirname(dir);
+        dir = import_path2.default.dirname(dir);
       }
       return null;
     };
     var resolveTsConfigFromFile = (cwd, filename) => {
-      if (import_path4.default.isAbsolute(filename))
-        return import_fs4.default.existsSync(filename) ? filename : null;
+      if (import_path2.default.isAbsolute(filename))
+        return import_fs2.default.existsSync(filename) ? filename : null;
       return findUp(filename, cwd);
     };
     var resolveTsConfigFromExtends = (cwd, name) => {
-      if (import_path4.default.isAbsolute(name))
-        return import_fs4.default.existsSync(name) ? name : null;
+      if (import_path2.default.isAbsolute(name))
+        return import_fs2.default.existsSync(name) ? name : null;
       if (name.startsWith("."))
         return findUp(name, cwd);
       const id = req.resolve(name, { paths: [cwd] });
@@ -47372,14 +47372,14 @@ var require_dist2 = __commonJS({
     };
     var loadTsConfigInternal = (dir = process.cwd(), name = "tsconfig.json", isExtends = false) => {
       var _a, _b;
-      dir = import_path4.default.resolve(dir);
+      dir = import_path2.default.resolve(dir);
       const id = isExtends ? resolveTsConfigFromExtends(dir, name) : resolveTsConfigFromFile(dir, name);
       if (!id)
         return null;
-      const data = jsoncParse(import_fs4.default.readFileSync(id, "utf-8"));
-      const configDir = import_path4.default.dirname(id);
+      const data = jsoncParse(import_fs2.default.readFileSync(id, "utf-8"));
+      const configDir = import_path2.default.dirname(id);
       if ((_a = data.compilerOptions) == null ? void 0 : _a.baseUrl) {
-        data.compilerOptions.baseUrl = import_path4.default.join(
+        data.compilerOptions.baseUrl = import_path2.default.join(
           configDir,
           data.compilerOptions.baseUrl
         );
@@ -47456,17 +47456,17 @@ var require_dist3 = __commonJS({
       tsconfigPathsToRegExp: () => tsconfigPathsToRegExp
     });
     module2.exports = __toCommonJS2(src_exports);
-    var import_fs22 = __toESM2(require("fs"), 1);
-    var import_path22 = __toESM2(require("path"), 1);
+    var import_fs2 = __toESM2(require("fs"), 1);
+    var import_path2 = __toESM2(require("path"), 1);
     var import_url3 = require("url");
     var import_esbuild = require("esbuild");
     var import_load_tsconfig = require_dist2();
-    var import_fs4 = __toESM2(require("fs"), 1);
-    var import_path4 = __toESM2(require("path"), 1);
+    var import_fs3 = __toESM2(require("fs"), 1);
+    var import_path3 = __toESM2(require("path"), 1);
     var getPkgType = () => {
       try {
         const pkg = JSON.parse(
-          import_fs4.default.readFileSync(import_path4.default.resolve("package.json"), "utf-8")
+          import_fs3.default.readFileSync(import_path3.default.resolve("package.json"), "utf-8")
         );
         return pkg.type;
       } catch (error) {
@@ -47475,7 +47475,7 @@ var require_dist3 = __commonJS({
     function guessFormat(inputFile) {
       if (!usingDynamicImport)
         return "cjs";
-      const ext2 = import_path4.default.extname(inputFile);
+      const ext2 = import_path3.default.extname(inputFile);
       const type = getPkgType();
       if (ext2 === ".js") {
         return type === "module" ? "esm" : "cjs";
@@ -47532,7 +47532,7 @@ var require_dist3 = __commonJS({
         name: "bundle-require:external",
         setup(ctx) {
           ctx.onResolve({ filter: /.*/ }, async (args) => {
-            if (args.path[0] === "." || import_path22.default.isAbsolute(args.path)) {
+            if (args.path[0] === "." || import_path2.default.isAbsolute(args.path)) {
               return;
             }
             if (match2(args.path, external)) {
@@ -47561,11 +47561,11 @@ var require_dist3 = __commonJS({
             "import.meta.url": IMPORT_META_URL_VAR_NAME
           };
           ctx.onLoad({ filter: JS_EXT_RE }, async (args) => {
-            const contents = await import_fs22.default.promises.readFile(args.path, "utf-8");
+            const contents = await import_fs2.default.promises.readFile(args.path, "utf-8");
             const injectLines = [
               `const ${FILENAME_VAR_NAME} = ${JSON.stringify(args.path)};`,
               `const ${DIRNAME_VAR_NAME} = ${JSON.stringify(
-                import_path22.default.dirname(args.path)
+                import_path2.default.dirname(args.path)
               )};`,
               `const ${IMPORT_META_URL_VAR_NAME} = ${JSON.stringify(
                 (0, import_url3.pathToFileURL)(args.path).href
@@ -47573,7 +47573,7 @@ var require_dist3 = __commonJS({
             ];
             return {
               contents: injectLines.join("") + contents,
-              loader: inferLoader(import_path22.default.extname(args.path))
+              loader: inferLoader(import_path2.default.extname(args.path))
             };
           });
         }
@@ -47599,7 +47599,7 @@ var require_dist3 = __commonJS({
           const { text } = result.outputFiles[0];
           const getOutputFile = options.getOutputFile || defaultGetOutputFile;
           const outfile = getOutputFile(options.filepath, format2);
-          await import_fs22.default.promises.writeFile(outfile, text, "utf8");
+          await import_fs2.default.promises.writeFile(outfile, text, "utf8");
           let mod;
           const req = options.require || dynamicImport;
           try {
@@ -47609,7 +47609,7 @@ var require_dist3 = __commonJS({
             );
           } finally {
             if (!preserveTemporaryFile) {
-              await import_fs22.default.promises.unlink(outfile);
+              await import_fs2.default.promises.unlink(outfile);
             }
           }
           return {
@@ -126392,17 +126392,17 @@ var LogLevelLabel = {
 };
 
 // packages/config-tools/src/utilities/find-up.ts
-var import_fs = require("fs");
-var import_path = require("path");
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
 var MAX_PATH_SEARCH_DEPTH = 30;
 var depth = 0;
 function findFolderUp(startPath, endFileNames) {
   const _startPath = startPath ?? process.cwd();
-  if (endFileNames.some((endFileName) => (0, import_fs.existsSync)((0, import_path.join)(_startPath, endFileName)))) {
+  if (endFileNames.some((endFileName) => (0, import_node_fs.existsSync)((0, import_node_path.join)(_startPath, endFileName)))) {
     return _startPath;
   }
   if (_startPath !== "/" && depth++ < MAX_PATH_SEARCH_DEPTH) {
-    const parent = (0, import_path.join)(_startPath, "..");
+    const parent = (0, import_node_path.join)(_startPath, "..");
     return findFolderUp(parent, endFileNames);
   }
   return void 0;
@@ -126461,8 +126461,8 @@ Path: ${pathInsideMonorepo ? pathInsideMonorepo : process.cwd()}`
 }
 
 // packages/config-tools/src/utilities/get-default-config.ts
-var import_fs2 = require("fs");
-var import_path2 = require("path");
+var import_node_fs2 = require("node:fs");
+var import_node_path2 = require("node:path");
 
 // node_modules/.pnpm/zod@3.22.4/node_modules/zod/lib/index.mjs
 var util;
@@ -130131,8 +130131,8 @@ var getDefaultConfig = (config = {}, root) => {
   let license = DefaultStormConfig.license;
   let homepage = DefaultStormConfig.homepage;
   const workspaceRoot = findWorkspaceRoot(root);
-  if ((0, import_fs2.existsSync)((0, import_path2.join)(workspaceRoot, "package.json"))) {
-    const file = (0, import_fs2.readFileSync)((0, import_path2.join)(workspaceRoot, "package.json"), {
+  if ((0, import_node_fs2.existsSync)((0, import_node_path2.join)(workspaceRoot, "package.json"))) {
+    const file = (0, import_node_fs2.readFileSync)((0, import_node_path2.join)(workspaceRoot, "package.json"), {
       encoding: "utf-8"
     });
     if (file) {
@@ -130501,16 +130501,6 @@ var setConfigEnv = (config) => {
   }
 };
 
-// packages/config-tools/src/utilities/prepare-workspace.ts
-var prepareWorkspace = async () => {
-  const _STORM_CONFIG = getDefaultConfig({
-    ...await getConfigFile(),
-    ...getConfigEnv()
-  });
-  setConfigEnv(_STORM_CONFIG);
-  return _STORM_CONFIG;
-};
-
 // packages/config-tools/src/env/get-env.ts
 var getExtensionEnv = (extensionName) => {
   const prefix = `STORM_EXTENSION_${extensionName.toUpperCase()}_`;
@@ -130578,6 +130568,32 @@ var getConfigEnv = () => {
   }, config);
 };
 
+// packages/config-tools/src/create-storm-config.ts
+var loadStormConfig = async (workspaceRoot) => {
+  let config = {};
+  let _workspaceRoot = workspaceRoot;
+  if (!_workspaceRoot) {
+    _workspaceRoot = findWorkspaceRoot();
+  }
+  const configFile = await getDefaultConfig(
+    {
+      ...await getConfigFile(_workspaceRoot),
+      ...getConfigEnv()
+    },
+    _workspaceRoot
+  );
+  if (configFile) {
+    config = StormConfigSchema.parse(configFile);
+  } else {
+    writeWarning(
+      config,
+      "No Storm config file found in the current workspace. Please ensure this is the expected behavior - you can add a `storm.config.js` file to the root of your workspace if it is not."
+    );
+  }
+  setConfigEnv(config);
+  return config;
+};
+
 // packages/workspace-tools/src/utils/get-workspace-root.ts
 var import_find_workspace_root2 = require("nx/src/utils/find-workspace-root.js");
 var getWorkspaceRoot = () => {
@@ -130690,7 +130706,7 @@ var withRunExecutor = (name, executorFn, executorOptions) => async (_options, co
  - projectName: ${projectName}
 `
       );
-      config = await prepareWorkspace();
+      config = await loadStormConfig(workspaceRoot);
       writeTrace(
         config,
         `Loaded Storm config into env: 
@@ -130791,9 +130807,9 @@ ${commentStart} ----------------------------------------------------------------
 };
 
 // packages/workspace-tools/src/executors/tsup/executor.ts
-var import_node_fs = require("node:fs");
+var import_node_fs3 = require("node:fs");
 var import_promises2 = require("node:fs/promises");
-var import_node_path = require("node:path");
+var import_node_path3 = require("node:path");
 var import_esbuild_decorators = __toESM(require_src());
 var import_devkit2 = __toESM(require_devkit());
 var import_js = __toESM(require_src2());
@@ -133404,10 +133420,10 @@ var LRUCache = class _LRUCache {
 };
 
 // node_modules/.pnpm/path-scurry@1.10.1/node_modules/path-scurry/dist/mjs/index.js
-var import_path3 = require("path");
+var import_path = require("path");
 var import_url = require("url");
 var actualFS = __toESM(require("fs"), 1);
-var import_fs3 = require("fs");
+var import_fs = require("fs");
 var import_promises = require("fs/promises");
 
 // node_modules/.pnpm/minipass@7.0.4/node_modules/minipass/dist/esm/index.js
@@ -134289,12 +134305,12 @@ var Minipass = class extends import_events.EventEmitter {
 };
 
 // node_modules/.pnpm/path-scurry@1.10.1/node_modules/path-scurry/dist/mjs/index.js
-var realpathSync = import_fs3.realpathSync.native;
+var realpathSync = import_fs.realpathSync.native;
 var defaultFS = {
-  lstatSync: import_fs3.lstatSync,
-  readdir: import_fs3.readdir,
-  readdirSync: import_fs3.readdirSync,
-  readlinkSync: import_fs3.readlinkSync,
+  lstatSync: import_fs.lstatSync,
+  readdir: import_fs.readdir,
+  readdirSync: import_fs.readdirSync,
+  readlinkSync: import_fs.readlinkSync,
   realpathSync,
   promises: {
     lstat: import_promises.lstat,
@@ -135290,7 +135306,7 @@ var PathWin32 = class _PathWin32 extends PathBase {
    * @internal
    */
   getRootString(path2) {
-    return import_path3.win32.parse(path2).root;
+    return import_path.win32.parse(path2).root;
   }
   /**
    * @internal
@@ -135930,7 +135946,7 @@ var PathScurryWin32 = class extends PathScurryBase {
   sep = "\\";
   constructor(cwd = process.cwd(), opts = {}) {
     const { nocase = true } = opts;
-    super(cwd, import_path3.win32, "\\", { ...opts, nocase });
+    super(cwd, import_path.win32, "\\", { ...opts, nocase });
     this.nocase = nocase;
     for (let p = this.cwd; p; p = p.parent) {
       p.nocase = this.nocase;
@@ -135940,7 +135956,7 @@ var PathScurryWin32 = class extends PathScurryBase {
    * @internal
    */
   parseRootPath(dir) {
-    return import_path3.win32.parse(dir).root.toUpperCase();
+    return import_path.win32.parse(dir).root.toUpperCase();
   }
   /**
    * @internal
@@ -135962,7 +135978,7 @@ var PathScurryPosix = class extends PathScurryBase {
   sep = "/";
   constructor(cwd = process.cwd(), opts = {}) {
     const { nocase = false } = opts;
-    super(cwd, import_path3.posix, "/", { ...opts, nocase });
+    super(cwd, import_path.posix, "/", { ...opts, nocase });
     this.nocase = nocase;
   }
   /**
@@ -137158,416 +137174,405 @@ var getTypiaTransform = (program, diagnostics) => (0, import_transform.default)(
 
 // packages/workspace-tools/src/executors/tsup/executor.ts
 async function tsupExecutorFn(options, context, config) {
-  try {
-    writeInfo(config, "\u{1F4E6}  Running Storm build executor on the workspace");
-    getLogLevel(config?.logLevel) >= LogLevel.TRACE && writeDebug(
-      config,
-      `\u2699\uFE0F  Executor options:
+  writeInfo(config, "\u{1F4E6}  Running Storm build executor on the workspace");
+  getLogLevel(config?.logLevel) >= LogLevel.TRACE && writeDebug(
+    config,
+    `\u2699\uFE0F  Executor options:
 ${Object.keys(options).map(
-        (key) => `${key}: ${!options[key] || _isPrimitive(options[key]) ? options[key] : JSON.stringify(options[key])}`
-      ).join("\n")}
+      (key) => `${key}: ${!options[key] || _isPrimitive(options[key]) ? options[key] : JSON.stringify(options[key])}`
+    ).join("\n")}
 `
+  );
+  if (!context.projectsConfigurations?.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."
     );
-    if (!context.projectsConfigurations?.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."
-      );
-    }
-    const workspaceRoot = getWorkspaceRoot();
-    const projectRoot = context.projectsConfigurations.projects[context.projectName].root;
-    const sourceRoot = context.projectsConfigurations.projects[context.projectName].sourceRoot;
-    if (options.clean !== false) {
-      if (getLogLevel(config?.logLevel) >= LogLevel.DEBUG) {
-        writeInfo(config, `\u{1F9F9} Cleaning output path: ${options.outputPath}`);
-      }
-      (0, import_fs_extra.removeSync)(options.outputPath);
+  }
+  const workspaceRoot = getWorkspaceRoot();
+  const projectRoot = context.projectsConfigurations.projects[context.projectName].root;
+  const sourceRoot = context.projectsConfigurations.projects[context.projectName].sourceRoot;
+  if (options.clean !== false) {
+    if (getLogLevel(config?.logLevel) >= LogLevel.DEBUG) {
+      writeInfo(config, `\u{1F9F9} Cleaning output path: ${options.outputPath}`);
     }
-    const assets = Array.from(options.assets);
+    (0, import_fs_extra.removeSync)(options.outputPath);
+  }
+  const assets = Array.from(options.assets);
+  assets.push({
+    input: projectRoot,
+    glob: "*.md",
+    output: "/"
+  });
+  assets.push({
+    input: "",
+    glob: "LICENSE",
+    output: "."
+  });
+  if (options.generatePackageJson === false) {
     assets.push({
       input: projectRoot,
-      glob: "*.md",
-      output: "/"
+      glob: "**/package.json",
+      output: "."
     });
+  }
+  if (options.includeSrc === true) {
     assets.push({
-      input: "",
-      glob: "LICENSE",
-      output: "."
+      input: sourceRoot,
+      glob: "**/{*.ts,*.tsx,*.js,*.jsx}",
+      output: "src/"
     });
-    if (options.generatePackageJson === false) {
-      assets.push({
-        input: projectRoot,
-        glob: "**/package.json",
-        output: "."
-      });
-    }
-    if (options.includeSrc === true) {
-      assets.push({
-        input: sourceRoot,
-        glob: "**/{*.ts,*.tsx,*.js,*.jsx}",
-        output: "src/"
-      });
-    }
-    const result = await (0, import_js.copyAssets)(
-      { assets, watch: options.watch, outputPath: options.outputPath },
-      context
-    );
-    if (!result.success) {
-      throw new Error("The Build process failed trying to copy assets");
-    }
-    const pathToPackageJson = (0, import_node_path.join)(context.root, projectRoot, "package.json");
-    const packageJson = (0, import_fileutils.fileExists)(pathToPackageJson) ? (0, import_devkit2.readJsonFile)(pathToPackageJson) : { name: context.projectName, version: "0.0.1" };
-    const workspacePackageJson = (0, import_devkit2.readJsonFile)((0, import_node_path.join)(workspaceRoot, "package.json"));
-    options.external = options.external || [];
-    if (workspacePackageJson?.dependencies) {
-      options.external = Object.keys(workspacePackageJson?.dependencies).reduce(
-        (ret, key) => {
-          if (!ret.includes(key)) {
-            ret.push(key);
-          }
-          return ret;
-        },
-        options.external
-      );
-    }
-    const externalDependencies = options.external.reduce(
-      (ret, name) => {
-        if (!packageJson?.devDependencies?.[name]) {
-          const externalNode = context.projectGraph.externalNodes[`npm:${name}`];
-          if (externalNode) {
-            ret.push({
-              name,
-              outputs: [],
-              node: externalNode
-            });
-          }
+  }
+  const result = await (0, import_js.copyAssets)(
+    { assets, watch: options.watch, outputPath: options.outputPath },
+    context
+  );
+  if (!result.success) {
+    throw new Error("The Build process failed trying to copy assets");
+  }
+  const pathToPackageJson = (0, import_node_path3.join)(context.root, projectRoot, "package.json");
+  const packageJson = (0, import_fileutils.fileExists)(pathToPackageJson) ? (0, import_devkit2.readJsonFile)(pathToPackageJson) : { name: context.projectName, version: "0.0.1" };
+  const workspacePackageJson = (0, import_devkit2.readJsonFile)((0, import_node_path3.join)(workspaceRoot, "package.json"));
+  options.external = options.external || [];
+  if (workspacePackageJson?.dependencies) {
+    options.external = Object.keys(workspacePackageJson?.dependencies).reduce(
+      (ret, key) => {
+        if (!ret.includes(key)) {
+          ret.push(key);
         }
         return ret;
       },
-      []
+      options.external
     );
-    const implicitDependencies = context.projectsConfigurations.projects[context.projectName].implicitDependencies;
-    const internalDependencies = [];
-    const projectConfigs = await Promise.resolve(getProjectConfigurations());
-    if (getLogLevel(config?.logLevel) >= LogLevel.TRACE) {
-      writeDebug(config, "Project Configs:");
-      console.log(projectConfigs);
-    }
-    if (implicitDependencies && implicitDependencies.length > 0) {
-      options.external = implicitDependencies.reduce((ret, key) => {
-        if (getLogLevel(config?.logLevel) >= LogLevel.DEBUG) {
-          writeDebug(config, `\u26A1 Adding implicit dependency: ${key}`);
-        }
-        const projectConfig = projectConfigs[key];
-        if (projectConfig?.targets?.build) {
-          const projectPackageJson = (0, import_devkit2.readJsonFile)(projectConfig.targets?.build.options.project);
-          if (projectPackageJson?.name && !options.external.includes(projectPackageJson.name)) {
-            ret.push(projectPackageJson.name);
-            internalDependencies.push(projectPackageJson.name);
-          }
-        }
-        return ret;
-      }, options.external);
-    }
-    if (options.bundle === false) {
-      for (const thirdPartyDependency of getExternalDependencies(
-        context.projectName,
-        context.projectGraph
-      )) {
-        const packageConfig = thirdPartyDependency.node.data;
-        if (packageConfig?.packageName) {
-          options.external.push(packageConfig.packageName);
-          if (!packageJson?.devDependencies?.[packageConfig.packageName]) {
-            externalDependencies.push(thirdPartyDependency);
-          }
+  }
+  const externalDependencies = options.external.reduce(
+    (ret, name) => {
+      if (!packageJson?.devDependencies?.[name]) {
+        const externalNode = context.projectGraph.externalNodes[`npm:${name}`];
+        if (externalNode) {
+          ret.push({
+            name,
+            outputs: [],
+            node: externalNode
+          });
         }
       }
-    }
-    if (getLogLevel(config?.logLevel) >= LogLevel.TRACE) {
-      console.log(`Building with the following dependencies marked as external:
-${externalDependencies.map((dep) => {
-        return `name: ${dep.name}, node: ${dep.node}, outputs: ${dep.outputs}`;
-      }).join("\n")}`);
-    }
-    const prettierOptions = {
-      plugins: ["prettier-plugin-packagejson"],
-      trailingComma: "none",
-      tabWidth: 2,
-      semi: true,
-      singleQuote: false,
-      quoteProps: "preserve",
-      insertPragma: false,
-      bracketSameLine: true,
-      printWidth: 80,
-      bracketSpacing: true,
-      arrowParens: "avoid",
-      endOfLine: "lf"
-    };
-    const entryPoints = [];
-    if (options.entry) {
-      entryPoints.push(options.entry);
-    }
-    if (options.emitOnAll === true) {
-      entryPoints.push((0, import_devkit2.joinPathFragments)(sourceRoot, "**/*.{ts,tsx}"));
-    }
-    if (options.additionalEntryPoints) {
-      entryPoints.push(...options.additionalEntryPoints);
-    }
-    const entry = globSync(entryPoints, {
-      withFileTypes: true
-    }).reduce((ret, filePath) => {
-      let formattedPath = workspaceRoot.replaceAll("\\", "/");
-      if (formattedPath.toUpperCase().startsWith("C:")) {
-        formattedPath = formattedPath.substring(2);
-      }
-      let propertyKey = (0, import_devkit2.joinPathFragments)(filePath.path, removeExtension(filePath.name)).replaceAll("\\", "/").replaceAll(formattedPath, "").replaceAll(sourceRoot, "").replaceAll(projectRoot, "");
-      if (propertyKey) {
-        while (propertyKey.startsWith("/")) {
-          propertyKey = propertyKey.substring(1);
-        }
-        if (getLogLevel(config?.logLevel) >= LogLevel.DEBUG) {
-          console.debug(
-            `Trying to add entry point ${propertyKey} at "${(0, import_devkit2.joinPathFragments)(
-              filePath.path,
-              filePath.name
-            )}"`
-          );
-        }
-        if (!(propertyKey in ret)) {
-          ret[propertyKey] = (0, import_devkit2.joinPathFragments)(filePath.path, filePath.name);
+      return ret;
+    },
+    []
+  );
+  const implicitDependencies = context.projectsConfigurations.projects[context.projectName].implicitDependencies;
+  const internalDependencies = [];
+  const projectConfigs = await Promise.resolve(getProjectConfigurations());
+  if (getLogLevel(config?.logLevel) >= LogLevel.TRACE) {
+    writeDebug(config, "Project Configs:");
+    console.log(projectConfigs);
+  }
+  if (implicitDependencies && implicitDependencies.length > 0) {
+    options.external = implicitDependencies.reduce((ret, key) => {
+      if (getLogLevel(config?.logLevel) >= LogLevel.DEBUG) {
+        writeDebug(config, `\u26A1 Adding implicit dependency: ${key}`);
+      }
+      const projectConfig = projectConfigs[key];
+      if (projectConfig?.targets?.build) {
+        const projectPackageJson = (0, import_devkit2.readJsonFile)(projectConfig.targets?.build.options.project);
+        if (projectPackageJson?.name && !options.external.includes(projectPackageJson.name)) {
+          ret.push(projectPackageJson.name);
+          internalDependencies.push(projectPackageJson.name);
         }
       }
       return ret;
-    }, {});
-    if (options.generatePackageJson !== false) {
-      const projectGraph = (0, import_devkit2.readCachedProjectGraph)();
-      packageJson.dependencies = void 0;
-      for (const externalDependency of externalDependencies) {
-        const packageConfig = externalDependency.node.data;
-        if (packageConfig?.packageName && !!(projectGraph.externalNodes[externalDependency.node.name]?.type === "npm")) {
-          const { packageName, version } = packageConfig;
-          if (workspacePackageJson.dependencies?.[packageName] || workspacePackageJson.devDependencies?.[packageName] || packageJson?.devDependencies?.[packageName]) {
-            return null;
-          }
-          packageJson.dependencies ??= {};
-          packageJson.dependencies[packageName] = projectGraph.nodes[externalDependency.node.name] ? "latest" : version;
+    }, options.external);
+  }
+  if (options.bundle === false) {
+    for (const thirdPartyDependency of getExternalDependencies(
+      context.projectName,
+      context.projectGraph
+    )) {
+      const packageConfig = thirdPartyDependency.node.data;
+      if (packageConfig?.packageName) {
+        options.external.push(packageConfig.packageName);
+        if (!packageJson?.devDependencies?.[packageConfig.packageName]) {
+          externalDependencies.push(thirdPartyDependency);
         }
       }
-      for (const packageName of internalDependencies) {
-        if (!packageJson?.devDependencies?.[packageName]) {
-          packageJson.dependencies ??= {};
-          packageJson.dependencies[packageName] = "latest";
+    }
+  }
+  writeTrace(
+    config,
+    `Building with the following dependencies marked as external:
+${externalDependencies.map((dep) => {
+      return `name: ${dep.name}, node: ${dep.node}, outputs: ${dep.outputs}`;
+    }).join("\n")}`
+  );
+  const prettierOptions = {
+    plugins: ["prettier-plugin-packagejson"],
+    trailingComma: "none",
+    tabWidth: 2,
+    semi: true,
+    singleQuote: false,
+    quoteProps: "preserve",
+    insertPragma: false,
+    bracketSameLine: true,
+    printWidth: 80,
+    bracketSpacing: true,
+    arrowParens: "avoid",
+    endOfLine: "lf"
+  };
+  const entryPoints = [];
+  if (options.entry) {
+    entryPoints.push(options.entry);
+  }
+  if (options.emitOnAll === true) {
+    entryPoints.push((0, import_devkit2.joinPathFragments)(sourceRoot, "**/*.{ts,tsx}"));
+  }
+  if (options.additionalEntryPoints) {
+    entryPoints.push(...options.additionalEntryPoints);
+  }
+  const entry = globSync(entryPoints, {
+    withFileTypes: true
+  }).reduce((ret, filePath) => {
+    let formattedPath = workspaceRoot.replaceAll("\\", "/");
+    if (formattedPath.toUpperCase().startsWith("C:")) {
+      formattedPath = formattedPath.substring(2);
+    }
+    let propertyKey = (0, import_devkit2.joinPathFragments)(filePath.path, removeExtension(filePath.name)).replaceAll("\\", "/").replaceAll(formattedPath, "").replaceAll(sourceRoot, "").replaceAll(projectRoot, "");
+    if (propertyKey) {
+      while (propertyKey.startsWith("/")) {
+        propertyKey = propertyKey.substring(1);
+      }
+      writeDebug(
+        config,
+        `Trying to add entry point ${propertyKey} at "${(0, import_devkit2.joinPathFragments)(
+          filePath.path,
+          filePath.name
+        )}"`
+      );
+      if (!(propertyKey in ret)) {
+        ret[propertyKey] = (0, import_devkit2.joinPathFragments)(filePath.path, filePath.name);
+      }
+    }
+    return ret;
+  }, {});
+  if (options.generatePackageJson !== false) {
+    const projectGraph = (0, import_devkit2.readCachedProjectGraph)();
+    packageJson.dependencies = void 0;
+    for (const externalDependency of externalDependencies) {
+      const packageConfig = externalDependency.node.data;
+      if (packageConfig?.packageName && !!(projectGraph.externalNodes[externalDependency.node.name]?.type === "npm")) {
+        const { packageName, version } = packageConfig;
+        if (workspacePackageJson.dependencies?.[packageName] || workspacePackageJson.devDependencies?.[packageName] || packageJson?.devDependencies?.[packageName]) {
+          return null;
         }
+        packageJson.dependencies ??= {};
+        packageJson.dependencies[packageName] = projectGraph.nodes[externalDependency.node.name] ? "latest" : version;
       }
-      const distPaths = !options?.getConfig || _isFunction(options.getConfig) ? ["dist/"] : Object.keys(options.getConfig).map((key) => `${key}/`);
-      packageJson.type = "module";
-      if (distPaths.length > 0) {
-        packageJson.exports ??= {
-          ".": {
+    }
+    for (const packageName of internalDependencies) {
+      if (!packageJson?.devDependencies?.[packageName]) {
+        packageJson.dependencies ??= {};
+        packageJson.dependencies[packageName] = "latest";
+      }
+    }
+    const distPaths = !options?.getConfig || _isFunction(options.getConfig) ? ["dist/"] : Object.keys(options.getConfig).map((key) => `${key}/`);
+    packageJson.type = "module";
+    if (distPaths.length > 0) {
+      packageJson.exports ??= {
+        ".": {
+          import: {
+            types: `./${distPaths[0]}index.d.ts`,
+            default: `./${distPaths[0]}index.js`
+          },
+          require: {
+            types: `./${distPaths[0]}index.d.cts`,
+            default: `./${distPaths[0]}index.cjs`
+          },
+          default: {
+            types: `./${distPaths[0]}index.d.ts`,
+            default: `./${distPaths[0]}index.js`
+          },
+          ...(options.additionalEntryPoints ?? []).map((entryPoint) => ({
+            [removeExtension(entryPoint).replace(sourceRoot, "")]: {
+              types: (0, import_node_path3.join)(
+                `./${distPaths[0]}`,
+                `${removeExtension(entryPoint.replace(sourceRoot, ""))}.d.ts`
+              ),
+              default: (0, import_node_path3.join)(
+                `./${distPaths[0]}`,
+                `${removeExtension(entryPoint.replace(sourceRoot, ""))}.js`
+              )
+            }
+          }))
+        },
+        "./package.json": "./package.json"
+      };
+      packageJson.exports = Object.keys(entry).reduce((ret, key) => {
+        let packageJsonKey = key.startsWith("./") ? key : `./${key}`;
+        packageJsonKey = packageJsonKey.replaceAll("/index", "");
+        if (!ret[packageJsonKey]) {
+          ret[packageJsonKey] = {
             import: {
               types: `./${distPaths[0]}index.d.ts`,
-              default: `./${distPaths[0]}index.js`
+              default: `./${distPaths[0]}${key}.js`
             },
             require: {
               types: `./${distPaths[0]}index.d.cts`,
-              default: `./${distPaths[0]}index.cjs`
+              default: `./${distPaths[0]}${key}.cjs`
             },
             default: {
               types: `./${distPaths[0]}index.d.ts`,
-              default: `./${distPaths[0]}index.js`
-            },
-            ...(options.additionalEntryPoints ?? []).map((entryPoint) => ({
-              [removeExtension(entryPoint).replace(sourceRoot, "")]: {
-                types: (0, import_node_path.join)(
-                  `./${distPaths[0]}`,
-                  `${removeExtension(entryPoint.replace(sourceRoot, ""))}.d.ts`
-                ),
-                default: (0, import_node_path.join)(
-                  `./${distPaths[0]}`,
-                  `${removeExtension(entryPoint.replace(sourceRoot, ""))}.js`
-                )
-              }
-            }))
-          },
-          "./package.json": "./package.json"
-        };
-        packageJson.exports = Object.keys(entry).reduce((ret, key) => {
-          let packageJsonKey = key.startsWith("./") ? key : `./${key}`;
-          packageJsonKey = packageJsonKey.replaceAll("/index", "");
-          if (!ret[packageJsonKey]) {
-            ret[packageJsonKey] = {
-              import: {
-                types: `./${distPaths[0]}index.d.ts`,
-                default: `./${distPaths[0]}${key}.js`
-              },
-              require: {
-                types: `./${distPaths[0]}index.d.cts`,
-                default: `./${distPaths[0]}${key}.cjs`
-              },
-              default: {
-                types: `./${distPaths[0]}index.d.ts`,
-                default: `./${distPaths[0]}${key}.js`
-              }
-            };
-          }
-          return ret;
-        }, packageJson.exports);
-        packageJson.funding ??= workspacePackageJson.funding;
-        packageJson.types ??= `${distPaths.length > 1 ? distPaths[1] : distPaths[0]}index.d.ts`;
-        packageJson.typings ??= `${distPaths.length > 1 ? distPaths[1] : distPaths[0]}index.d.ts`;
-        packageJson.typescript ??= {
-          definition: `${distPaths.length > 1 ? distPaths[1] : distPaths[0]}index.d.ts`
-        };
-        packageJson.main ??= `${distPaths.length > 1 ? distPaths[1] : distPaths[0]}index.cjs`;
-        packageJson.module ??= `${distPaths.length > 1 ? distPaths[1] : distPaths[0]}index.js`;
-        if (options.platform && options.platform !== "node") {
-          packageJson.browser ??= `${distPaths[0]}index.global.js`;
-        }
-        if (options.includeSrc === true) {
-          let distSrc = sourceRoot.replace(projectRoot, "");
-          if (distSrc.startsWith("/")) {
-            distSrc = distSrc.substring(1);
-          }
-          packageJson.source ??= `${(0, import_node_path.join)(distSrc, "index.ts").replaceAll("\\", "/")}`;
-        }
-        packageJson.sideEffects ??= false;
-        packageJson.files ??= ["dist/**/*"];
-        if (options.includeSrc === true && !packageJson.files.includes("src")) {
-          packageJson.files.push("src/**/*");
+              default: `./${distPaths[0]}${key}.js`
+            }
+          };
         }
-      }
-      packageJson.publishConfig ??= {
-        access: "public"
-      };
-      packageJson.description ??= workspacePackageJson.description;
-      packageJson.homepage ??= workspacePackageJson.homepage;
-      packageJson.bugs ??= workspacePackageJson.bugs;
-      packageJson.author ??= workspacePackageJson.author;
-      packageJson.license ??= workspacePackageJson.license;
-      packageJson.keywords ??= workspacePackageJson.keywords;
-      packageJson.repository ??= workspacePackageJson.repository;
-      packageJson.repository.directory ??= projectRoot ? projectRoot : (0, import_node_path.join)("packages", context.projectName);
-      const packageJsonPath = (0, import_node_path.join)(context.root, options.outputPath, "package.json");
-      if (getLogLevel(config?.logLevel) >= LogLevel.DEBUG) {
-        writeDebug(config, `\u26A1 Writing package.json file to: ${packageJsonPath}`);
-      }
-      (0, import_node_fs.writeFileSync)(
-        packageJsonPath,
-        await (0, import_prettier.format)(JSON.stringify(packageJson), {
-          ...prettierOptions,
-          parser: "json"
-        })
-      );
-    }
-    if (options.includeSrc === true) {
-      const files = globSync([
-        (0, import_devkit2.joinPathFragments)(context.root, options.outputPath, "src/**/*.ts"),
-        (0, import_devkit2.joinPathFragments)(context.root, options.outputPath, "src/**/*.tsx"),
-        (0, import_devkit2.joinPathFragments)(context.root, options.outputPath, "src/**/*.js"),
-        (0, import_devkit2.joinPathFragments)(context.root, options.outputPath, "src/**/*.jsx")
-      ]);
-      await Promise.allSettled(
-        files.map(
-          async (file) => (0, import_promises2.writeFile)(
-            file,
-            await (0, import_prettier.format)(
-              `${options.banner ? options.banner.startsWith("//") ? options.banner : `// ${options.banner}` : ""}
-
-${(0, import_node_fs.readFileSync)(file, "utf-8")}`,
-              {
-                ...prettierOptions,
-                parser: "typescript"
-              }
-            ),
-            "utf-8"
-          )
-        )
-      );
-    }
-    const stormEnv = Object.keys(options.env).filter((key) => key.startsWith("STORM_")).reduce((ret, key) => {
-      ret[key] = options.env[key];
-      return ret;
-    }, {});
-    options.plugins.push(
-      (0, import_esbuild_decorators.esbuildDecorators)({
-        tsconfig: options.tsConfig,
-        cwd: workspaceRoot
+        return ret;
+      }, packageJson.exports);
+      packageJson.funding ??= workspacePackageJson.funding;
+      packageJson.types ??= `${distPaths.length > 1 ? distPaths[1] : distPaths[0]}index.d.ts`;
+      packageJson.typings ??= `${distPaths.length > 1 ? distPaths[1] : distPaths[0]}index.d.ts`;
+      packageJson.typescript ??= {
+        definition: `${distPaths.length > 1 ? distPaths[1] : distPaths[0]}index.d.ts`
+      };
+      packageJson.main ??= `${distPaths.length > 1 ? distPaths[1] : distPaths[0]}index.cjs`;
+      packageJson.module ??= `${distPaths.length > 1 ? distPaths[1] : distPaths[0]}index.js`;
+      if (options.platform && options.platform !== "node") {
+        packageJson.browser ??= `${distPaths[0]}index.global.js`;
+      }
+      if (options.includeSrc === true) {
+        let distSrc = sourceRoot.replace(projectRoot, "");
+        if (distSrc.startsWith("/")) {
+          distSrc = distSrc.substring(1);
+        }
+        packageJson.source ??= `${(0, import_node_path3.join)(distSrc, "index.ts").replaceAll("\\", "/")}`;
+      }
+      packageJson.sideEffects ??= false;
+      packageJson.files ??= ["dist/**/*"];
+      if (options.includeSrc === true && !packageJson.files.includes("src")) {
+        packageJson.files.push("src/**/*");
+      }
+    }
+    packageJson.publishConfig ??= {
+      access: "public"
+    };
+    packageJson.description ??= workspacePackageJson.description;
+    packageJson.homepage ??= workspacePackageJson.homepage;
+    packageJson.bugs ??= workspacePackageJson.bugs;
+    packageJson.author ??= workspacePackageJson.author;
+    packageJson.license ??= workspacePackageJson.license;
+    packageJson.keywords ??= workspacePackageJson.keywords;
+    packageJson.repository ??= workspacePackageJson.repository;
+    packageJson.repository.directory ??= projectRoot ? projectRoot : (0, import_node_path3.join)("packages", context.projectName);
+    const packageJsonPath = (0, import_node_path3.join)(context.root, options.outputPath, "package.json");
+    writeDebug(config, `\u26A1 Writing package.json file to: ${packageJsonPath}`);
+    (0, import_node_fs3.writeFileSync)(
+      packageJsonPath,
+      await (0, import_prettier.format)(JSON.stringify(packageJson), {
+        ...prettierOptions,
+        parser: "json"
       })
     );
-    options.plugins.push(environmentPlugin(stormEnv));
-    const getConfigOptions = {
-      ...options,
-      define: {
-        __STORM_CONFIG: JSON.stringify(stormEnv)
-      },
-      env: {
-        __STORM_CONFIG: JSON.stringify(stormEnv),
-        ...stormEnv
-      },
-      dtsTsConfig: getNormalizedTsConfig(
-        context.root,
-        options.outputPath,
-        (0, import_tsc.createTypeScriptCompilationOptions)(
-          (0, import_normalize_options.normalizeOptions)(
+  } else {
+    writeWarning(config, "Skipping writing to package.json file");
+  }
+  if (options.includeSrc === true) {
+    const files = globSync([
+      (0, import_devkit2.joinPathFragments)(context.root, options.outputPath, "src/**/*.ts"),
+      (0, import_devkit2.joinPathFragments)(context.root, options.outputPath, "src/**/*.tsx"),
+      (0, import_devkit2.joinPathFragments)(context.root, options.outputPath, "src/**/*.js"),
+      (0, import_devkit2.joinPathFragments)(context.root, options.outputPath, "src/**/*.jsx")
+    ]);
+    await Promise.allSettled(
+      files.map(
+        async (file) => (0, import_promises2.writeFile)(
+          file,
+          await (0, import_prettier.format)(
+            `${options.banner ? options.banner.startsWith("//") ? options.banner : `// ${options.banner}` : ""}
+
+${(0, import_node_fs3.readFileSync)(file, "utf-8")}`,
             {
-              ...options,
-              watch: false,
-              main: options.entry,
-              transformers: options.skipTypia ? [] : ["typia/lib/transform"]
-            },
-            context.root,
-            sourceRoot,
-            workspaceRoot
+              ...prettierOptions,
+              parser: "typescript"
+            }
           ),
-          context
+          "utf-8"
         )
-      ),
-      banner: options.banner ? {
-        js: `${options.banner}
+      )
+    );
+  }
+  const stormEnv = Object.keys(options.env).filter((key) => key.startsWith("STORM_")).reduce((ret, key) => {
+    ret[key] = options.env[key];
+    return ret;
+  }, {});
+  options.plugins.push(
+    (0, import_esbuild_decorators.esbuildDecorators)({
+      tsconfig: options.tsConfig,
+      cwd: workspaceRoot
+    })
+  );
+  options.plugins.push(environmentPlugin(stormEnv));
+  const getConfigOptions = {
+    ...options,
+    define: {
+      __STORM_CONFIG: JSON.stringify(stormEnv)
+    },
+    env: {
+      __STORM_CONFIG: JSON.stringify(stormEnv),
+      ...stormEnv
+    },
+    dtsTsConfig: getNormalizedTsConfig(
+      context.root,
+      options.outputPath,
+      (0, import_tsc.createTypeScriptCompilationOptions)(
+        (0, import_normalize_options.normalizeOptions)(
+          {
+            ...options,
+            watch: false,
+            main: options.entry,
+            transformers: options.skipTypia ? [] : ["typia/lib/transform"]
+          },
+          context.root,
+          sourceRoot,
+          workspaceRoot
+        ),
+        context
+      )
+    ),
+    banner: options.banner ? {
+      js: `${options.banner}
 
 `,
-        css: `/* 
+      css: `/* 
 ${options.banner}
  */
 
 `
-      } : void 0,
-      outputPath: options.outputPath,
-      entry,
-      getTransform: options.skipTypia ? void 0 : getTypiaTransform
-    };
-    if (options.getConfig) {
-      if (getLogLevel(config?.logLevel) >= LogLevel.INFO) {
-        writeInfo(config, "\u26A1 Running the Build process");
-      }
-      const getConfigFns = _isFunction(options.getConfig) ? [options.getConfig] : Object.keys(options.getConfig).map((key) => options.getConfig[key]);
-      const tsupConfig = (0, import_tsup.defineConfig)(
-        getConfigFns.map(
-          (getConfigFn) => getConfig(context.root, projectRoot, getConfigFn, getConfigOptions)
-        )
-      );
-      if (_isFunction(tsupConfig)) {
-        await build(await Promise.resolve(tsupConfig({})), config);
-      } else {
-        await build(tsupConfig, config);
-      }
-    } else if (getLogLevel(config?.logLevel) >= LogLevel.WARN) {
-      writeWarning(
-        config,
-        "The Build process did not run because no `getConfig` parameter was provided"
-      );
-    }
-    if (getLogLevel(config?.logLevel) >= LogLevel.INFO) {
-      writeSuccess(config, "\u26A1 The Build process has completed successfully");
+    } : void 0,
+    outputPath: options.outputPath,
+    entry,
+    getTransform: options.skipTypia ? void 0 : getTypiaTransform
+  };
+  if (options.getConfig) {
+    writeInfo(config, "\u26A1 Running the Build process");
+    const getConfigFns = _isFunction(options.getConfig) ? [options.getConfig] : Object.keys(options.getConfig).map((key) => options.getConfig[key]);
+    const tsupConfig = (0, import_tsup.defineConfig)(
+      getConfigFns.map(
+        (getConfigFn) => getConfig(context.root, projectRoot, getConfigFn, getConfigOptions)
+      )
+    );
+    if (_isFunction(tsupConfig)) {
+      await build(await Promise.resolve(tsupConfig({})), config);
+    } else {
+      await build(tsupConfig, config);
     }
-    return {
-      success: true
-    };
-  } catch (e) {
-    console.error(e);
-    return {
-      success: false
-    };
+  } else if (getLogLevel(config?.logLevel) >= LogLevel.WARN) {
+    writeWarning(
+      config,
+      "The Build process did not run because no `getConfig` parameter was provided"
+    );
   }
+  writeSuccess(config, "\u26A1 The Build process has completed successfully");
+  return {
+    success: true
+  };
 }
 function getNormalizedTsConfig(workspaceRoot, outputPath, options) {
   const config = ts.readConfigFile(options.tsConfig, ts.sys.readFile).config;
@@ -137587,11 +137592,11 @@ function getNormalizedTsConfig(workspaceRoot, outputPath, options) {
         emitDeclarationOnly: true,
         declaration: true,
         declarationMap: true,
-        declarationDir: (0, import_node_path.join)(workspaceRoot, "tmp", ".tsup", "declaration")
+        declarationDir: (0, import_node_path3.join)(workspaceRoot, "tmp", ".tsup", "declaration")
       }
     },
     ts.sys,
-    (0, import_node_path.dirname)(options.tsConfig)
+    (0, import_node_path3.dirname)(options.tsConfig)
   );
   tsConfig.options.pathsBasePath = workspaceRoot;
   if (tsConfig.options.incremental && !tsConfig.options.tsBuildInfoFile) {