@storm-software/workspace-tools 1.30.8 → 1.30.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@storm-software/workspace-tools",
-  "version": "1.30.8",
+  "version": "1.30.10",
   "private": false,
   "description": "⚡ A Nx plugin package that contains various executors and generators used in a Storm workspaces.",
   "keywords": [

package/src/executors/tsup/executor.js

@@ -60929,7 +60929,7 @@ var require_Options_gen_types = __commonJS({
       compiledFilename: "string"
     });
     exports.SourceMapOptions = SourceMapOptions;
-    var Options3 = t.iface([], {
+    var Options2 = t.iface([], {
       transforms: t.array("Transform"),
       disableESTransforms: t.opt("boolean"),
       jsxRuntime: t.opt(t.union(t.lit("classic"), t.lit("automatic"), t.lit("preserve"))),
@@ -60945,7 +60945,7 @@ var require_Options_gen_types = __commonJS({
       sourceMapOptions: t.opt("SourceMapOptions"),
       filePath: t.opt("string")
     });
-    exports.Options = Options3;
+    exports.Options = Options2;
     var exportedTypeSuite = {
       Transform: exports.Transform,
       SourceMapOptions: exports.SourceMapOptions,
@@ -112784,7 +112784,7 @@ glob.glob = glob;
 var import_fileutils = require("nx/src/utils/fileutils");
 var import_path3 = require("path");
 var import_prettier = require("prettier");
-var import_tsup2 = __toESM(require_dist5());
+var import_tsup = __toESM(require_dist5());
 var ts = __toESM(require("typescript"));
 
 // packages/config-tools/src/config-file/get-config-file.ts
@@ -116959,7 +116959,6 @@ function getExternalDependencies(projectName, graph) {
 
 // packages/workspace-tools/src/executors/tsup/get-config.ts
 var import_devkit = __toESM(require_devkit());
-var import_tsup = __toESM(require_dist5());
 function modernConfig({
   entry,
   outDir,
@@ -116996,7 +116995,7 @@ function modernConfig({
       "ios15",
       "opera77",
       "esnext"
-    ] : ["esnext", "node18"],
+    ] : ["esnext", "node"],
     tsconfig,
     splitting,
     generatePackageJson,
@@ -117113,139 +117112,21 @@ function legacyConfig({
     outExtension
   };
 }
-function workerConfig({
-  entry,
-  outDir,
-  projectRoot,
-  workspaceRoot,
-  tsconfig = "tsconfig.json",
-  splitting,
-  treeshake,
-  debug = false,
-  external,
-  banner = {},
-  verbose = false,
-  apiReport = true,
-  docModel = true,
-  tsdocMetadata = true,
-  shims = true,
-  define: define2,
-  env,
-  plugins,
-  generatePackageJson,
-  dtsTsConfig
-}) {
-  let outputPath = (0, import_devkit.joinPathFragments)(outDir, "dist");
-  return {
-    name: "worker",
-    entry,
-    format: ["esm"],
-    target: ["chrome95"],
-    bundle: true,
-    tsconfig,
-    splitting,
-    generatePackageJson,
-    treeshake: treeshake ? {
-      preset: "recommended"
-    } : false,
-    projectRoot,
-    workspaceRoot,
-    outDir: outputPath,
-    silent: !verbose,
-    metafile: true,
-    shims,
-    external,
-    platform: "browser",
-    banner,
-    define: define2,
-    env,
-    dts: false,
-    experimentalDts: {
-      entry,
-      compilerOptions: {
-        ...dtsTsConfig,
-        options: {
-          ...dtsTsConfig.options,
-          outDir: outputPath
-        }
-      }
-    },
-    minify: debug ? false : "terser",
-    terserOptions: {
-      compress: true,
-      ecma: 2020,
-      keep_classnames: true,
-      keep_fnames: true
-    },
-    apiReport,
-    docModel,
-    tsdocMetadata,
-    sourcemap: debug,
-    clean: false,
-    tsconfigDecoratorMetadata: true,
-    plugins,
-    outExtension
-  };
-}
-function getConfig(workspaceRoot, projectRoot, sourceRoot, {
+function getConfig(workspaceRoot, projectRoot, getConfigFn, {
   outputPath,
   tsConfig,
   additionalEntryPoints,
   platform,
-  emitOnAll = true,
   ...rest
 }) {
-  const entryPoints = [];
-  if (rest.entry) {
-    entryPoints.push(rest.entry);
-  }
-  if (emitOnAll !== false) {
-    entryPoints.push((0, import_devkit.joinPathFragments)(sourceRoot, "**/*.{ts,tsx}"));
-  }
-  if (additionalEntryPoints) {
-    entryPoints.push(...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_devkit.joinPathFragments)(
-      filePath.path,
-      removeExtension(filePath.name)
-    ).replaceAll("\\", "/").replaceAll(formattedPath, "").replaceAll(sourceRoot, "").replaceAll(projectRoot, "");
-    if (propertyKey) {
-      while (propertyKey.startsWith("/")) {
-        propertyKey = propertyKey.substring(1);
-      }
-      console.debug(
-        `Trying to add entry point ${propertyKey} at "${(0, import_devkit.joinPathFragments)(
-          filePath.path,
-          filePath.name
-        )}"`
-      );
-      if (!(propertyKey in ret)) {
-        ret[propertyKey] = (0, import_devkit.joinPathFragments)(filePath.path, filePath.name);
-      }
-    }
-    return ret;
-  }, {});
-  const params = {
+  return getConfigFn({
     ...rest,
-    entry,
     outDir: outputPath,
     tsconfig: tsConfig,
     workspaceRoot,
     projectRoot,
-    sourceRoot,
     platform
-  };
-  if (platform === "worker") {
-    return (0, import_tsup.defineConfig)(workerConfig(params));
-  }
-  return (0, import_tsup.defineConfig)([modernConfig(params), legacyConfig(params)]);
+  });
 }
 var outExtension = ({ format: format2 }) => {
   let jsExtension = ".js";
@@ -117402,20 +117283,57 @@ ${externalDependencies.map((dep) => {
       arrowParens: "avoid",
       endOfLine: "lf"
     };
+    const entryPoints = [];
+    if (options.entry) {
+      entryPoints.push(options.entry);
+    }
+    if (options.emitOnAll !== false) {
+      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);
+        }
+        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;
+    }, {});
     if (options.generatePackageJson !== false) {
       const projectGraph = (0, import_devkit2.readCachedProjectGraph)();
       const pathToPackageJson = (0, import_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" };
       delete packageJson.dependencies;
-      externalDependencies.forEach((entry) => {
-        const packageConfig = entry.node.data;
-        if (packageConfig?.packageName && !!(projectGraph.externalNodes[entry.node.name]?.type === "npm")) {
+      externalDependencies.forEach((externalDependency) => {
+        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]) {
             return;
           }
           packageJson.dependencies ??= {};
-          packageJson.dependencies[packageName] = !!projectGraph.nodes[entry.node.name] ? "latest" : version;
+          packageJson.dependencies[packageName] = !!projectGraph.nodes[externalDependency.node.name] ? "latest" : version;
         }
       });
       internalDependencies.forEach((packageName) => {
@@ -117437,20 +117355,6 @@ ${externalDependencies.map((dep) => {
             types: "./dist/modern/index.d.ts",
             default: "./dist/modern/index.js"
           },
-          "./*": {
-            "import": {
-              types: "./dist/modern/index.d.ts",
-              default: "./dist/modern/**/*.js"
-            },
-            require: {
-              types: "./dist/modern/index.d.cts",
-              default: "./dist/modern/**/*.cjs"
-            },
-            "default": {
-              types: "./dist/modern/index.d.ts",
-              default: "./dist/modern/**/*.js"
-            }
-          },
           ...(options.additionalEntryPoints ?? []).map((entryPoint) => ({
             [removeExtension(entryPoint).replace(sourceRoot, "")]: {
               types: (0, import_path3.join)(
@@ -117466,6 +117370,30 @@ ${externalDependencies.map((dep) => {
         },
         "./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: `./dist/modern/${key}.d.ts`,
+                default: `./dist/modern/${key}.js`
+              },
+              require: {
+                types: `./dist/modern/${key}.d.cts`,
+                default: `./dist/modern/${key}.cjs`
+              },
+              default: {
+                types: `./dist/modern/${key}.d.ts`,
+                default: `./dist/modern/${key}.js`
+              }
+            };
+          }
+          return ret;
+        },
+        packageJson.exports
+      );
       packageJson.funding ??= workspacePackageJson.funding;
       packageJson.types ??= "dist/legacy/index.d.ts";
       packageJson.typings ??= "dist/legacy/index.d.ts";
@@ -117552,45 +117480,57 @@ ${(0, import_fs3.readFileSync)(file, "utf-8")}`,
       })
     );
     options.plugins.push(environmentPlugin(stormEnv));
-    const config = getConfig(context.root, projectRoot, sourceRoot, {
-      ...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: []
-            },
+    const config = (0, import_tsup.defineConfig)([
+      ...Object.keys(entry).reduce((ret, key) => {
+        const getConfigOptions = {
+          ...options,
+          define: {
+            __STORM_CONFIG: JSON.stringify(stormEnv)
+          },
+          env: {
+            __STORM_CONFIG: JSON.stringify(stormEnv),
+            ...stormEnv
+          },
+          dtsTsConfig: getNormalizedTsConfig(
             context.root,
-            sourceRoot,
-            workspaceRoot
+            options.outputPath,
+            (0, import_tsc.createTypeScriptCompilationOptions)(
+              (0, import_normalize_options.normalizeOptions)(
+                {
+                  ...options,
+                  watch: false,
+                  main: entry[key],
+                  transformers: []
+                },
+                context.root,
+                sourceRoot,
+                workspaceRoot
+              ),
+              context
+            )
           ),
-          context
-        )
-      ),
-      banner: options.banner ? {
-        js: `${options.banner}
+          banner: options.banner ? {
+            js: `${options.banner}
 
 `,
-        css: `/* 
+            css: `/* 
 ${options.banner}
  */
 
 `
-      } : void 0,
-      outputPath: options.outputPath
-    });
+          } : void 0,
+          outputPath: options.outputPath,
+          entry: entry[key]
+        };
+        ret.push(
+          getConfig(context.root, projectRoot, legacyConfig, getConfigOptions)
+        );
+        ret.push(
+          getConfig(context.root, projectRoot, modernConfig, getConfigOptions)
+        );
+        return ret;
+      }, [])
+    ]);
     if (typeof config === "function") {
       await build(await Promise.resolve(config({})));
     } else {
@@ -117640,9 +117580,9 @@ function getNormalizedTsConfig(workspaceRoot, outputPath, options) {
 var build = async (options) => {
   Array.isArray(options) ? options.length > 0 ? options[0].silent : false : options.silent && console.log("\u2699\uFE0F  Tsup build config: \n", options, "\n");
   if (Array.isArray(options)) {
-    await Promise.all(options.map((buildOptions) => (0, import_tsup2.build)(buildOptions)));
+    await Promise.all(options.map((buildOptions) => (0, import_tsup.build)(buildOptions)));
   } else {
-    await (0, import_tsup2.build)(options);
+    await (0, import_tsup.build)(options);
   }
 };
 var isPrimitive = (value) => {