@xylabs/ts-scripts-yarn3 7.0.0-rc.9 → 7.0.0

package/dist/actions/package/index.mjs

@@ -1,3 +1,6 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
 // src/actions/package/clean-outputs.ts
 import path from "path";
 import chalk2 from "chalk";
@@ -5,12 +8,15 @@ import chalk2 from "chalk";
 // src/lib/deleteGlob.ts
 import fs from "fs";
 import { glob } from "glob";
-var deleteGlob = (globPath) => {
+var deleteGlob = /* @__PURE__ */ __name((globPath) => {
   const files = glob.sync(globPath);
   for (const file of files) {
-    fs.rmSync(file, { recursive: true, force: true });
+    fs.rmSync(file, {
+      recursive: true,
+      force: true
+    });
   }
-};
+}, "deleteGlob");
 
 // src/lib/loadConfig.ts
 import chalk from "chalk";
@@ -18,58 +24,76 @@ import { cosmiconfig } from "cosmiconfig";
 import { TypeScriptLoader } from "cosmiconfig-typescript-loader";
 import deepmerge from "deepmerge";
 var config;
-var loadConfig = async (params) => {
-  if (config) {
-    return deepmerge(config, params ?? {});
-  }
-  const cosmicConfigResult = await cosmiconfig("xy", { cache: true, loaders: { ".ts": TypeScriptLoader() } }).search();
-  config = cosmicConfigResult?.config;
-  const configFilePath = cosmicConfigResult?.filepath;
-  if (configFilePath) {
-    console.log(chalk.gray(`Loading config from ${configFilePath}`));
+var loadConfig = /* @__PURE__ */ __name(async (params) => {
+  if (config === void 0) {
+    const cosmicConfigResult = await cosmiconfig("xy", {
+      cache: true,
+      loaders: {
+        ".ts": TypeScriptLoader()
+      }
+    }).search();
+    config = cosmicConfigResult?.config;
+    const configFilePath = cosmicConfigResult?.filepath;
+    if (configFilePath !== void 0) {
+      console.log(chalk.green(`Loaded config from ${configFilePath}`));
+      if (config.verbose) {
+        console.log(chalk.gray(`${JSON.stringify(config, null, 2)}`));
+      }
+    }
   }
   return deepmerge(config, params ?? {});
-};
+}, "loadConfig");
 
 // src/actions/package/clean-outputs.ts
-var packageCleanOutputs = () => {
+var packageCleanOutputs = /* @__PURE__ */ __name(() => {
   const pkg = process.env.INIT_CWD ?? ".";
   const pkgName = process.env.npm_package_name;
-  const folders = [path.join(pkg, "dist"), path.join(pkg, "build"), path.join(pkg, "docs")];
+  const folders = [
+    path.join(pkg, "dist"),
+    path.join(pkg, "build"),
+    path.join(pkg, "docs")
+  ];
   console.log(chalk2.green(`Cleaning Outputs [${pkgName}]`));
   for (let folder of folders) {
     deleteGlob(folder);
   }
   return 0;
-};
+}, "packageCleanOutputs");
 
 // src/actions/package/clean-typescript.ts
 import path2 from "path";
 import chalk3 from "chalk";
-var packageCleanTypescript = () => {
+var packageCleanTypescript = /* @__PURE__ */ __name(() => {
   const pkg = process.env.INIT_CWD ?? ".";
   const pkgName = process.env.npm_package_name;
   console.log(chalk3.green(`Cleaning Typescript [${pkgName}]`));
-  const files = [path2.join(pkg, "*.tsbuildinfo"), path2.join(pkg, ".tsconfig.*"), path2.join(pkg, ".eslintcache")];
+  const files = [
+    path2.join(pkg, "*.tsbuildinfo"),
+    path2.join(pkg, ".tsconfig.*"),
+    path2.join(pkg, ".eslintcache")
+  ];
   for (let file of files) {
     deleteGlob(file);
   }
   return 0;
-};
+}, "packageCleanTypescript");
 
 // src/actions/package/clean.ts
-var packageClean = async () => {
-  return (await Promise.all([packageCleanOutputs(), packageCleanTypescript()])).reduce((prev, value) => prev + value, 0);
-};
+var packageClean = /* @__PURE__ */ __name(async () => {
+  return (await Promise.all([
+    packageCleanOutputs(),
+    packageCleanTypescript()
+  ])).reduce((prev, value) => prev + value, 0);
+}, "packageClean");
 
 // src/actions/package/compile/compile.ts
-import chalk5 from "chalk";
+import chalk9 from "chalk";
 
 // src/actions/package/publint.ts
 import { promises as fs2 } from "fs";
 import chalk4 from "chalk";
 import sortPackageJson from "sort-package-json";
-var packagePublint = async (params) => {
+var packagePublint = /* @__PURE__ */ __name(async (params) => {
   const pkgDir = process.env.INIT_CWD;
   const sortedPkg = sortPackageJson(await fs2.readFile(`${pkgDir}/package.json`, "utf8"));
   await fs2.writeFile(`${pkgDir}/package.json`, sortedPkg);
@@ -83,9 +107,9 @@ var packagePublint = async (params) => {
     strict: true
   });
   const { formatMessage } = await import("publint/utils");
-  const validMessage = (_message) => {
+  const validMessage = /* @__PURE__ */ __name((_message) => {
     return true;
-  };
+  }, "validMessage");
   const validMessages = messages.filter(validMessage);
   for (const message of validMessages) {
     switch (message.type) {
@@ -107,27 +131,51 @@ var packagePublint = async (params) => {
     console.log(chalk4.gray(`Publint [Finish]: ${pkgDir} [${validMessages.length}]`));
   }
   return validMessages.filter((message) => message.type === "error").length;
-};
+}, "packagePublint");
 
 // src/actions/package/compile/packageCompileTsup.ts
+import chalk8 from "chalk";
 import { build, defineConfig } from "tsup";
 
 // src/actions/package/compile/inputs.ts
+import chalk5 from "chalk";
 import { glob as glob2 } from "glob";
-var getAllInputs = (folder) => {
-  return glob2.sync(`${folder}/**/*.*`, { posix: true });
-};
+var getAllInputs = /* @__PURE__ */ __name((srcDir, verbose = false) => {
+  return [
+    ...glob2.sync(`${srcDir}/**/*.ts`, {
+      posix: true
+    }).map((file) => {
+      const result = file.slice(Math.max(0, srcDir.length + 1));
+      if (verbose) {
+        console.log(chalk5.gray(`getAllInputs: ${JSON.stringify(result, null, 2)}`));
+      }
+      return result;
+    }),
+    ...glob2.sync(`${srcDir}/**/*.tsx`, {
+      posix: true
+    }).map((file) => {
+      const result = file.slice(Math.max(0, srcDir.length + 1));
+      if (verbose) {
+        console.log(chalk5.gray(`getAllInputs: ${JSON.stringify(result, null, 2)}`));
+      }
+      return result;
+    })
+  ];
+}, "getAllInputs");
 
 // src/actions/package/compile/buildEntries.ts
-var buildEntries = (folder, entryMode = "single", options, excludeSpecAndStories = true, verbose = false) => {
+var buildEntries = /* @__PURE__ */ __name((srcDir, entryMode = "single", options, excludeSpecAndStories = true, verbose = false) => {
   let entries = [];
   switch (entryMode) {
     case "platform": {
-      entries = [`${folder}/index-node.ts`, `${folder}/index-browser.ts`];
+      entries = [
+        "index-node.ts",
+        "index-browser.ts"
+      ];
       break;
     }
     case "all": {
-      entries = excludeSpecAndStories ? getAllInputs(folder).filter((entry) => !entry.includes(".spec.") && !entry.includes(".stories.")) : getAllInputs(folder);
+      entries = (excludeSpecAndStories ? getAllInputs(srcDir).filter((entry) => !entry.includes(".spec.") && !entry.includes(".stories.")) : getAllInputs(srcDir)).filter((entry) => !entry.endsWith(".d.ts"));
       break;
     }
     case "custom": {
@@ -135,7 +183,9 @@ var buildEntries = (folder, entryMode = "single", options, excludeSpecAndStories
       break;
     }
     default: {
-      entries = [`${folder}/index.ts`];
+      entries = [
+        "index.ts"
+      ];
       break;
     }
   }
@@ -144,7 +194,7 @@ var buildEntries = (folder, entryMode = "single", options, excludeSpecAndStories
   }
   if (verbose) console.log(`buildEntries [${entryMode}] ${entries.length}`);
   return entries;
-};
+}, "buildEntries");
 
 // src/actions/package/compile/deepMerge.ts
 function deepMerge(target, source) {
@@ -161,6 +211,7 @@ function deepMerge(target, source) {
   }
   return target;
 }
+__name(deepMerge, "deepMerge");
 function deepMergeObjects(objects) {
   const result = {};
   for (const obj of objects) {
@@ -168,167 +219,335 @@ function deepMergeObjects(objects) {
   }
   return result;
 }
+__name(deepMergeObjects, "deepMergeObjects");
 
-// src/actions/package/compile/packageCompileTscTypes.ts
+// src/actions/package/compile/packageCompileTsc.ts
+import { cwd as cwd2 } from "process";
+import chalk6 from "chalk";
+import { createProgramFromConfig } from "tsc-prog";
+import ts, { DiagnosticCategory, formatDiagnosticsWithColorAndContext, getPreEmitDiagnostics, sys } from "typescript";
+
+// src/actions/package/compile/getCompilerOptions.ts
 import { cwd } from "process";
+import deepmerge2 from "deepmerge";
+import { getTsconfig } from "get-tsconfig";
+var getCompilerOptions = /* @__PURE__ */ __name((options = {}, fileName = "tsconfig.json") => {
+  const resolvedTsConfigCompilerOptions = getTsconfig(cwd(), fileName)?.config?.compilerOptions ?? {};
+  return deepmerge2(resolvedTsConfigCompilerOptions, options);
+}, "getCompilerOptions");
+
+// src/actions/package/compile/packageCompileTsc.ts
+var packageCompileTsc = /* @__PURE__ */ __name((platform, entries, srcDir = "src", outDir = "dist", compilerOptionsParam, verbose = false) => {
+  const pkg = process.env.INIT_CWD ?? cwd2();
+  if (verbose) {
+    console.log(chalk6.cyan(`Validating code START: ${entries.length} files to ${outDir} from ${srcDir}`));
+  }
+  const configFilePath = ts.findConfigFile("./", ts.sys.fileExists, "tsconfig.json");
+  if (configFilePath === void 0) {
+    throw new Error("Could not find tsconfig.json");
+  }
+  const compilerOptions = {
+    ...getCompilerOptions({
+      removeComments: false,
+      skipDefaultLibCheck: true,
+      skipLibCheck: true,
+      sourceMap: false
+    }),
+    ...compilerOptionsParam,
+    outDir: `${outDir}/${platform}`,
+    emitDeclarationOnly: true,
+    noEmit: false
+  };
+  console.log(chalk6.cyan(`Validating Files: ${entries.length}`));
+  if (verbose) {
+    for (const entry of entries) {
+      console.log(chalk6.grey(`Validating: ${entry}`));
+    }
+  }
+  try {
+    if (entries.length > 0) {
+      const program = createProgramFromConfig({
+        configFilePath,
+        basePath: pkg ?? cwd2(),
+        compilerOptions,
+        files: entries.map((entry) => `${srcDir}/${entry}`),
+        include: [
+          `${srcDir}/**/*.*`
+        ]
+      });
+      const diagnostics = getPreEmitDiagnostics(program);
+      if (diagnostics.length > 0) {
+        const formattedDiagnostics = formatDiagnosticsWithColorAndContext(diagnostics, {
+          getCanonicalFileName: /* @__PURE__ */ __name((fileName) => fileName, "getCanonicalFileName"),
+          getCurrentDirectory: /* @__PURE__ */ __name(() => srcDir, "getCurrentDirectory"),
+          getNewLine: /* @__PURE__ */ __name(() => sys.newLine, "getNewLine")
+        });
+        console.error(formattedDiagnostics);
+      }
+      program.emit();
+      return diagnostics.reduce((acc, diag) => acc + (diag.category === DiagnosticCategory.Error ? 1 : 0), 0);
+    }
+    return 0;
+  } finally {
+    if (verbose) {
+      console.log(chalk6.cyan(`Validating code FINISH: ${entries.length} files to ${outDir} from ${srcDir}`));
+    }
+  }
+}, "packageCompileTsc");
+
+// src/actions/package/compile/packageCompileTscTypes.ts
+import path3 from "path";
+import { cwd as cwd3 } from "process";
+import chalk7 from "chalk";
 import { rollup } from "rollup";
 import dts from "rollup-plugin-dts";
 import nodeExternals from "rollup-plugin-node-externals";
-async function bundleDts(inputPath, outputPath, platform) {
-  const nodePlugIns = platform === "node" ? [nodeExternals()] : [];
-  const bundle = await rollup({
-    input: inputPath,
-    plugins: [dts(), ...nodePlugIns],
-    onwarn(warning, warn) {
-      if (warning.code === "UNUSED_EXTERNAL_IMPORT") return;
-      warn(warning);
-    }
-  });
-  await bundle.write({
-    file: outputPath,
-    format: "es"
-  });
-  console.log(`Bundled declarations written to ${outputPath}`);
+var ignoredWarningCodes = /* @__PURE__ */ new Set([
+  "EMPTY_BUNDLE",
+  "UNRESOLVED_IMPORT"
+]);
+async function bundleDts(inputPath, outputPath, platform, options, verbose = false) {
+  const pkg = process.env.INIT_CWD ?? cwd3();
+  const tsconfigPath = path3.resolve(pkg, "tsconfig.json");
+  const nodePlugIns = platform === "node" ? [
+    nodeExternals()
+  ] : [];
+  try {
+    const bundle = await rollup({
+      input: inputPath,
+      plugins: [
+        dts({
+          ...options,
+          tsconfig: tsconfigPath,
+          compilerOptions: {
+            emitDeclarationOnly: true,
+            noEmit: false,
+            declarationMap: true
+          }
+        }),
+        ...nodePlugIns
+      ],
+      onwarn(warning, warn) {
+        if (ignoredWarningCodes.has(warning.code ?? "")) {
+          return;
+        }
+        console.warn(chalk7.yellow(`[${warning.code}] ${warning.message}`));
+        console.warn(chalk7.gray(inputPath));
+        warn(warning);
+      }
+    });
+    await bundle.write({
+      file: outputPath,
+      format: "es"
+    });
+  } catch (ex) {
+    const error = ex;
+    console.warn(chalk7.red(error));
+    console.warn(chalk7.gray(inputPath));
+  }
+  if (verbose) {
+    console.log(`Bundled declarations written to ${outputPath}`);
+  }
 }
-var packageCompileTscTypes = async (entries, outDir, platform, folder = "src") => {
-  const pkg = process.env.INIT_CWD ?? cwd();
-  const srcRoot = `${pkg}/${folder}`;
-  const entryNameToTypeName = (entry) => {
+__name(bundleDts, "bundleDts");
+var packageCompileTscTypes = /* @__PURE__ */ __name(async (entries, outDir, platform, srcDir = "build", verbose = false) => {
+  if (verbose) {
+    console.log(chalk7.cyan(`Compiling Types START [${platform}]: ${entries.length} files to ${outDir} from ${srcDir}`));
+    console.log(`Entries: ${entries.join(", ")}`);
+  }
+  const pkg = process.env.INIT_CWD ?? cwd3();
+  const srcRoot = `${pkg}/${srcDir}/${platform}`;
+  const entryNameToTypeName = /* @__PURE__ */ __name((entry) => {
     const splitEntryName = entry.split(".");
     const newEntryExtension = "d." + splitEntryName.at(-1);
-    return [...splitEntryName.slice(0, -1), newEntryExtension].join(".");
-  };
-  const entryNames = entries.map((entry) => entry.split(`${folder}/`).at(-1) ?? entry);
+    return [
+      ...splitEntryName.slice(0, -1),
+      newEntryExtension
+    ].join(".");
+  }, "entryNameToTypeName");
+  const compilerOptions = getCompilerOptions({
+    removeComments: false,
+    skipDefaultLibCheck: true,
+    skipLibCheck: true,
+    declarationMap: true,
+    emitDeclarationOnly: true,
+    noEmit: true
+  });
+  const entryNames = entries.map((entry) => entry.split(`${srcDir}/`).at(-1) ?? entry);
   await Promise.all(entryNames.map(async (entryName) => {
-    await bundleDts(`${srcRoot}/${entryName}`, outDir + "/" + entryNameToTypeName(entryName), platform);
+    const entryTypeName = entryNameToTypeName(entryName);
+    await bundleDts(`${srcRoot}/${entryTypeName}`, `${outDir}/${entryTypeName}`, platform, {
+      compilerOptions
+    }, verbose);
   }));
+  if (verbose) {
+    console.log(chalk7.cyan(`Compiling Types FINISH: ${entries.length} files to ${outDir} from ${srcDir}`));
+  }
   return 0;
-};
+}, "packageCompileTscTypes");
 
 // src/actions/package/compile/packageCompileTsup.ts
-var compileFolder = async (folder, entries, options, verbose) => {
+var compileFolder = /* @__PURE__ */ __name(async (srcDir, entries, buildDir, options, bundleTypes = false, verbose) => {
   const outDir = options?.outDir ?? "dist";
   if (verbose) {
-    console.log(`compileFolder [${folder}]`);
+    console.log(`compileFolder [${srcDir}, ${options?.outDir}]`);
+  }
+  if (entries.length === 0) {
+    console.warn(chalk8.yellow(`No entries found in ${srcDir} to compile`));
+    return 0;
   }
-  const optionsResult = defineConfig({
-    bundle: true,
-    cjsInterop: true,
-    clean: true,
-    dts: false,
-    entry: entries,
-    format: ["esm"],
-    outDir,
-    silent: true,
-    sourcemap: true,
-    splitting: false,
-    tsconfig: "tsconfig.json",
-    ...options
-  });
-  const optionsList = (await Promise.all(
-    (Array.isArray(optionsResult) ? optionsResult : [optionsResult]).flatMap(async (options2) => {
-      const result = typeof options2 === "function" ? await options2({}) : [options2];
-      return Array.isArray(result) ? result : [result];
-    })
-  )).flat();
   if (verbose) {
-    console.log(`TSUP:build:start [${folder}]`);
+    console.log(chalk8.gray(`buildDir [${buildDir}]`));
+  }
+  const validationResult = packageCompileTsc(options?.platform ?? "neutral", entries, srcDir, buildDir, void 0, verbose);
+  if (validationResult !== 0) {
+    console.error(chalk8.red(`Compile:Validation had ${validationResult} errors`));
+    return validationResult;
+  }
+  const optionsParams = tsupOptions([
+    {
+      bundle: true,
+      cjsInterop: true,
+      clean: false,
+      dts: false,
+      format: [
+        "esm"
+      ],
+      outDir,
+      silent: true,
+      sourcemap: true,
+      splitting: false,
+      tsconfig: "tsconfig.json",
+      ...options,
+      entry: entries.map((entry) => `${srcDir}/${entry}`)
+    }
+  ]);
+  const optionsResult = defineConfig(optionsParams);
+  const optionsList = (await Promise.all((Array.isArray(optionsResult) ? optionsResult : [
+    optionsResult
+  ]).flatMap(async (options2) => {
+    const result = typeof options2 === "function" ? await options2({}) : [
+      options2
+    ];
+    return Array.isArray(result) ? result : [
+      result
+    ];
+  }))).flat();
+  if (verbose) {
+    console.log(chalk8.cyan(`TSUP:build:start [${srcDir}]`));
+    console.log(chalk8.gray(`TSUP:build:options [${JSON.stringify(optionsList, null, 2)}]`));
   }
   await Promise.all(optionsList.map((options2) => build(options2)));
   if (verbose) {
-    console.log(`TSUP:build:stop [${folder}]`);
+    console.log(chalk8.cyan(`TSUP:build:stop [${srcDir}]`));
+  }
+  if (bundleTypes) {
+    await packageCompileTscTypes(entries, outDir, options?.platform ?? "neutral", buildDir, verbose);
   }
-  await packageCompileTscTypes(entries, outDir, options?.platform ?? "neutral", folder);
   return 0;
-};
-var tsupOptions = (options = []) => {
+}, "compileFolder");
+var tsupOptions = /* @__PURE__ */ __name((options = []) => {
   const standardLoaders = {
     ".gif": "copy",
     ".html": "copy",
     ".jpg": "copy",
     ".json": "json",
     ".png": "copy",
-    ".svg": "copy",
+    ".svg": "text",
     ".webp": "copy"
   };
   const standardOptions = {
     bundle: true,
-    format: ["esm"],
+    format: [
+      "esm"
+    ],
     loader: standardLoaders,
-    outExtension: ({ format }) => format === "esm" ? { js: ".mjs" } : { js: ".cjs" },
+    outExtension: /* @__PURE__ */ __name(({ format }) => format === "esm" ? {
+      js: ".mjs"
+    } : {
+      js: ".cjs"
+    }, "outExtension"),
     skipNodeModulesBundle: true,
     sourcemap: true,
     target: "esnext"
   };
-  return deepMergeObjects([standardOptions, ...options]);
-};
-var packageCompileTsup = async (config2) => {
+  return deepMergeObjects([
+    standardOptions,
+    ...options
+  ]);
+}, "tsupOptions");
+var packageCompileTsup = /* @__PURE__ */ __name(async (config2) => {
   const compile = config2?.compile;
   const verbose = config2?.verbose ?? false;
+  const outDirAsBuildDir = compile?.outDirAsBuildDir ?? true;
+  const bundleTypes = compile?.bundleTypes ?? false;
   if (verbose) {
-    console.log(`Compiling with TSUP [Depth: ${compile?.depth}]`);
+    console.log("Compiling with TSUP");
   }
-  const compileForNode = compile?.node ?? { src: {} };
-  const compileForBrowser = compile?.browser ?? { src: {} };
-  const compileForNeutral = compile?.neutral ?? { src: {} };
-  if (verbose) {
-    console.log("Calling packageCompileTscTypes");
-  }
-  return (await Promise.all(
-    Object.entries(compileForNode).map(async ([folder, options]) => {
-      const optionsObject = typeof options === "object" ? options : {};
-      const inEsBuildOptions = typeof compile?.node?.esbuildOptions === "object" ? compile?.node?.esbuildOptions : {};
-      return typeof folder === "string" ? await compileFolder(
-        folder,
-        buildEntries(folder, compile?.entryMode, options, true, verbose),
-        tsupOptions([
-          inEsBuildOptions,
-          compile?.tsup?.options ?? {},
-          typeof options === "object" ? options : {},
-          { platform: "node", outDir: optionsObject.outDir ?? "dist/node" }
-        ]),
-        verbose
-      ) : 0;
-    })
-  )).reduce((prev, value) => prev + value, 0) + (await Promise.all(
-    Object.entries(compileForBrowser).map(async ([folder, options]) => {
-      const optionsObject = typeof options === "object" ? options : {};
-      const inEsBuildOptions = typeof compile?.browser?.esbuildOptions === "object" ? compile?.browser?.esbuildOptions : {};
-      return typeof folder === "string" ? await compileFolder(
-        folder,
-        buildEntries(folder, compile?.entryMode, options, true, verbose),
-        tsupOptions([
-          inEsBuildOptions,
-          compile?.tsup?.options ?? {},
-          typeof options === "object" ? options : {},
-          { platform: "browser", outDir: optionsObject.outDir ?? "dist/browser" }
-        ]),
-        verbose
-      ) : 0;
-    })
-  )).reduce((prev, value) => prev + value, 0) + (await Promise.all(
-    Object.entries(compileForNeutral).map(async ([folder, options]) => {
-      const optionsObject = typeof options === "object" ? options : {};
-      const inEsBuildOptions = typeof compile?.neutral?.esbuildOptions === "object" ? compile?.neutral?.esbuildOptions : {};
-      return typeof folder === "string" ? await compileFolder(
-        folder,
-        buildEntries(folder, compile?.entryMode, options, true, verbose),
-        tsupOptions([
-          inEsBuildOptions,
-          compile?.tsup?.options ?? {},
-          typeof options === "object" ? options : {},
-          { platform: "neutral", outDir: optionsObject.outDir ?? "dist/neutral" }
-        ]),
-        verbose
-      ) : 0;
-    })
-  )).reduce((prev, value) => prev + value, 0) + 0;
-};
+  const compileForNode = compile?.node ?? {
+    src: {}
+  };
+  const compileForBrowser = compile?.browser ?? {
+    src: {}
+  };
+  const compileForNeutral = compile?.neutral ?? {
+    src: {}
+  };
+  return (await Promise.all(Object.entries(compileForNode).map(async ([srcDir, options]) => {
+    const optionsObject = typeof options === "object" ? options : {};
+    const inEsBuildOptions = typeof compile?.node?.esbuildOptions === "object" ? compile?.node?.esbuildOptions : {};
+    const entry = buildEntries(srcDir, compile?.entryMode, options, true, verbose);
+    const platform = "node";
+    const rootOutDir = optionsObject.outDir ?? "dist";
+    const outDir = rootOutDir + "/" + platform;
+    return typeof srcDir === "string" ? await compileFolder(srcDir, entry, outDirAsBuildDir ? rootOutDir : "build", tsupOptions([
+      inEsBuildOptions,
+      compile?.tsup?.options ?? {},
+      typeof options === "object" ? options : {},
+      {
+        platform: "node",
+        outDir
+      }
+    ]), bundleTypes, verbose) : 0;
+  }))).reduce((prev, value) => prev + value, 0) + (await Promise.all(Object.entries(compileForBrowser).map(async ([srcDir, options]) => {
+    const optionsObject = typeof options === "object" ? options : {};
+    const inEsBuildOptions = typeof compile?.browser?.esbuildOptions === "object" ? compile?.browser?.esbuildOptions : {};
+    const entry = buildEntries(srcDir, compile?.entryMode, options, true, verbose);
+    const platform = "browser";
+    const rootOutDir = optionsObject.outDir ?? "dist";
+    const outDir = rootOutDir + "/" + platform;
+    return typeof srcDir === "string" ? await compileFolder(srcDir, entry, outDirAsBuildDir ? rootOutDir : "build", tsupOptions([
+      inEsBuildOptions,
+      compile?.tsup?.options ?? {},
+      typeof options === "object" ? options : {},
+      {
+        platform: "browser",
+        outDir
+      }
+    ]), bundleTypes, verbose) : 0;
+  }))).reduce((prev, value) => prev + value, 0) + (await Promise.all(Object.entries(compileForNeutral).map(async ([srcDir, options]) => {
+    const optionsObject = typeof options === "object" ? options : {};
+    const inEsBuildOptions = typeof compile?.neutral?.esbuildOptions === "object" ? compile?.neutral?.esbuildOptions : {};
+    const entry = buildEntries(srcDir, compile?.entryMode, options, true, verbose);
+    const platform = "neutral";
+    const rootOutDir = optionsObject.outDir ?? "dist";
+    const outDir = rootOutDir + "/" + platform;
+    return typeof srcDir === "string" ? await compileFolder(srcDir, entry, outDirAsBuildDir ? rootOutDir : "build", tsupOptions([
+      inEsBuildOptions,
+      compile?.tsup?.options ?? {},
+      typeof options === "object" ? options : {},
+      {
+        platform: "neutral",
+        outDir
+      }
+    ]), bundleTypes, verbose) : 0;
+  }))).reduce((prev, value) => prev + value, 0) + 0;
+}, "packageCompileTsup");
 
 // src/actions/package/compile/compile.ts
-var packageCompile = async (inConfig = {}) => {
+var packageCompile = /* @__PURE__ */ __name(async (inConfig = {}) => {
   const pkg = process.env.INIT_CWD;
-  console.log(chalk5.green(`Compiling ${pkg}`));
+  console.log(chalk9.green(`Compiling ${pkg}`));
   const config2 = await loadConfig(inConfig);
   const publint = config2.publint;
   const tsupResults = await packageCompileTsup(config2);
@@ -336,106 +555,30 @@ var packageCompile = async (inConfig = {}) => {
     return tsupResults;
   }
   return publint ? await packagePublint(config2) : 0;
-};
-
-// src/actions/package/compile/packageCompileTsc.ts
-import { cwd as cwd2 } from "process";
-import chalk6 from "chalk";
-import { createProgramFromConfig } from "tsc-prog";
-import {
-  DiagnosticCategory,
-  formatDiagnosticsWithColorAndContext,
-  getPreEmitDiagnostics,
-  sys as sys2
-} from "typescript";
-
-// src/actions/package/compile/getCompilerOptions.ts
-import { createRequire } from "module";
-import deepmerge2 from "deepmerge";
-import {
-  findConfigFile,
-  readConfigFile,
-  sys
-} from "typescript";
-var getNested = (config2) => {
-  if (config2.extends) {
-    const require2 = createRequire(import.meta.url);
-    const opts = require2(config2.extends);
-    return deepmerge2(getNested(opts), config2.compilerOptions ?? {});
-  }
-  return config2.compilerOptions;
-};
-var getCompilerOptionsJSONFollowExtends = (filename) => {
-  const config2 = readConfigFile(filename, sys.readFile).config;
-  return getNested(config2);
-};
-var getCompilerOptions = (options = {}, tsconfig = "tsconfig.json") => {
-  const configFileName = findConfigFile("./", sys.fileExists, tsconfig);
-  const configFileCompilerOptions = (configFileName ? getCompilerOptionsJSONFollowExtends(configFileName) : void 0) ?? {};
-  return deepmerge2(configFileCompilerOptions, options);
-};
-
-// src/actions/package/compile/packageCompileTsc.ts
-var packageCompileTsc = (folder = "src", config2 = {}, compilerOptionsParam) => {
-  const pkg = process.env.INIT_CWD ?? cwd2();
-  const verbose = config2?.verbose ?? false;
-  const compilerOptions = {
-    ...getCompilerOptions({
-      outDir: "dist/types",
-      removeComments: false,
-      skipDefaultLibCheck: true,
-      skipLibCheck: true,
-      sourceMap: false
-    }),
-    ...compilerOptionsParam,
-    emitDeclarationOnly: false,
-    noEmit: true
-  };
-  const validTsExt = [".ts", ".tsx", ".d.ts", ".cts", ".d.cts", ".mts", ".d.mts"];
-  const includes = [".stories.", ".spec.", ".d.ts", ".d.cts", ".d.mts"];
-  const files = buildEntries(folder, "all", {}, true, verbose).filter((file) => validTsExt.find((ext) => file.endsWith(ext)) && includes.find((include) => file.includes(include)));
-  console.log(chalk6.green(`Compiling Files ${pkg}: ${files.length}`));
-  if (files.length > 0) {
-    const program = createProgramFromConfig({
-      basePath: pkg ?? cwd2(),
-      compilerOptions,
-      exclude: ["dist", "docs"],
-      files
-    });
-    const diagnostics = getPreEmitDiagnostics(program);
-    if (diagnostics.length > 0) {
-      const formattedDiagnostics = formatDiagnosticsWithColorAndContext(
-        diagnostics,
-        {
-          getCanonicalFileName: (fileName) => fileName,
-          getCurrentDirectory: () => folder,
-          getNewLine: () => sys2.newLine
-        }
-      );
-      console.error(formattedDiagnostics);
-    }
-    program.emit();
-    return diagnostics.reduce((acc, diag) => acc + (diag.category === DiagnosticCategory.Error ? 1 : 0), 0);
-  }
-  return 0;
-};
+}, "packageCompile");
 
 // src/actions/package/copy-assets.ts
-import path3 from "path/posix";
-import chalk7 from "chalk";
+import path4 from "path/posix";
+import chalk10 from "chalk";
 import cpy from "cpy";
-var copyTargetAssets = async (target, name, location) => {
+var copyTargetAssets = /* @__PURE__ */ __name(async (target, name, location) => {
   try {
-    const values = await cpy(
-      ["**/*.jpg", "**/*.png", "**/*.gif", "**/*.svg", "**/*.webp", "**/*.sass", "**/*.scss", "**/*.gif", "**/*.css"],
-      `../dist/${target}`,
-      {
-        cwd: path3.join(location, "src"),
-        flat: false
-      }
-    );
+    const values = await cpy([
+      "**/*.jpg",
+      "**/*.png",
+      "**/*.gif",
+      "**/*.svg",
+      "**/*.webp",
+      "**/*.sass",
+      "**/*.scss",
+      "**/*.gif",
+      "**/*.css"
+    ], `../dist/${target}`, {
+      cwd: path4.join(location, "src"),
+      flat: false
+    });
     if (values.length > 0) {
-      console.log(chalk7.green(`Copying Assets [${target.toUpperCase()}] - ${name} - ${location}`));
+      console.log(chalk10.green(`Copying Assets [${target.toUpperCase()}] - ${name} - ${location}`));
     }
     for (const value of values) {
       console.log(`${value.split("/").pop()} => ./dist/${target}`);
@@ -446,8 +589,8 @@ var copyTargetAssets = async (target, name, location) => {
     console.log(`Copy Assets Failed: ${name}: ${error.message}`);
     return 1;
   }
-};
-var packageCopyAssets = async ({ target }) => {
+}, "copyTargetAssets");
+var packageCopyAssets = /* @__PURE__ */ __name(async ({ target }) => {
   const pkg = process.env.INIT_CWD ?? "./";
   const pkgName = process.env.npm_package_name ?? "Unknown";
   switch (target) {
@@ -461,11 +604,11 @@ var packageCopyAssets = async ({ target }) => {
       return await copyTargetAssets("esm", pkgName, pkg) || await copyTargetAssets("cjs", pkgName, pkg);
     }
   }
-};
+}, "packageCopyAssets");
 
 // src/actions/package/cycle.ts
 import { cruise } from "dependency-cruiser";
-var packageCycle = async ({ verbose = false }) => {
+var packageCycle = /* @__PURE__ */ __name(async () => {
   const pkg = process.env.INIT_CWD;
   const pkgName = process.env.npm_package_name;
   const cruiseOptions = {
@@ -476,41 +619,40 @@ var packageCycle = async ({ verbose = false }) => {
           severity: "error",
           comment: "This dependency creates a circular reference",
           from: {},
-          to: { circular: true }
+          to: {
+            circular: true
+          }
         }
       ]
     },
     exclude: "node_modules|packages/.*/packages",
     validate: true,
-    doNotFollow: { path: "node_modules|packages/.*/packages" },
+    doNotFollow: {
+      path: "node_modules|packages/.*/packages"
+    },
     tsPreCompilationDeps: false,
     combinedDependencies: true,
-    outputType: verbose ? "text" : "err"
+    outputType: "err"
   };
   const target = `${pkg}/src`;
   console.log(`Checking for circular dependencies in ${target}...`);
-  const result = await cruise([target], cruiseOptions);
-  if (result.output) {
-    console.log(result.output);
-  }
+  const result = await cruise([
+    target
+  ], cruiseOptions);
+  console.log(result.output);
   if (result.exitCode === 0) {
     console.log(`${pkgName} \u2705 No dependency violations`);
   } else {
     console.error(`${pkgName} \u274C Dependency violations found`);
   }
   return result.exitCode;
-};
+}, "packageCycle");
 
 // src/actions/package/gen-docs.ts
 import { existsSync } from "fs";
-import path4 from "path";
-import chalk8 from "chalk";
-import {
-  Application,
-  ArgumentsReader,
-  TSConfigReader,
-  TypeDocReader
-} from "typedoc";
+import path5 from "path";
+import chalk11 from "chalk";
+import { Application, ArgumentsReader, TSConfigReader, TypeDocReader } from "typedoc";
 var ExitCodes = {
   CompileError: 3,
   ExceptionThrown: 6,
@@ -520,14 +662,17 @@ var ExitCodes = {
   OutputError: 5,
   ValidationError: 4
 };
-var packageGenDocs = async () => {
+var packageGenDocs = /* @__PURE__ */ __name(async () => {
   const pkg = process.env.INIT_CWD;
-  if (pkg && !existsSync(path4.join(pkg, "typedoc.json"))) {
+  if (pkg && !existsSync(path5.join(pkg, "typedoc.json"))) {
     return;
   }
   const app = await Application.bootstrap({
     entryPointStrategy: "merge",
-    entryPoints: [`${pkg}/src/**/*.ts`, `${pkg}/packages/*/dist/docs.json`],
+    entryPoints: [
+      `${pkg}/src/**/*.ts`,
+      `${pkg}/packages/*/dist/docs.json`
+    ],
     excludeExternals: true,
     json: `${pkg}/dist/docs.json`,
     logLevel: "Error",
@@ -538,8 +683,8 @@ var packageGenDocs = async () => {
   app.options.addReader(new TSConfigReader());
   app.options.addReader(new ArgumentsReader(300));
   return await runTypeDoc(app);
-};
-var runTypeDoc = async (app) => {
+}, "packageGenDocs");
+var runTypeDoc = /* @__PURE__ */ __name(async (app) => {
   const pkgName = process.env.npm_package_name;
   if (app.options.getValue("version")) {
     console.log(app.toString());
@@ -608,37 +753,40 @@ var runTypeDoc = async (app) => {
       return ExitCodes.OutputError;
     }
   }
-  console.log(chalk8.green(`${pkgName} - Ok`));
+  console.log(chalk11.green(`${pkgName} - Ok`));
   return ExitCodes.Ok;
-};
+}, "runTypeDoc");
 
 // src/actions/package/lint.ts
 import { readdirSync } from "fs";
-import path5 from "path";
-import { cwd as cwd3 } from "process";
+import path6 from "path";
+import { cwd as cwd4 } from "process";
 import { pathToFileURL } from "url";
-import chalk9 from "chalk";
+import chalk12 from "chalk";
 import { ESLint } from "eslint";
 import { findUp } from "find-up";
 import picomatch from "picomatch";
-var dumpMessages = (lintResults) => {
-  const colors = ["white", "yellow", "red"];
-  const severity = ["none", "warning", "error"];
+var dumpMessages = /* @__PURE__ */ __name((lintResults) => {
+  const colors = [
+    "white",
+    "yellow",
+    "red"
+  ];
+  const severity = [
+    "none",
+    "warning",
+    "error"
+  ];
   for (const lintResult of lintResults) {
     if (lintResult.messages.length > 0) {
-      console.log(chalk9.gray(`
+      console.log(chalk12.gray(`
 ${lintResult.filePath}`));
       for (const message of lintResult.messages) {
-        console.log(
-          chalk9.gray(`	${message.line}:${message.column}`),
-          chalk9[colors[message.severity]](`	${severity[message.severity]}`),
-          chalk9.white(`	${message.message}`),
-          chalk9.gray(`	${message.ruleId}`)
-        );
+        console.log(chalk12.gray(`	${message.line}:${message.column}`), chalk12[colors[message.severity]](`	${severity[message.severity]}`), chalk12.white(`	${message.message}`), chalk12.gray(`	${message.ruleId}`));
       }
     }
   }
-};
+}, "dumpMessages");
 async function getRootESLintConfig() {
   const configPath = await findUp("eslint.config.mjs");
   if (configPath === void 0) {
@@ -646,33 +794,50 @@ async function getRootESLintConfig() {
   }
   return pathToFileURL(configPath);
 }
+__name(getRootESLintConfig, "getRootESLintConfig");
 function getFiles(dir, ignoreFolders) {
-  const currentDirectory = cwd3();
+  const currentDirectory = cwd4();
   const subDirectory = dir.split(currentDirectory)[1];
   if (ignoreFolders.includes(subDirectory)) return [];
-  return readdirSync(dir, { withFileTypes: true }).flatMap((dirent) => {
-    const res = path5.resolve(dir, dirent.name);
+  return readdirSync(dir, {
+    withFileTypes: true
+  }).flatMap((dirent) => {
+    const res = path6.resolve(dir, dirent.name);
     const relativePath = subDirectory === void 0 ? dirent.name : `${subDirectory}/${dirent.name}`;
     const ignoreMatchers = ignoreFolders.map((pattern) => picomatch(pattern));
     if (ignoreMatchers.some((isMatch) => isMatch(relativePath))) return [];
-    return dirent.isDirectory() ? getFiles(res, ignoreFolders) : [res];
+    return dirent.isDirectory() ? getFiles(res, ignoreFolders) : [
+      res
+    ];
   });
 }
-var packageLint = async (fix = false, verbose = false, cache = true) => {
+__name(getFiles, "getFiles");
+var packageLint = /* @__PURE__ */ __name(async (fix = false, verbose = false, cache = true) => {
   const pkg = process.env.INIT_CWD;
   const configPath = await getRootESLintConfig();
   const { default: eslintConfig } = await import(configPath.href);
   const start = Date.now();
-  const ignoreFolders = ["node_modules", "dist", "packages", ".git", "build", ".yarn", ".vscode", ".github"];
+  const ignoreFolders = [
+    "node_modules",
+    "dist",
+    "packages",
+    ".git",
+    "build",
+    ".yarn",
+    ".vscode",
+    ".github"
+  ];
   const engine = new ESLint({
-    baseConfig: [...eslintConfig],
+    baseConfig: [
+      ...eslintConfig
+    ],
     fix,
     warnIgnored: false,
     cache
   });
-  const files = getFiles(cwd3(), ignoreFolders);
+  const files = getFiles(cwd4(), ignoreFolders);
   if (verbose) {
-    console.log(chalk9.green(`Linting ${pkg} [files = ${files.length}]`));
+    console.log(chalk12.green(`Linting ${pkg} [files = ${files.length}]`));
   }
   const lintResults = await engine.lintFiles(files);
   dumpMessages(lintResults);
@@ -682,14 +847,14 @@ var packageLint = async (fix = false, verbose = false, cache = true) => {
   const filesCountColor = files.length < 100 ? "green" : files.length < 1e3 ? "yellow" : "red";
   const lintTime = Date.now() - start;
   const lintTimeColor = lintTime < 1e3 ? "green" : lintTime < 3e3 ? "yellow" : "red";
-  console.log(chalk9.white(`Linted ${chalk9[filesCountColor](files.length)} files in ${chalk9[lintTimeColor](lintTime)}ms`));
+  console.log(chalk12.white(`Linted ${chalk12[filesCountColor](files.length)} files in ${chalk12[lintTimeColor](lintTime)}ms`));
   return lintResults.reduce((prev, lintResult) => prev + lintResult.errorCount, 0);
-};
+}, "packageLint");
 
 // src/actions/package/recompile.ts
-var packageRecompile = async () => {
+var packageRecompile = /* @__PURE__ */ __name(async () => {
   return await packageClean() || await packageCompile();
-};
+}, "packageRecompile");
 export {
   bundleDts,
   packageClean,